]> 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
remove targets before cp, mv and ln, otherwise ambiguous links and
[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_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBitmap swig_types[12]
2479 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2480 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2481 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2482 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2483 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2484 #define SWIGTYPE_p_wxCaret swig_types[18]
2485 #define SWIGTYPE_p_wxChar swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboard swig_types[21]
2488 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[23]
2490 #define SWIGTYPE_p_wxCloseEvent swig_types[24]
2491 #define SWIGTYPE_p_wxColour swig_types[25]
2492 #define SWIGTYPE_p_wxCommandEvent swig_types[26]
2493 #define SWIGTYPE_p_wxConfig swig_types[27]
2494 #define SWIGTYPE_p_wxConfigBase swig_types[28]
2495 #define SWIGTYPE_p_wxConfigPathChanger swig_types[29]
2496 #define SWIGTYPE_p_wxContextMenuEvent swig_types[30]
2497 #define SWIGTYPE_p_wxControl swig_types[31]
2498 #define SWIGTYPE_p_wxControlWithItems swig_types[32]
2499 #define SWIGTYPE_p_wxCursor swig_types[33]
2500 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
2501 #define SWIGTYPE_p_wxDC swig_types[35]
2502 #define SWIGTYPE_p_wxDataFormat swig_types[36]
2503 #define SWIGTYPE_p_wxDataObject swig_types[37]
2504 #define SWIGTYPE_p_wxDataObjectComposite swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectSimple swig_types[39]
2506 #define SWIGTYPE_p_wxDateEvent swig_types[40]
2507 #define SWIGTYPE_p_wxDateSpan swig_types[41]
2508 #define SWIGTYPE_p_wxDateTime swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[43]
2510 #define SWIGTYPE_p_wxDisplay swig_types[44]
2511 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[45]
2512 #define SWIGTYPE_p_wxDropFilesEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDuplexMode swig_types[47]
2514 #define SWIGTYPE_p_wxEraseEvent swig_types[48]
2515 #define SWIGTYPE_p_wxEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvtHandler swig_types[50]
2517 #define SWIGTYPE_p_wxFSFile swig_types[51]
2518 #define SWIGTYPE_p_wxFileConfig swig_types[52]
2519 #define SWIGTYPE_p_wxFileDataObject swig_types[53]
2520 #define SWIGTYPE_p_wxFileHistory swig_types[54]
2521 #define SWIGTYPE_p_wxFileSystem swig_types[55]
2522 #define SWIGTYPE_p_wxFileType swig_types[56]
2523 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
2524 #define SWIGTYPE_p_wxFlexGridSizer swig_types[58]
2525 #define SWIGTYPE_p_wxFocusEvent swig_types[59]
2526 #define SWIGTYPE_p_wxFont swig_types[60]
2527 #define SWIGTYPE_p_wxFrame swig_types[61]
2528 #define SWIGTYPE_p_wxGBSizerItem swig_types[62]
2529 #define SWIGTYPE_p_wxGIFHandler swig_types[63]
2530 #define SWIGTYPE_p_wxGridBagSizer swig_types[64]
2531 #define SWIGTYPE_p_wxGridSizer swig_types[65]
2532 #define SWIGTYPE_p_wxICOHandler swig_types[66]
2533 #define SWIGTYPE_p_wxIcon swig_types[67]
2534 #define SWIGTYPE_p_wxIconizeEvent swig_types[68]
2535 #define SWIGTYPE_p_wxIdleEvent swig_types[69]
2536 #define SWIGTYPE_p_wxImage swig_types[70]
2537 #define SWIGTYPE_p_wxImageHandler swig_types[71]
2538 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[72]
2539 #define SWIGTYPE_p_wxInitDialogEvent swig_types[73]
2540 #define SWIGTYPE_p_wxJPEGHandler swig_types[74]
2541 #define SWIGTYPE_p_wxJoystick swig_types[75]
2542 #define SWIGTYPE_p_wxJoystickEvent swig_types[76]
2543 #define SWIGTYPE_p_wxKeyEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKillError swig_types[78]
2545 #define SWIGTYPE_p_wxLayoutConstraints swig_types[79]
2546 #define SWIGTYPE_p_wxLog swig_types[80]
2547 #define SWIGTYPE_p_wxLogBuffer swig_types[81]
2548 #define SWIGTYPE_p_wxLogChain swig_types[82]
2549 #define SWIGTYPE_p_wxLogGui swig_types[83]
2550 #define SWIGTYPE_p_wxLogNull swig_types[84]
2551 #define SWIGTYPE_p_wxLogStderr swig_types[85]
2552 #define SWIGTYPE_p_wxLogTextCtrl swig_types[86]
2553 #define SWIGTYPE_p_wxLogWindow swig_types[87]
2554 #define SWIGTYPE_p_wxMaximizeEvent swig_types[88]
2555 #define SWIGTYPE_p_wxMenu swig_types[89]
2556 #define SWIGTYPE_p_wxMenuBar swig_types[90]
2557 #define SWIGTYPE_p_wxMenuEvent swig_types[91]
2558 #define SWIGTYPE_p_wxMenuItem swig_types[92]
2559 #define SWIGTYPE_p_wxMetafileDataObject swig_types[93]
2560 #define SWIGTYPE_p_wxMimeTypesManager swig_types[94]
2561 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseState swig_types[98]
2565 #define SWIGTYPE_p_wxMoveEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[100]
2567 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
2568 #define SWIGTYPE_p_wxNcPaintEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNotifyEvent swig_types[103]
2570 #define SWIGTYPE_p_wxObject swig_types[104]
2571 #define SWIGTYPE_p_wxOutputStream swig_types[105]
2572 #define SWIGTYPE_p_wxPCXHandler swig_types[106]
2573 #define SWIGTYPE_p_wxPNGHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNMHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPaintEvent swig_types[109]
2576 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaperSize swig_types[111]
2578 #define SWIGTYPE_p_wxPlatformInfo swig_types[112]
2579 #define SWIGTYPE_p_wxPoint swig_types[113]
2580 #define SWIGTYPE_p_wxPowerEvent swig_types[114]
2581 #define SWIGTYPE_p_wxProcessEvent swig_types[115]
2582 #define SWIGTYPE_p_wxPyApp swig_types[116]
2583 #define SWIGTYPE_p_wxPyArtProvider swig_types[117]
2584 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[118]
2585 #define SWIGTYPE_p_wxPyCommandEvent swig_types[119]
2586 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[120]
2587 #define SWIGTYPE_p_wxPyDropSource swig_types[121]
2588 #define SWIGTYPE_p_wxPyDropTarget swig_types[122]
2589 #define SWIGTYPE_p_wxPyEvent swig_types[123]
2590 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[124]
2591 #define SWIGTYPE_p_wxPyImageHandler swig_types[125]
2592 #define SWIGTYPE_p_wxPyLog swig_types[126]
2593 #define SWIGTYPE_p_wxPyProcess swig_types[127]
2594 #define SWIGTYPE_p_wxPySizer swig_types[128]
2595 #define SWIGTYPE_p_wxPyTextDataObject swig_types[129]
2596 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[130]
2597 #define SWIGTYPE_p_wxPyTimer swig_types[131]
2598 #define SWIGTYPE_p_wxPyTipProvider swig_types[132]
2599 #define SWIGTYPE_p_wxPyValidator swig_types[133]
2600 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[134]
2601 #define SWIGTYPE_p_wxRect swig_types[135]
2602 #define SWIGTYPE_p_wxScrollEvent swig_types[136]
2603 #define SWIGTYPE_p_wxScrollWinEvent swig_types[137]
2604 #define SWIGTYPE_p_wxSetCursorEvent swig_types[138]
2605 #define SWIGTYPE_p_wxShowEvent swig_types[139]
2606 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[140]
2607 #define SWIGTYPE_p_wxSize swig_types[141]
2608 #define SWIGTYPE_p_wxSizeEvent swig_types[142]
2609 #define SWIGTYPE_p_wxSizer swig_types[143]
2610 #define SWIGTYPE_p_wxSizerItem swig_types[144]
2611 #define SWIGTYPE_p_wxSound swig_types[145]
2612 #define SWIGTYPE_p_wxStandardPaths swig_types[146]
2613 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[147]
2614 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[148]
2615 #define SWIGTYPE_p_wxStopWatch swig_types[149]
2616 #define SWIGTYPE_p_wxString swig_types[150]
2617 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[151]
2618 #define SWIGTYPE_p_wxSystemOptions swig_types[152]
2619 #define SWIGTYPE_p_wxSystemSettings swig_types[153]
2620 #define SWIGTYPE_p_wxTIFFHandler swig_types[154]
2621 #define SWIGTYPE_p_wxTextCtrl swig_types[155]
2622 #define SWIGTYPE_p_wxTextDataObject swig_types[156]
2623 #define SWIGTYPE_p_wxTimeSpan swig_types[157]
2624 #define SWIGTYPE_p_wxTimer swig_types[158]
2625 #define SWIGTYPE_p_wxTimerEvent swig_types[159]
2626 #define SWIGTYPE_p_wxTimerRunner swig_types[160]
2627 #define SWIGTYPE_p_wxTipProvider swig_types[161]
2628 #define SWIGTYPE_p_wxToolTip swig_types[162]
2629 #define SWIGTYPE_p_wxURLDataObject swig_types[163]
2630 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[164]
2631 #define SWIGTYPE_p_wxValidator swig_types[165]
2632 #define SWIGTYPE_p_wxVideoMode swig_types[166]
2633 #define SWIGTYPE_p_wxWindow swig_types[167]
2634 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[168]
2635 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[169]
2636 #define SWIGTYPE_p_wxWindowDisabler swig_types[170]
2637 #define SWIGTYPE_p_wxXPMHandler swig_types[171]
2638 static swig_type_info *swig_types[173];
2639 static swig_module_info swig_module = {swig_types, 172, 0, 0, 0, 0};
2640 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2641 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2642
2643 /* -------- TYPES TABLE (END) -------- */
2644
2645 #if (PY_VERSION_HEX <= 0x02000000)
2646 # if !defined(SWIG_PYTHON_CLASSIC)
2647 # error "This python version requires to use swig with the '-classic' option"
2648 # endif
2649 #endif
2650 #if (PY_VERSION_HEX <= 0x02020000)
2651 # error "This python version requires to use swig with the '-nomodern' option"
2652 #endif
2653 #if (PY_VERSION_HEX <= 0x02020000)
2654 # error "This python version requires to use swig with the '-nomodernargs' option"
2655 #endif
2656 #ifndef METH_O
2657 # error "This python version requires to use swig with the '-nofastunpack' option"
2658 #endif
2659
2660 /*-----------------------------------------------
2661 @(target):= _misc_.so
2662 ------------------------------------------------*/
2663 #define SWIG_init init_misc_
2664
2665 #define SWIG_name "_misc_"
2666
2667 #define SWIGVERSION 0x010329
2668
2669
2670 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2671 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2672
2673
2674 #include <stdexcept>
2675
2676
2677 namespace swig {
2678 class PyObject_ptr {
2679 protected:
2680 PyObject *_obj;
2681
2682 public:
2683 PyObject_ptr() :_obj(0)
2684 {
2685 }
2686
2687 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2688 {
2689 Py_XINCREF(_obj);
2690 }
2691
2692 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2693 {
2694 if (initial_ref) Py_XINCREF(_obj);
2695 }
2696
2697 PyObject_ptr & operator=(const PyObject_ptr& item)
2698 {
2699 Py_XINCREF(item._obj);
2700 Py_XDECREF(_obj);
2701 _obj = item._obj;
2702 return *this;
2703 }
2704
2705 ~PyObject_ptr()
2706 {
2707 Py_XDECREF(_obj);
2708 }
2709
2710 operator PyObject *() const
2711 {
2712 return _obj;
2713 }
2714
2715 PyObject *operator->() const
2716 {
2717 return _obj;
2718 }
2719 };
2720 }
2721
2722
2723 namespace swig {
2724 struct PyObject_var : PyObject_ptr {
2725 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2726
2727 PyObject_var & operator = (PyObject* obj)
2728 {
2729 Py_XDECREF(_obj);
2730 _obj = obj;
2731 return *this;
2732 }
2733 };
2734 }
2735
2736
2737 #include "wx/wxPython/wxPython.h"
2738 #include "wx/wxPython/pyclasses.h"
2739 #include "wx/wxPython/pyistream.h"
2740
2741 static const wxString wxPyEmptyString(wxEmptyString);
2742
2743
2744
2745 #define SWIG_From_long PyInt_FromLong
2746
2747
2748 SWIGINTERNINLINE PyObject *
2749 SWIG_From_int (int value)
2750 {
2751 return SWIG_From_long (value);
2752 }
2753
2754
2755 #include <limits.h>
2756 #ifndef LLONG_MIN
2757 # define LLONG_MIN LONG_LONG_MIN
2758 #endif
2759 #ifndef LLONG_MAX
2760 # define LLONG_MAX LONG_LONG_MAX
2761 #endif
2762 #ifndef ULLONG_MAX
2763 # define ULLONG_MAX ULONG_LONG_MAX
2764 #endif
2765
2766
2767 SWIGINTERN int
2768 SWIG_AsVal_long (PyObject* obj, long* val)
2769 {
2770 if (PyNumber_Check(obj)) {
2771 if (val) *val = PyInt_AsLong(obj);
2772 return SWIG_OK;
2773 }
2774 return SWIG_TypeError;
2775 }
2776
2777
2778 SWIGINTERN int
2779 SWIG_AsVal_int (PyObject * obj, int *val)
2780 {
2781 long v;
2782 int res = SWIG_AsVal_long (obj, &v);
2783 if (SWIG_IsOK(res)) {
2784 if ((v < INT_MIN || v > INT_MAX)) {
2785 return SWIG_OverflowError;
2786 } else {
2787 if (val) *val = static_cast< int >(v);
2788 }
2789 }
2790 return res;
2791 }
2792
2793 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2794
2795 #include <wx/stockitem.h>
2796
2797 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2798 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2799 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2800
2801 SWIGINTERN int
2802 SWIG_AsVal_bool (PyObject *obj, bool *val)
2803 {
2804 if (obj == Py_True) {
2805 if (val) *val = true;
2806 return SWIG_OK;
2807 } else if (obj == Py_False) {
2808 if (val) *val = false;
2809 return SWIG_OK;
2810 } else {
2811 long v = 0;
2812 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2813 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2814 return res;
2815 }
2816 }
2817
2818
2819 wxMemorySize wxGetFreeMemory()
2820 { wxPyRaiseNotImplemented(); return 0; }
2821
2822
2823 SWIGINTERN int
2824 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2825 {
2826 long v = 0;
2827 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2828 return SWIG_TypeError;
2829 }
2830 else if (val)
2831 *val = (unsigned long)v;
2832 return SWIG_OK;
2833 }
2834
2835
2836 SWIGINTERNINLINE PyObject*
2837 SWIG_From_unsigned_SS_long (unsigned long value)
2838 {
2839 return (value > LONG_MAX) ?
2840 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2841 }
2842
2843
2844 void* wxGetXDisplay()
2845 {
2846 #ifdef __WXGTK__
2847 return wxGetDisplay();
2848 #else
2849 return NULL;
2850 #endif
2851 }
2852
2853
2854 wxWindow* FindWindowAtPointer() {
2855 wxPoint unused;
2856 return wxFindWindowAtPointer(unused);
2857 }
2858
2859
2860 void wxWakeUpMainThread() {}
2861
2862
2863 bool wxThread_IsMain() {
2864 #ifdef WXP_WITH_THREAD
2865 return wxThread::IsMain();
2866 #else
2867 return true;
2868 #endif
2869 }
2870
2871 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2872 delete self;
2873 }
2874
2875 #include <wx/snglinst.h>
2876
2877
2878 #ifdef __WXMSW__
2879 #include <wx/msw/private.h>
2880 #include <wx/dynload.h>
2881 #endif
2882
2883
2884
2885 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2886 #if 0
2887 , int method
2888 #endif
2889 )
2890 {
2891 #ifdef __WXMSW__
2892 #if 0
2893 switch (method)
2894 {
2895 case 1:
2896 // This one only partially works. Appears to be an undocumented
2897 // "standard" convention that not all widgets adhear to. For
2898 // example, for some widgets backgrounds or non-client areas may
2899 // not be painted.
2900 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2901 break;
2902
2903 case 2:
2904 #endif
2905 // This one works much better, nearly all widgets and their
2906 // children are captured correctly[**]. Prior to the big
2907 // background erase changes that Vadim did in 2004-2005 this
2908 // method failed badly on XP with Themes activated, most native
2909 // widgets draw only partially, if at all. Without themes it
2910 // worked just like on Win2k. After those changes this method
2911 // works very well.
2912 //
2913 // ** For example the radio buttons in a wxRadioBox are not its
2914 // children by default, but you can capture it via the panel
2915 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2916 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2917 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2918 PRF_ERASEBKGND | PRF_OWNED );
2919 return true;
2920 #if 0
2921 break;
2922
2923 case 3:
2924 // This one is only defined in the latest SDK and is only
2925 // available on XP. MSDN says it is similar to sending WM_PRINT
2926 // so I expect that it will work similar to the above. Since it
2927 // is avaialble only on XP, it can't be compiled like this and
2928 // will have to be loaded dynamically.
2929 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2930
2931 // fall through
2932
2933 case 4:
2934 // Use PrintWindow if available, or fallback to WM_PRINT
2935 // otherwise. Unfortunately using PrintWindow is even worse than
2936 // WM_PRINT. For most native widgets nothing is drawn to the dc
2937 // at all, with or without Themes.
2938 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2939 static bool s_triedToLoad = false;
2940 static PrintWindow_t pfnPrintWindow = NULL;
2941 if ( !s_triedToLoad )
2942 {
2943
2944 s_triedToLoad = true;
2945 wxDynamicLibrary dllUser32(_T("user32.dll"));
2946 if ( dllUser32.IsLoaded() )
2947 {
2948 wxLogNull nolog; // Don't report errors here
2949 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2950 }
2951 }
2952 if (pfnPrintWindow)
2953 {
2954 //printf("Using PrintWindow\n");
2955 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2956 }
2957 else
2958 {
2959 //printf("Using WM_PRINT\n");
2960 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2961 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2962 PRF_ERASEBKGND | PRF_OWNED );
2963 }
2964 }
2965 #endif // 0
2966 #else
2967 return false;
2968 #endif // __WXMSW__
2969 }
2970
2971
2972
2973 #include <wx/tipdlg.h>
2974
2975
2976 SWIGINTERNINLINE PyObject *
2977 SWIG_From_size_t (size_t value)
2978 {
2979 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2980 }
2981
2982
2983 class wxPyTipProvider : public wxTipProvider {
2984 public:
2985 wxPyTipProvider(size_t currentTip)
2986 : wxTipProvider(currentTip) {}
2987
2988 DEC_PYCALLBACK_STRING__pure(GetTip);
2989 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2990 PYPRIVATE;
2991 };
2992
2993 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2994 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2995
2996
2997 SWIGINTERNINLINE int
2998 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2999 {
3000 unsigned long v;
3001 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3002 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3003 return res;
3004 }
3005
3006
3007 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3008
3009 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3010
3011 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3012 : wxTimer(owner, id)
3013 {
3014 if (owner == NULL)
3015 SetOwner(this);
3016 }
3017
3018
3019 SWIGINTERN swig_type_info*
3020 SWIG_pchar_descriptor()
3021 {
3022 static int init = 0;
3023 static swig_type_info* info = 0;
3024 if (!init) {
3025 info = SWIG_TypeQuery("_p_char");
3026 init = 1;
3027 }
3028 return info;
3029 }
3030
3031
3032 SWIGINTERNINLINE PyObject *
3033 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3034 {
3035 if (carray) {
3036 if (size > INT_MAX) {
3037 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3038 return pchar_descriptor ?
3039 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3040 } else {
3041 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3042 }
3043 } else {
3044 return SWIG_Py_Void();
3045 }
3046 }
3047
3048
3049 SWIGINTERNINLINE PyObject *
3050 SWIG_FromCharPtr(const char *cptr)
3051 {
3052 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3053 }
3054
3055
3056 SWIGINTERN int
3057 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3058 {
3059 unsigned long v;
3060 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3061 if (SWIG_IsOK(res)) {
3062 if ((v > UINT_MAX)) {
3063 return SWIG_OverflowError;
3064 } else {
3065 if (val) *val = static_cast< unsigned int >(v);
3066 }
3067 }
3068 return res;
3069 }
3070
3071 SWIGINTERN wxString wxLog_TimeStamp(){
3072 wxString msg;
3073 wxLog::TimeStamp(&msg);
3074 return msg;
3075 }
3076 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3077 // Make some wrappers that double any % signs so they are 'escaped'
3078 void wxPyLogFatalError(const wxString& msg)
3079 {
3080 wxString m(msg);
3081 m.Replace(wxT("%"), wxT("%%"));
3082 wxLogFatalError(m);
3083 }
3084
3085 void wxPyLogError(const wxString& msg)
3086 {
3087 wxString m(msg);
3088 m.Replace(wxT("%"), wxT("%%"));
3089 wxLogError(m);
3090 }
3091
3092 void wxPyLogWarning(const wxString& msg)
3093 {
3094 wxString m(msg);
3095 m.Replace(wxT("%"), wxT("%%"));
3096 wxLogWarning(m);
3097 }
3098
3099 void wxPyLogMessage(const wxString& msg)
3100 {
3101 wxString m(msg);
3102 m.Replace(wxT("%"), wxT("%%"));
3103 wxLogMessage(m);
3104 }
3105
3106 void wxPyLogInfo(const wxString& msg)
3107 {
3108 wxString m(msg);
3109 m.Replace(wxT("%"), wxT("%%"));
3110 wxLogInfo(m);
3111 }
3112
3113 void wxPyLogDebug(const wxString& msg)
3114 {
3115 wxString m(msg);
3116 m.Replace(wxT("%"), wxT("%%"));
3117 wxLogDebug(m);
3118 }
3119
3120 void wxPyLogVerbose(const wxString& msg)
3121 {
3122 wxString m(msg);
3123 m.Replace(wxT("%"), wxT("%%"));
3124 wxLogVerbose(m);
3125 }
3126
3127 void wxPyLogStatus(const wxString& msg)
3128 {
3129 wxString m(msg);
3130 m.Replace(wxT("%"), wxT("%%"));
3131 wxLogStatus(m);
3132 }
3133
3134 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3135 {
3136 wxString m(msg);
3137 m.Replace(wxT("%"), wxT("%%"));
3138 wxLogStatus(pFrame, m);
3139 }
3140
3141 void wxPyLogSysError(const wxString& msg)
3142 {
3143 wxString m(msg);
3144 m.Replace(wxT("%"), wxT("%%"));
3145 wxLogSysError(m);
3146 }
3147
3148 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3149 {
3150 wxString m(msg);
3151 m.Replace(wxT("%"), wxT("%%"));
3152 wxLogGeneric(level, m);
3153 }
3154
3155 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3156 {
3157 wxString m(msg);
3158 m.Replace(wxT("%"), wxT("%%"));
3159 wxLogTrace(mask, m);
3160 }
3161
3162 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3163 {
3164 wxString m(msg);
3165 m.Replace(wxT("%"), wxT("%%"));
3166 wxLogTrace(mask, m);
3167 }
3168
3169
3170
3171 // A wxLog class that can be derived from in wxPython
3172 class wxPyLog : public wxLog {
3173 public:
3174 wxPyLog() : wxLog() {}
3175
3176 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3177 bool found;
3178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3179 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3180 PyObject* s = wx2PyString(szString);
3181 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3182 Py_DECREF(s);
3183 }
3184 wxPyEndBlockThreads(blocked);
3185 if (! found)
3186 wxLog::DoLog(level, szString, t);
3187 }
3188
3189 virtual void DoLogString(const wxChar *szString, time_t t) {
3190 bool found;
3191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3192 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3193 PyObject* s = wx2PyString(szString);
3194 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3195 Py_DECREF(s);
3196 }
3197 wxPyEndBlockThreads(blocked);
3198 if (! found)
3199 wxLog::DoLogString(szString, t);
3200 }
3201
3202 DEC_PYCALLBACK_VOID_(Flush);
3203 PYPRIVATE;
3204 };
3205 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3206
3207
3208
3209
3210 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3211
3212
3213 #include <wx/joystick.h>
3214
3215
3216 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3217 // A C++ stub class for wxJoystick for platforms that don't have it.
3218 class wxJoystick : public wxObject {
3219 public:
3220 wxJoystick(int joystick = wxJOYSTICK1) {
3221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3222 PyErr_SetString(PyExc_NotImplementedError,
3223 "wxJoystick is not available on this platform.");
3224 wxPyEndBlockThreads(blocked);
3225 }
3226 wxPoint GetPosition() { return wxPoint(-1,-1); }
3227 int GetZPosition() { return -1; }
3228 int GetButtonState() { return -1; }
3229 int GetPOVPosition() { return -1; }
3230 int GetPOVCTSPosition() { return -1; }
3231 int GetRudderPosition() { return -1; }
3232 int GetUPosition() { return -1; }
3233 int GetVPosition() { return -1; }
3234 int GetMovementThreshold() { return -1; }
3235 void SetMovementThreshold(int threshold) {}
3236
3237 bool IsOk(void) { return false; }
3238 int GetNumberJoysticks() { return -1; }
3239 int GetManufacturerId() { return -1; }
3240 int GetProductId() { return -1; }
3241 wxString GetProductName() { return wxEmptyString; }
3242 int GetXMin() { return -1; }
3243 int GetYMin() { return -1; }
3244 int GetZMin() { return -1; }
3245 int GetXMax() { return -1; }
3246 int GetYMax() { return -1; }
3247 int GetZMax() { return -1; }
3248 int GetNumberButtons() { return -1; }
3249 int GetNumberAxes() { return -1; }
3250 int GetMaxButtons() { return -1; }
3251 int GetMaxAxes() { return -1; }
3252 int GetPollingMin() { return -1; }
3253 int GetPollingMax() { return -1; }
3254 int GetRudderMin() { return -1; }
3255 int GetRudderMax() { return -1; }
3256 int GetUMin() { return -1; }
3257 int GetUMax() { return -1; }
3258 int GetVMin() { return -1; }
3259 int GetVMax() { return -1; }
3260
3261 bool HasRudder() { return false; }
3262 bool HasZ() { return false; }
3263 bool HasU() { return false; }
3264 bool HasV() { return false; }
3265 bool HasPOV() { return false; }
3266 bool HasPOV4Dir() { return false; }
3267 bool HasPOVCTS() { return false; }
3268
3269 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3270 bool ReleaseCapture() { return false; }
3271 };
3272 #endif
3273
3274
3275 #include <wx/sound.h>
3276
3277
3278 #if !wxUSE_SOUND
3279 // A C++ stub class for wxWave for platforms that don't have it.
3280 class wxSound : public wxObject
3281 {
3282 public:
3283 wxSound() {
3284 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3285 PyErr_SetString(PyExc_NotImplementedError,
3286 "wxSound is not available on this platform.");
3287 wxPyEndBlockThreads(blocked);
3288 }
3289 wxSound(const wxString&/*, bool*/) {
3290 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3291 PyErr_SetString(PyExc_NotImplementedError,
3292 "wxSound is not available on this platform.");
3293 wxPyEndBlockThreads(blocked);
3294 }
3295 wxSound(int, const wxByte*) {
3296 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3297 PyErr_SetString(PyExc_NotImplementedError,
3298 "wxSound is not available on this platform.");
3299 wxPyEndBlockThreads(blocked);
3300 }
3301
3302 ~wxSound() {};
3303
3304 bool Create(const wxString&/*, bool*/) { return false; }
3305 bool Create(int, const wxByte*) { return false; };
3306 bool IsOk() { return false; };
3307 bool Play(unsigned) const { return false; }
3308 static bool Play(const wxString&, unsigned) { return false; }
3309 static void Stop() {}
3310 };
3311
3312 #endif
3313
3314 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3315 if (fileName.Length() == 0)
3316 return new wxSound;
3317 else
3318 return new wxSound(fileName);
3319 }
3320 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3321 unsigned char* buffer; int size;
3322 wxSound *sound = NULL;
3323
3324 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3325 if (!PyArg_Parse(data, "t#", &buffer, &size))
3326 goto done;
3327 sound = new wxSound(size, buffer);
3328 done:
3329 wxPyEndBlockThreads(blocked);
3330 return sound;
3331 }
3332 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3333 #ifndef __WXMAC__
3334 unsigned char* buffer;
3335 int size;
3336 bool rv = false;
3337
3338 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3339 if (!PyArg_Parse(data, "t#", &buffer, &size))
3340 goto done;
3341 rv = self->Create(size, buffer);
3342 done:
3343 wxPyEndBlockThreads(blocked);
3344 return rv;
3345 #else
3346 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3347 PyErr_SetString(PyExc_NotImplementedError,
3348 "Create from data is not available on this platform.");
3349 wxPyEndBlockThreads(blocked);
3350 return false;
3351 #endif
3352 }
3353
3354 #include <wx/mimetype.h>
3355
3356 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3357 wxString str;
3358 if (self->GetMimeType(&str))
3359 return wx2PyString(str);
3360 else
3361 RETURN_NONE();
3362 }
3363 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3364 wxArrayString arr;
3365 if (self->GetMimeTypes(arr))
3366 return wxArrayString2PyList_helper(arr);
3367 else
3368 RETURN_NONE();
3369 }
3370 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3371 wxArrayString arr;
3372 if (self->GetExtensions(arr))
3373 return wxArrayString2PyList_helper(arr);
3374 else
3375 RETURN_NONE();
3376 }
3377 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3378 wxIconLocation loc;
3379 if (self->GetIcon(&loc))
3380 return new wxIcon(loc);
3381 else
3382 return NULL;
3383 }
3384 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3385 wxIconLocation loc;
3386 if (self->GetIcon(&loc)) {
3387 wxString iconFile = loc.GetFileName();
3388 int iconIndex = -1;
3389
3390
3391
3392 // Make a tuple and put the values in it
3393 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3394 PyObject* tuple = PyTuple_New(3);
3395 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3396 wxT("wxIcon"), true));
3397 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3398 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3399 wxPyEndBlockThreads(blocked);
3400 return tuple;
3401 }
3402 else
3403 RETURN_NONE();
3404 }
3405 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3406 wxString str;
3407 if (self->GetDescription(&str))
3408 return wx2PyString(str);
3409 else
3410 RETURN_NONE();
3411 }
3412 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3413 wxString str;
3414 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3415 return wx2PyString(str);
3416 else
3417 RETURN_NONE();
3418 }
3419 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3420 wxString str;
3421 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3422 return wx2PyString(str);
3423 else
3424 RETURN_NONE();
3425 }
3426 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3427 wxArrayString verbs;
3428 wxArrayString commands;
3429 if (self->GetAllCommands(&verbs, &commands,
3430 wxFileType::MessageParameters(filename, mimetype))) {
3431 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3432 PyObject* tuple = PyTuple_New(2);
3433 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3434 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3435 wxPyEndBlockThreads(blocked);
3436 return tuple;
3437 }
3438 else
3439 RETURN_NONE();
3440 }
3441 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3442 return wxFileType::ExpandCommand(command,
3443 wxFileType::MessageParameters(filename, mimetype));
3444 }
3445 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3446 wxArrayString arr;
3447 self->EnumAllFileTypes(arr);
3448 return wxArrayString2PyList_helper(arr);
3449 }
3450
3451 #include <wx/artprov.h>
3452
3453 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3454 static const wxString wxPyART_MENU(wxART_MENU);
3455 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3456 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3457 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3458 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3459 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3460 static const wxString wxPyART_OTHER(wxART_OTHER);
3461 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3462 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3463 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3464 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3465 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3466 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3467 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3468 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3469 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3470 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3471 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3472 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3473 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3474 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3475 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3476 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3477 static const wxString wxPyART_PRINT(wxART_PRINT);
3478 static const wxString wxPyART_HELP(wxART_HELP);
3479 static const wxString wxPyART_TIP(wxART_TIP);
3480 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3481 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3482 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3483 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3484 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3485 static const wxString wxPyART_CDROM(wxART_CDROM);
3486 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3487 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3488 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3489 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3490 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3491 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3492 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3493 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3494 static const wxString wxPyART_ERROR(wxART_ERROR);
3495 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3496 static const wxString wxPyART_WARNING(wxART_WARNING);
3497 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3498 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3499 static const wxString wxPyART_COPY(wxART_COPY);
3500 static const wxString wxPyART_CUT(wxART_CUT);
3501 static const wxString wxPyART_PASTE(wxART_PASTE);
3502 static const wxString wxPyART_DELETE(wxART_DELETE);
3503 static const wxString wxPyART_NEW(wxART_NEW);
3504 static const wxString wxPyART_UNDO(wxART_UNDO);
3505 static const wxString wxPyART_REDO(wxART_REDO);
3506 static const wxString wxPyART_QUIT(wxART_QUIT);
3507 static const wxString wxPyART_FIND(wxART_FIND);
3508 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3509 // Python aware wxArtProvider
3510 class wxPyArtProvider : public wxArtProvider {
3511 public:
3512
3513 virtual wxBitmap CreateBitmap(const wxArtID& id,
3514 const wxArtClient& client,
3515 const wxSize& size) {
3516 wxBitmap rval = wxNullBitmap;
3517 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3518 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3519 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3520 PyObject* ro;
3521 wxBitmap* ptr;
3522 PyObject* s1, *s2;
3523 s1 = wx2PyString(id);
3524 s2 = wx2PyString(client);
3525 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3526 Py_DECREF(so);
3527 Py_DECREF(s1);
3528 Py_DECREF(s2);
3529 if (ro) {
3530 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3531 rval = *ptr;
3532 Py_DECREF(ro);
3533 }
3534 }
3535 wxPyEndBlockThreads(blocked);
3536 return rval;
3537 }
3538
3539 PYPRIVATE;
3540 };
3541
3542 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3543
3544
3545
3546 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3547 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3548 PyObject* ret = PyTuple_New(3);
3549 if (ret) {
3550 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3551 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3552 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3553 }
3554 wxPyEndBlockThreads(blocked);
3555 return ret;
3556 }
3557
3558 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3559 bool cont;
3560 long index = 0;
3561 wxString value;
3562
3563 cont = self->GetFirstGroup(value, index);
3564 return __EnumerationHelper(cont, value, index);
3565 }
3566 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3567 bool cont;
3568 wxString value;
3569
3570 cont = self->GetNextGroup(value, index);
3571 return __EnumerationHelper(cont, value, index);
3572 }
3573 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3574 bool cont;
3575 long index = 0;
3576 wxString value;
3577
3578 cont = self->GetFirstEntry(value, index);
3579 return __EnumerationHelper(cont, value, index);
3580 }
3581 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3582 bool cont;
3583 wxString value;
3584
3585 cont = self->GetNextEntry(value, index);
3586 return __EnumerationHelper(cont, value, index);
3587 }
3588 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3589 long rv;
3590 self->Read(key, &rv, defaultVal);
3591 return rv;
3592 }
3593
3594 SWIGINTERN int
3595 SWIG_AsVal_double (PyObject *obj, double* val)
3596 {
3597 if (PyNumber_Check(obj)) {
3598 if (val) *val = PyFloat_AsDouble(obj);
3599 return SWIG_OK;
3600 }
3601 return SWIG_TypeError;
3602 }
3603
3604 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3605 double rv;
3606 self->Read(key, &rv, defaultVal);
3607 return rv;
3608 }
3609
3610 #define SWIG_From_double PyFloat_FromDouble
3611
3612 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3613 bool rv;
3614 self->Read(key, &rv, defaultVal);
3615 return rv;
3616 }
3617
3618 #include <wx/datetime.h>
3619
3620 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3621 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3622
3623 #define LOCAL_TZ wxDateTime::Local
3624
3625 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3626 wxString am;
3627 wxString pm;
3628 wxDateTime::GetAmPmStrings(&am, &pm);
3629 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3630 PyObject* tup = PyTuple_New(2);
3631 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3632 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3633 wxPyEndBlockThreads(blocked);
3634 return tup;
3635 }
3636
3637 SWIGINTERNINLINE PyObject *
3638 SWIG_From_unsigned_SS_int (unsigned int value)
3639 {
3640 return SWIG_From_unsigned_SS_long (value);
3641 }
3642
3643 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3644 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3645 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3646 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3647 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3648 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3649 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3650 return (*self < *other);
3651 }
3652 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3653 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3654 return (*self <= *other);
3655 }
3656 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3657 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3658 return (*self > *other);
3659 }
3660 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3661 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3662 return (*self >= *other);
3663 }
3664 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3665 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3666 return (*self == *other);
3667 }
3668 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3669 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3670 return (*self != *other);
3671 }
3672 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3673 const wxChar* rv;
3674 const wxChar* _date = date;
3675 rv = self->ParseRfc822Date(_date);
3676 if (rv == NULL) return -1;
3677 return rv - _date;
3678 }
3679 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3680 const wxChar* rv;
3681 const wxChar* _date = date;
3682 rv = self->ParseFormat(_date, format, dateDef);
3683 if (rv == NULL) return -1;
3684 return rv - _date;
3685 }
3686 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3687 const wxChar* rv;
3688 const wxChar* _datetime = datetime;
3689 rv = self->ParseDateTime(_datetime);
3690 if (rv == NULL) return -1;
3691 return rv - _datetime;
3692 }
3693 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3694 const wxChar* rv;
3695 const wxChar* _date = date;
3696 rv = self->ParseDate(_date);
3697 if (rv == NULL) return -1;
3698 return rv - _date;
3699 }
3700 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3701 const wxChar* rv;
3702 const wxChar* _time = time;
3703 rv = self->ParseTime(_time);
3704 if (rv == NULL) return -1;
3705 return rv - _time;
3706 }
3707 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3708 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3709 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3710 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3711 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3712 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3713 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3714 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3715 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3716 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3717 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3718 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3719 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3720 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3721 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3722 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3723
3724 #include <wx/dataobj.h>
3725
3726 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3727 size_t count = self->GetFormatCount(dir);
3728 wxDataFormat* formats = new wxDataFormat[count];
3729 self->GetAllFormats(formats, dir);
3730
3731 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3732 PyObject* list = PyList_New(count);
3733 for (size_t i=0; i<count; i++) {
3734 wxDataFormat* format = new wxDataFormat(formats[i]);
3735 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3736 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3737 }
3738 wxPyEndBlockThreads(blocked);
3739 delete [] formats;
3740 return list;
3741 }
3742 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3743 PyObject* rval = NULL;
3744 size_t size = self->GetDataSize(format);
3745 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3746 if (size) {
3747 char* buf = new char[size];
3748 if (self->GetDataHere(format, buf))
3749 rval = PyString_FromStringAndSize(buf, size);
3750 delete [] buf;
3751 }
3752 if (! rval) {
3753 rval = Py_None;
3754 Py_INCREF(rval);
3755 }
3756 wxPyEndBlockThreads(blocked);
3757 return rval;
3758 }
3759 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3760 bool rval;
3761 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3762 if (PyString_Check(data)) {
3763 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3764 }
3765 else {
3766 // raise a TypeError if not a string
3767 PyErr_SetString(PyExc_TypeError, "String expected.");
3768 rval = false;
3769 }
3770 wxPyEndBlockThreads(blocked);
3771 return rval;
3772 }
3773 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3774 PyObject* rval = NULL;
3775 size_t size = self->GetDataSize();
3776 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3777 if (size) {
3778 char* buf = new char[size];
3779 if (self->GetDataHere(buf))
3780 rval = PyString_FromStringAndSize(buf, size);
3781 delete [] buf;
3782 }
3783 if (! rval) {
3784 rval = Py_None;
3785 Py_INCREF(rval);
3786 }
3787 wxPyEndBlockThreads(blocked);
3788 return rval;
3789 }
3790 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3791 bool rval;
3792 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3793 if (PyString_Check(data)) {
3794 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3795 }
3796 else {
3797 // raise a TypeError if not a string
3798 PyErr_SetString(PyExc_TypeError, "String expected.");
3799 rval = false;
3800 }
3801 wxPyEndBlockThreads(blocked);
3802 return rval;
3803 }
3804 // Create a new class for wxPython to use
3805 class wxPyDataObjectSimple : public wxDataObjectSimple {
3806 public:
3807 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3808 : wxDataObjectSimple(format) {}
3809
3810 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3811 bool GetDataHere(void *buf) const;
3812 bool SetData(size_t len, const void *buf);
3813 PYPRIVATE;
3814 };
3815
3816 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3817
3818 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3819 // We need to get the data for this object and write it to buf. I think
3820 // the best way to do this for wxPython is to have the Python method
3821 // return either a string or None and then act appropriately with the
3822 // C++ version.
3823
3824 bool rval = false;
3825 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3826 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3827 PyObject* ro;
3828 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3829 if (ro) {
3830 rval = (ro != Py_None && PyString_Check(ro));
3831 if (rval)
3832 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3833 Py_DECREF(ro);
3834 }
3835 }
3836 wxPyEndBlockThreads(blocked);
3837 return rval;
3838 }
3839
3840 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3841 // For this one we simply need to make a string from buf and len
3842 // and send it to the Python method.
3843 bool rval = false;
3844 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3845 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3846 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3847 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3848 Py_DECREF(data);
3849 }
3850 wxPyEndBlockThreads(blocked);
3851 return rval;
3852 }
3853
3854 // Create a new class for wxPython to use
3855 class wxPyTextDataObject : public wxTextDataObject {
3856 public:
3857 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3858 : wxTextDataObject(text) {}
3859
3860 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3861 DEC_PYCALLBACK_STRING__const(GetText);
3862 DEC_PYCALLBACK__STRING(SetText);
3863 PYPRIVATE;
3864 };
3865
3866 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3867 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3868 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3869
3870
3871 // Create a new class for wxPython to use
3872 class wxPyBitmapDataObject : public wxBitmapDataObject {
3873 public:
3874 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3875 : wxBitmapDataObject(bitmap) {}
3876
3877 wxBitmap GetBitmap() const;
3878 void SetBitmap(const wxBitmap& bitmap);
3879 PYPRIVATE;
3880 };
3881
3882 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3883 wxBitmap* rval = &wxNullBitmap;
3884 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3885 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3886 PyObject* ro;
3887 wxBitmap* ptr;
3888 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3889 if (ro) {
3890 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3891 rval = ptr;
3892 Py_DECREF(ro);
3893 }
3894 }
3895 wxPyEndBlockThreads(blocked);
3896 return *rval;
3897 }
3898
3899 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3900 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3901 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3902 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3903 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3904 Py_DECREF(bo);
3905 }
3906 wxPyEndBlockThreads(blocked);
3907 }
3908
3909 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3910 return new wxCustomDataObject(wxDataFormat(formatName));
3911 }
3912 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3913 bool rval;
3914 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3915 if (PyString_Check(data)) {
3916 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3917 }
3918 else {
3919 // raise a TypeError if not a string
3920 PyErr_SetString(PyExc_TypeError, "String expected.");
3921 rval = false;
3922 }
3923 wxPyEndBlockThreads(blocked);
3924 return rval;
3925 }
3926 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3927 PyObject* obj;
3928 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3929 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3930 wxPyEndBlockThreads(blocked);
3931 return obj;
3932 }
3933
3934 class wxMetafileDataObject : public wxDataObjectSimple
3935 {
3936 public:
3937 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3938 };
3939
3940
3941 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3942
3943
3944 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3945 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3946 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3947 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3948 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3949
3950
3951 class wxPyTextDropTarget : public wxTextDropTarget {
3952 public:
3953 wxPyTextDropTarget() {}
3954
3955 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3956
3957 DEC_PYCALLBACK__(OnLeave);
3958 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3959 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3960 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3961 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3962
3963 PYPRIVATE;
3964 };
3965
3966 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3967 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3968 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3969 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3970 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3971 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3972
3973
3974
3975 class wxPyFileDropTarget : public wxFileDropTarget {
3976 public:
3977 wxPyFileDropTarget() {}
3978
3979 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3980
3981 DEC_PYCALLBACK__(OnLeave);
3982 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3983 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3984 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3985 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3986
3987 PYPRIVATE;
3988 };
3989
3990 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3991 const wxArrayString& filenames) {
3992 bool rval = false;
3993 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3994 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3995 PyObject* list = wxArrayString2PyList_helper(filenames);
3996 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3997 Py_DECREF(list);
3998 }
3999 wxPyEndBlockThreads(blocked);
4000 return rval;
4001 }
4002
4003
4004
4005 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4006 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4007 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4008 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4009 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4010
4011
4012
4013
4014 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4015
4016 #include <wx/display.h>
4017
4018 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4019 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4020
4021 #if !wxUSE_DISPLAY
4022 const wxVideoMode wxDefaultVideoMode;
4023 #endif
4024
4025 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4026 #if wxUSE_DISPLAY
4027 PyObject* pyList = NULL;
4028 wxArrayVideoModes arr = self->GetModes(mode);
4029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4030 pyList = PyList_New(0);
4031 for (size_t i=0; i < arr.GetCount(); i++)
4032 {
4033 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4034 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4035 PyList_Append(pyList, pyObj);
4036 Py_DECREF(pyObj);
4037 }
4038 wxPyEndBlockThreads(blocked);
4039 return pyList;
4040 #else
4041 wxPyRaiseNotImplemented();
4042 return NULL;
4043 #endif
4044 }
4045 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4046 #if wxUSE_DISPLAY
4047 return self->GetCurrentMode();
4048 #else
4049 wxPyRaiseNotImplemented();
4050 return wxDefaultVideoMode;
4051 #endif
4052 }
4053 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4054 #if wxUSE_DISPLAY
4055 return self->ChangeMode(mode);
4056 #else
4057 wxPyRaiseNotImplemented();
4058 return false;
4059 #endif
4060 }
4061 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4062 #if wxUSE_DISPLAY
4063 self->ResetMode();
4064 #else
4065 wxPyRaiseNotImplemented();
4066 #endif
4067 }
4068
4069 #include <wx/stdpaths.h>
4070
4071 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4072 return (wxStandardPaths*) &wxStandardPaths::Get();
4073 }
4074
4075 #ifndef wxHAS_POWER_EVENTS
4076 // Dummy class and other definitions for platforms that don't have them
4077
4078 // See wxPython_int.h for wxPowerEvent
4079
4080 enum {
4081 wxEVT_POWER_SUSPENDING,
4082 wxEVT_POWER_SUSPENDED,
4083 wxEVT_POWER_SUSPEND_CANCEL,
4084 wxEVT_POWER_RESUME,
4085 };
4086
4087 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4088 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4089
4090 #endif
4091
4092 #ifdef __cplusplus
4093 extern "C" {
4094 #endif
4095 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4096 PyObject *resultobj = 0;
4097 wxSystemColour arg1 ;
4098 wxColour result;
4099 int val1 ;
4100 int ecode1 = 0 ;
4101 PyObject * obj0 = 0 ;
4102 char * kwnames[] = {
4103 (char *) "index", NULL
4104 };
4105
4106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4107 ecode1 = SWIG_AsVal_int(obj0, &val1);
4108 if (!SWIG_IsOK(ecode1)) {
4109 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4110 }
4111 arg1 = static_cast< wxSystemColour >(val1);
4112 {
4113 if (!wxPyCheckForApp()) SWIG_fail;
4114 PyThreadState* __tstate = wxPyBeginAllowThreads();
4115 result = wxSystemSettings::GetColour(arg1);
4116 wxPyEndAllowThreads(__tstate);
4117 if (PyErr_Occurred()) SWIG_fail;
4118 }
4119 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4120 return resultobj;
4121 fail:
4122 return NULL;
4123 }
4124
4125
4126 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4127 PyObject *resultobj = 0;
4128 wxSystemFont arg1 ;
4129 wxFont result;
4130 int val1 ;
4131 int ecode1 = 0 ;
4132 PyObject * obj0 = 0 ;
4133 char * kwnames[] = {
4134 (char *) "index", NULL
4135 };
4136
4137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4138 ecode1 = SWIG_AsVal_int(obj0, &val1);
4139 if (!SWIG_IsOK(ecode1)) {
4140 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4141 }
4142 arg1 = static_cast< wxSystemFont >(val1);
4143 {
4144 if (!wxPyCheckForApp()) SWIG_fail;
4145 PyThreadState* __tstate = wxPyBeginAllowThreads();
4146 result = wxSystemSettings::GetFont(arg1);
4147 wxPyEndAllowThreads(__tstate);
4148 if (PyErr_Occurred()) SWIG_fail;
4149 }
4150 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4151 return resultobj;
4152 fail:
4153 return NULL;
4154 }
4155
4156
4157 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4158 PyObject *resultobj = 0;
4159 wxSystemMetric arg1 ;
4160 wxWindow *arg2 = (wxWindow *) NULL ;
4161 int result;
4162 int val1 ;
4163 int ecode1 = 0 ;
4164 void *argp2 = 0 ;
4165 int res2 = 0 ;
4166 PyObject * obj0 = 0 ;
4167 PyObject * obj1 = 0 ;
4168 char * kwnames[] = {
4169 (char *) "index",(char *) "win", NULL
4170 };
4171
4172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4173 ecode1 = SWIG_AsVal_int(obj0, &val1);
4174 if (!SWIG_IsOK(ecode1)) {
4175 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4176 }
4177 arg1 = static_cast< wxSystemMetric >(val1);
4178 if (obj1) {
4179 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4180 if (!SWIG_IsOK(res2)) {
4181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4182 }
4183 arg2 = reinterpret_cast< wxWindow * >(argp2);
4184 }
4185 {
4186 if (!wxPyCheckForApp()) SWIG_fail;
4187 PyThreadState* __tstate = wxPyBeginAllowThreads();
4188 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4189 wxPyEndAllowThreads(__tstate);
4190 if (PyErr_Occurred()) SWIG_fail;
4191 }
4192 resultobj = SWIG_From_int(static_cast< int >(result));
4193 return resultobj;
4194 fail:
4195 return NULL;
4196 }
4197
4198
4199 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4200 PyObject *resultobj = 0;
4201 wxSystemFeature arg1 ;
4202 bool result;
4203 int val1 ;
4204 int ecode1 = 0 ;
4205 PyObject * obj0 = 0 ;
4206 char * kwnames[] = {
4207 (char *) "index", NULL
4208 };
4209
4210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4211 ecode1 = SWIG_AsVal_int(obj0, &val1);
4212 if (!SWIG_IsOK(ecode1)) {
4213 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4214 }
4215 arg1 = static_cast< wxSystemFeature >(val1);
4216 {
4217 if (!wxPyCheckForApp()) SWIG_fail;
4218 PyThreadState* __tstate = wxPyBeginAllowThreads();
4219 result = (bool)wxSystemSettings::HasFeature(arg1);
4220 wxPyEndAllowThreads(__tstate);
4221 if (PyErr_Occurred()) SWIG_fail;
4222 }
4223 {
4224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4225 }
4226 return resultobj;
4227 fail:
4228 return NULL;
4229 }
4230
4231
4232 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4233 PyObject *resultobj = 0;
4234 wxSystemScreenType result;
4235
4236 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4237 {
4238 if (!wxPyCheckForApp()) SWIG_fail;
4239 PyThreadState* __tstate = wxPyBeginAllowThreads();
4240 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4241 wxPyEndAllowThreads(__tstate);
4242 if (PyErr_Occurred()) SWIG_fail;
4243 }
4244 resultobj = SWIG_From_int(static_cast< int >(result));
4245 return resultobj;
4246 fail:
4247 return NULL;
4248 }
4249
4250
4251 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4252 PyObject *resultobj = 0;
4253 wxSystemScreenType arg1 ;
4254 int val1 ;
4255 int ecode1 = 0 ;
4256 PyObject * obj0 = 0 ;
4257 char * kwnames[] = {
4258 (char *) "screen", NULL
4259 };
4260
4261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4262 ecode1 = SWIG_AsVal_int(obj0, &val1);
4263 if (!SWIG_IsOK(ecode1)) {
4264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4265 }
4266 arg1 = static_cast< wxSystemScreenType >(val1);
4267 {
4268 if (!wxPyCheckForApp()) SWIG_fail;
4269 PyThreadState* __tstate = wxPyBeginAllowThreads();
4270 wxSystemSettings::SetScreenType(arg1);
4271 wxPyEndAllowThreads(__tstate);
4272 if (PyErr_Occurred()) SWIG_fail;
4273 }
4274 resultobj = SWIG_Py_Void();
4275 return resultobj;
4276 fail:
4277 return NULL;
4278 }
4279
4280
4281 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4282 PyObject *obj;
4283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4284 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4285 return SWIG_Py_Void();
4286 }
4287
4288 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4289 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4290 return 1;
4291 }
4292
4293
4294 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4295 PyObject *pyobj = 0;
4296
4297 {
4298 #if wxUSE_UNICODE
4299 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4300 #else
4301 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4302 #endif
4303 }
4304 return pyobj;
4305 }
4306
4307
4308 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4309 PyObject *resultobj = 0;
4310 wxSystemOptions *result = 0 ;
4311
4312 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4313 {
4314 PyThreadState* __tstate = wxPyBeginAllowThreads();
4315 result = (wxSystemOptions *)new wxSystemOptions();
4316 wxPyEndAllowThreads(__tstate);
4317 if (PyErr_Occurred()) SWIG_fail;
4318 }
4319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4320 return resultobj;
4321 fail:
4322 return NULL;
4323 }
4324
4325
4326 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4327 PyObject *resultobj = 0;
4328 wxString *arg1 = 0 ;
4329 wxString *arg2 = 0 ;
4330 bool temp1 = false ;
4331 bool temp2 = false ;
4332 PyObject * obj0 = 0 ;
4333 PyObject * obj1 = 0 ;
4334 char * kwnames[] = {
4335 (char *) "name",(char *) "value", NULL
4336 };
4337
4338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4339 {
4340 arg1 = wxString_in_helper(obj0);
4341 if (arg1 == NULL) SWIG_fail;
4342 temp1 = true;
4343 }
4344 {
4345 arg2 = wxString_in_helper(obj1);
4346 if (arg2 == NULL) SWIG_fail;
4347 temp2 = true;
4348 }
4349 {
4350 PyThreadState* __tstate = wxPyBeginAllowThreads();
4351 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4352 wxPyEndAllowThreads(__tstate);
4353 if (PyErr_Occurred()) SWIG_fail;
4354 }
4355 resultobj = SWIG_Py_Void();
4356 {
4357 if (temp1)
4358 delete arg1;
4359 }
4360 {
4361 if (temp2)
4362 delete arg2;
4363 }
4364 return resultobj;
4365 fail:
4366 {
4367 if (temp1)
4368 delete arg1;
4369 }
4370 {
4371 if (temp2)
4372 delete arg2;
4373 }
4374 return NULL;
4375 }
4376
4377
4378 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4379 PyObject *resultobj = 0;
4380 wxString *arg1 = 0 ;
4381 int arg2 ;
4382 bool temp1 = false ;
4383 int val2 ;
4384 int ecode2 = 0 ;
4385 PyObject * obj0 = 0 ;
4386 PyObject * obj1 = 0 ;
4387 char * kwnames[] = {
4388 (char *) "name",(char *) "value", NULL
4389 };
4390
4391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4392 {
4393 arg1 = wxString_in_helper(obj0);
4394 if (arg1 == NULL) SWIG_fail;
4395 temp1 = true;
4396 }
4397 ecode2 = SWIG_AsVal_int(obj1, &val2);
4398 if (!SWIG_IsOK(ecode2)) {
4399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4400 }
4401 arg2 = static_cast< int >(val2);
4402 {
4403 PyThreadState* __tstate = wxPyBeginAllowThreads();
4404 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4405 wxPyEndAllowThreads(__tstate);
4406 if (PyErr_Occurred()) SWIG_fail;
4407 }
4408 resultobj = SWIG_Py_Void();
4409 {
4410 if (temp1)
4411 delete arg1;
4412 }
4413 return resultobj;
4414 fail:
4415 {
4416 if (temp1)
4417 delete arg1;
4418 }
4419 return NULL;
4420 }
4421
4422
4423 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4424 PyObject *resultobj = 0;
4425 wxString *arg1 = 0 ;
4426 wxString result;
4427 bool temp1 = false ;
4428 PyObject * obj0 = 0 ;
4429 char * kwnames[] = {
4430 (char *) "name", NULL
4431 };
4432
4433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4434 {
4435 arg1 = wxString_in_helper(obj0);
4436 if (arg1 == NULL) SWIG_fail;
4437 temp1 = true;
4438 }
4439 {
4440 PyThreadState* __tstate = wxPyBeginAllowThreads();
4441 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4442 wxPyEndAllowThreads(__tstate);
4443 if (PyErr_Occurred()) SWIG_fail;
4444 }
4445 {
4446 #if wxUSE_UNICODE
4447 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4448 #else
4449 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4450 #endif
4451 }
4452 {
4453 if (temp1)
4454 delete arg1;
4455 }
4456 return resultobj;
4457 fail:
4458 {
4459 if (temp1)
4460 delete arg1;
4461 }
4462 return NULL;
4463 }
4464
4465
4466 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4467 PyObject *resultobj = 0;
4468 wxString *arg1 = 0 ;
4469 int result;
4470 bool temp1 = false ;
4471 PyObject * obj0 = 0 ;
4472 char * kwnames[] = {
4473 (char *) "name", NULL
4474 };
4475
4476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4477 {
4478 arg1 = wxString_in_helper(obj0);
4479 if (arg1 == NULL) SWIG_fail;
4480 temp1 = true;
4481 }
4482 {
4483 PyThreadState* __tstate = wxPyBeginAllowThreads();
4484 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4485 wxPyEndAllowThreads(__tstate);
4486 if (PyErr_Occurred()) SWIG_fail;
4487 }
4488 resultobj = SWIG_From_int(static_cast< int >(result));
4489 {
4490 if (temp1)
4491 delete arg1;
4492 }
4493 return resultobj;
4494 fail:
4495 {
4496 if (temp1)
4497 delete arg1;
4498 }
4499 return NULL;
4500 }
4501
4502
4503 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4504 PyObject *resultobj = 0;
4505 wxString *arg1 = 0 ;
4506 bool result;
4507 bool temp1 = false ;
4508 PyObject * obj0 = 0 ;
4509 char * kwnames[] = {
4510 (char *) "name", NULL
4511 };
4512
4513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4514 {
4515 arg1 = wxString_in_helper(obj0);
4516 if (arg1 == NULL) SWIG_fail;
4517 temp1 = true;
4518 }
4519 {
4520 PyThreadState* __tstate = wxPyBeginAllowThreads();
4521 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4522 wxPyEndAllowThreads(__tstate);
4523 if (PyErr_Occurred()) SWIG_fail;
4524 }
4525 {
4526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4527 }
4528 {
4529 if (temp1)
4530 delete arg1;
4531 }
4532 return resultobj;
4533 fail:
4534 {
4535 if (temp1)
4536 delete arg1;
4537 }
4538 return NULL;
4539 }
4540
4541
4542 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4543 PyObject *resultobj = 0;
4544 wxString *arg1 = 0 ;
4545 bool result;
4546 bool temp1 = false ;
4547 PyObject * obj0 = 0 ;
4548 char * kwnames[] = {
4549 (char *) "name", NULL
4550 };
4551
4552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4553 {
4554 arg1 = wxString_in_helper(obj0);
4555 if (arg1 == NULL) SWIG_fail;
4556 temp1 = true;
4557 }
4558 {
4559 PyThreadState* __tstate = wxPyBeginAllowThreads();
4560 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4561 wxPyEndAllowThreads(__tstate);
4562 if (PyErr_Occurred()) SWIG_fail;
4563 }
4564 {
4565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4566 }
4567 {
4568 if (temp1)
4569 delete arg1;
4570 }
4571 return resultobj;
4572 fail:
4573 {
4574 if (temp1)
4575 delete arg1;
4576 }
4577 return NULL;
4578 }
4579
4580
4581 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4582 PyObject *obj;
4583 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4584 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4585 return SWIG_Py_Void();
4586 }
4587
4588 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4589 return SWIG_Python_InitShadowInstance(args);
4590 }
4591
4592 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4593 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4594 return 1;
4595 }
4596
4597
4598 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4599 PyObject *pyobj = 0;
4600
4601 {
4602 #if wxUSE_UNICODE
4603 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4604 #else
4605 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4606 #endif
4607 }
4608 return pyobj;
4609 }
4610
4611
4612 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4613 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4614 return 1;
4615 }
4616
4617
4618 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4619 PyObject *pyobj = 0;
4620
4621 {
4622 #if wxUSE_UNICODE
4623 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4624 #else
4625 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4626 #endif
4627 }
4628 return pyobj;
4629 }
4630
4631
4632 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4633 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4634 return 1;
4635 }
4636
4637
4638 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4639 PyObject *pyobj = 0;
4640
4641 {
4642 #if wxUSE_UNICODE
4643 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4644 #else
4645 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4646 #endif
4647 }
4648 return pyobj;
4649 }
4650
4651
4652 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4653 PyObject *resultobj = 0;
4654 long result;
4655
4656 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4657 {
4658 PyThreadState* __tstate = wxPyBeginAllowThreads();
4659 result = (long)wxNewId();
4660 wxPyEndAllowThreads(__tstate);
4661 if (PyErr_Occurred()) SWIG_fail;
4662 }
4663 resultobj = SWIG_From_long(static_cast< long >(result));
4664 return resultobj;
4665 fail:
4666 return NULL;
4667 }
4668
4669
4670 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4671 PyObject *resultobj = 0;
4672 long arg1 ;
4673 long val1 ;
4674 int ecode1 = 0 ;
4675 PyObject * obj0 = 0 ;
4676 char * kwnames[] = {
4677 (char *) "id", NULL
4678 };
4679
4680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4681 ecode1 = SWIG_AsVal_long(obj0, &val1);
4682 if (!SWIG_IsOK(ecode1)) {
4683 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4684 }
4685 arg1 = static_cast< long >(val1);
4686 {
4687 PyThreadState* __tstate = wxPyBeginAllowThreads();
4688 wxRegisterId(arg1);
4689 wxPyEndAllowThreads(__tstate);
4690 if (PyErr_Occurred()) SWIG_fail;
4691 }
4692 resultobj = SWIG_Py_Void();
4693 return resultobj;
4694 fail:
4695 return NULL;
4696 }
4697
4698
4699 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4700 PyObject *resultobj = 0;
4701 long result;
4702
4703 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4704 {
4705 PyThreadState* __tstate = wxPyBeginAllowThreads();
4706 result = (long)wxGetCurrentId();
4707 wxPyEndAllowThreads(__tstate);
4708 if (PyErr_Occurred()) SWIG_fail;
4709 }
4710 resultobj = SWIG_From_long(static_cast< long >(result));
4711 return resultobj;
4712 fail:
4713 return NULL;
4714 }
4715
4716
4717 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4718 PyObject *resultobj = 0;
4719 int arg1 ;
4720 bool result;
4721 int val1 ;
4722 int ecode1 = 0 ;
4723 PyObject * obj0 = 0 ;
4724 char * kwnames[] = {
4725 (char *) "id", NULL
4726 };
4727
4728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4729 ecode1 = SWIG_AsVal_int(obj0, &val1);
4730 if (!SWIG_IsOK(ecode1)) {
4731 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4732 }
4733 arg1 = static_cast< int >(val1);
4734 {
4735 PyThreadState* __tstate = wxPyBeginAllowThreads();
4736 result = (bool)wxIsStockID(arg1);
4737 wxPyEndAllowThreads(__tstate);
4738 if (PyErr_Occurred()) SWIG_fail;
4739 }
4740 {
4741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4742 }
4743 return resultobj;
4744 fail:
4745 return NULL;
4746 }
4747
4748
4749 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4750 PyObject *resultobj = 0;
4751 int arg1 ;
4752 wxString *arg2 = 0 ;
4753 bool result;
4754 int val1 ;
4755 int ecode1 = 0 ;
4756 bool temp2 = false ;
4757 PyObject * obj0 = 0 ;
4758 PyObject * obj1 = 0 ;
4759 char * kwnames[] = {
4760 (char *) "id",(char *) "label", NULL
4761 };
4762
4763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4764 ecode1 = SWIG_AsVal_int(obj0, &val1);
4765 if (!SWIG_IsOK(ecode1)) {
4766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4767 }
4768 arg1 = static_cast< int >(val1);
4769 {
4770 arg2 = wxString_in_helper(obj1);
4771 if (arg2 == NULL) SWIG_fail;
4772 temp2 = true;
4773 }
4774 {
4775 PyThreadState* __tstate = wxPyBeginAllowThreads();
4776 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4777 wxPyEndAllowThreads(__tstate);
4778 if (PyErr_Occurred()) SWIG_fail;
4779 }
4780 {
4781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4782 }
4783 {
4784 if (temp2)
4785 delete arg2;
4786 }
4787 return resultobj;
4788 fail:
4789 {
4790 if (temp2)
4791 delete arg2;
4792 }
4793 return NULL;
4794 }
4795
4796
4797 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4798 PyObject *resultobj = 0;
4799 int arg1 ;
4800 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4801 wxString result;
4802 int val1 ;
4803 int ecode1 = 0 ;
4804 long val2 ;
4805 int ecode2 = 0 ;
4806 PyObject * obj0 = 0 ;
4807 PyObject * obj1 = 0 ;
4808 char * kwnames[] = {
4809 (char *) "id",(char *) "flags", NULL
4810 };
4811
4812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4813 ecode1 = SWIG_AsVal_int(obj0, &val1);
4814 if (!SWIG_IsOK(ecode1)) {
4815 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4816 }
4817 arg1 = static_cast< int >(val1);
4818 if (obj1) {
4819 ecode2 = SWIG_AsVal_long(obj1, &val2);
4820 if (!SWIG_IsOK(ecode2)) {
4821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4822 }
4823 arg2 = static_cast< long >(val2);
4824 }
4825 {
4826 PyThreadState* __tstate = wxPyBeginAllowThreads();
4827 result = wxGetStockLabel(arg1,arg2);
4828 wxPyEndAllowThreads(__tstate);
4829 if (PyErr_Occurred()) SWIG_fail;
4830 }
4831 {
4832 #if wxUSE_UNICODE
4833 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4834 #else
4835 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4836 #endif
4837 }
4838 return resultobj;
4839 fail:
4840 return NULL;
4841 }
4842
4843
4844 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4845 PyObject *resultobj = 0;
4846 int arg1 ;
4847 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4848 wxString result;
4849 int val1 ;
4850 int ecode1 = 0 ;
4851 int val2 ;
4852 int ecode2 = 0 ;
4853 PyObject * obj0 = 0 ;
4854 PyObject * obj1 = 0 ;
4855 char * kwnames[] = {
4856 (char *) "id",(char *) "client", NULL
4857 };
4858
4859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4860 ecode1 = SWIG_AsVal_int(obj0, &val1);
4861 if (!SWIG_IsOK(ecode1)) {
4862 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4863 }
4864 arg1 = static_cast< int >(val1);
4865 if (obj1) {
4866 ecode2 = SWIG_AsVal_int(obj1, &val2);
4867 if (!SWIG_IsOK(ecode2)) {
4868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4869 }
4870 arg2 = static_cast< wxStockHelpStringClient >(val2);
4871 }
4872 {
4873 PyThreadState* __tstate = wxPyBeginAllowThreads();
4874 result = wxGetStockHelpString(arg1,arg2);
4875 wxPyEndAllowThreads(__tstate);
4876 if (PyErr_Occurred()) SWIG_fail;
4877 }
4878 {
4879 #if wxUSE_UNICODE
4880 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4881 #else
4882 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4883 #endif
4884 }
4885 return resultobj;
4886 fail:
4887 return NULL;
4888 }
4889
4890
4891 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4892 PyObject *resultobj = 0;
4893
4894 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4895 {
4896 if (!wxPyCheckForApp()) SWIG_fail;
4897 PyThreadState* __tstate = wxPyBeginAllowThreads();
4898 wxBell();
4899 wxPyEndAllowThreads(__tstate);
4900 if (PyErr_Occurred()) SWIG_fail;
4901 }
4902 resultobj = SWIG_Py_Void();
4903 return resultobj;
4904 fail:
4905 return NULL;
4906 }
4907
4908
4909 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4910 PyObject *resultobj = 0;
4911
4912 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4913 {
4914 if (!wxPyCheckForApp()) SWIG_fail;
4915 PyThreadState* __tstate = wxPyBeginAllowThreads();
4916 wxEndBusyCursor();
4917 wxPyEndAllowThreads(__tstate);
4918 if (PyErr_Occurred()) SWIG_fail;
4919 }
4920 resultobj = SWIG_Py_Void();
4921 return resultobj;
4922 fail:
4923 return NULL;
4924 }
4925
4926
4927 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4928 PyObject *resultobj = 0;
4929 bool arg1 = (bool) true ;
4930 long result;
4931 bool val1 ;
4932 int ecode1 = 0 ;
4933 PyObject * obj0 = 0 ;
4934 char * kwnames[] = {
4935 (char *) "resetTimer", NULL
4936 };
4937
4938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4939 if (obj0) {
4940 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4941 if (!SWIG_IsOK(ecode1)) {
4942 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4943 }
4944 arg1 = static_cast< bool >(val1);
4945 }
4946 {
4947 PyThreadState* __tstate = wxPyBeginAllowThreads();
4948 result = (long)wxGetElapsedTime(arg1);
4949 wxPyEndAllowThreads(__tstate);
4950 if (PyErr_Occurred()) SWIG_fail;
4951 }
4952 resultobj = SWIG_From_long(static_cast< long >(result));
4953 return resultobj;
4954 fail:
4955 return NULL;
4956 }
4957
4958
4959 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4960 PyObject *resultobj = 0;
4961 bool result;
4962
4963 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4964 {
4965 PyThreadState* __tstate = wxPyBeginAllowThreads();
4966 result = (bool)wxIsBusy();
4967 wxPyEndAllowThreads(__tstate);
4968 if (PyErr_Occurred()) SWIG_fail;
4969 }
4970 {
4971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4972 }
4973 return resultobj;
4974 fail:
4975 return NULL;
4976 }
4977
4978
4979 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4980 PyObject *resultobj = 0;
4981 wxString result;
4982
4983 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4984 {
4985 PyThreadState* __tstate = wxPyBeginAllowThreads();
4986 result = wxNow();
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 {
4991 #if wxUSE_UNICODE
4992 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4993 #else
4994 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4995 #endif
4996 }
4997 return resultobj;
4998 fail:
4999 return NULL;
5000 }
5001
5002
5003 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5004 PyObject *resultobj = 0;
5005 wxString const &arg1_defvalue = wxPyEmptyString ;
5006 wxString *arg1 = (wxString *) &arg1_defvalue ;
5007 bool result;
5008 bool temp1 = false ;
5009 PyObject * obj0 = 0 ;
5010 char * kwnames[] = {
5011 (char *) "command", NULL
5012 };
5013
5014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5015 if (obj0) {
5016 {
5017 arg1 = wxString_in_helper(obj0);
5018 if (arg1 == NULL) SWIG_fail;
5019 temp1 = true;
5020 }
5021 }
5022 {
5023 PyThreadState* __tstate = wxPyBeginAllowThreads();
5024 result = (bool)wxShell((wxString const &)*arg1);
5025 wxPyEndAllowThreads(__tstate);
5026 if (PyErr_Occurred()) SWIG_fail;
5027 }
5028 {
5029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5030 }
5031 {
5032 if (temp1)
5033 delete arg1;
5034 }
5035 return resultobj;
5036 fail:
5037 {
5038 if (temp1)
5039 delete arg1;
5040 }
5041 return NULL;
5042 }
5043
5044
5045 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5046 PyObject *resultobj = 0;
5047
5048 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5049 {
5050 PyThreadState* __tstate = wxPyBeginAllowThreads();
5051 wxStartTimer();
5052 wxPyEndAllowThreads(__tstate);
5053 if (PyErr_Occurred()) SWIG_fail;
5054 }
5055 resultobj = SWIG_Py_Void();
5056 return resultobj;
5057 fail:
5058 return NULL;
5059 }
5060
5061
5062 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5063 PyObject *resultobj = 0;
5064 int *arg1 = (int *) 0 ;
5065 int *arg2 = (int *) 0 ;
5066 int result;
5067 int temp1 ;
5068 int res1 = SWIG_TMPOBJ ;
5069 int temp2 ;
5070 int res2 = SWIG_TMPOBJ ;
5071
5072 arg1 = &temp1;
5073 arg2 = &temp2;
5074 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5075 {
5076 PyThreadState* __tstate = wxPyBeginAllowThreads();
5077 result = (int)wxGetOsVersion(arg1,arg2);
5078 wxPyEndAllowThreads(__tstate);
5079 if (PyErr_Occurred()) SWIG_fail;
5080 }
5081 resultobj = SWIG_From_int(static_cast< int >(result));
5082 if (SWIG_IsTmpObj(res1)) {
5083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5084 } else {
5085 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5087 }
5088 if (SWIG_IsTmpObj(res2)) {
5089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5090 } else {
5091 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5093 }
5094 return resultobj;
5095 fail:
5096 return NULL;
5097 }
5098
5099
5100 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5101 PyObject *resultobj = 0;
5102 wxString result;
5103
5104 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5105 {
5106 PyThreadState* __tstate = wxPyBeginAllowThreads();
5107 result = wxGetOsDescription();
5108 wxPyEndAllowThreads(__tstate);
5109 if (PyErr_Occurred()) SWIG_fail;
5110 }
5111 {
5112 #if wxUSE_UNICODE
5113 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5114 #else
5115 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5116 #endif
5117 }
5118 return resultobj;
5119 fail:
5120 return NULL;
5121 }
5122
5123
5124 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5125 PyObject *resultobj = 0;
5126 bool result;
5127
5128 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5129 {
5130 PyThreadState* __tstate = wxPyBeginAllowThreads();
5131 result = (bool)wxIsPlatformLittleEndian();
5132 wxPyEndAllowThreads(__tstate);
5133 if (PyErr_Occurred()) SWIG_fail;
5134 }
5135 {
5136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5137 }
5138 return resultobj;
5139 fail:
5140 return NULL;
5141 }
5142
5143
5144 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5145 PyObject *resultobj = 0;
5146 bool result;
5147
5148 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5149 {
5150 PyThreadState* __tstate = wxPyBeginAllowThreads();
5151 result = (bool)wxIsPlatform64Bit();
5152 wxPyEndAllowThreads(__tstate);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 {
5156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5157 }
5158 return resultobj;
5159 fail:
5160 return NULL;
5161 }
5162
5163
5164 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5165 PyObject *resultobj = 0;
5166 wxMemorySize result;
5167
5168 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5169 {
5170 PyThreadState* __tstate = wxPyBeginAllowThreads();
5171 result = wxGetFreeMemory();
5172 wxPyEndAllowThreads(__tstate);
5173 if (PyErr_Occurred()) SWIG_fail;
5174 }
5175 {
5176 #if wxUSE_LONGLONG
5177 resultobj = PyLong_FromLongLong((&result)->GetValue());
5178 #else
5179 resultobj = PyInt_FromLong(result);
5180 #endif
5181 }
5182 return resultobj;
5183 fail:
5184 return NULL;
5185 }
5186
5187
5188 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5189 PyObject *resultobj = 0;
5190 wxShutdownFlags arg1 ;
5191 bool result;
5192 int val1 ;
5193 int ecode1 = 0 ;
5194 PyObject * obj0 = 0 ;
5195 char * kwnames[] = {
5196 (char *) "wFlags", NULL
5197 };
5198
5199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5200 ecode1 = SWIG_AsVal_int(obj0, &val1);
5201 if (!SWIG_IsOK(ecode1)) {
5202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5203 }
5204 arg1 = static_cast< wxShutdownFlags >(val1);
5205 {
5206 if (!wxPyCheckForApp()) SWIG_fail;
5207 PyThreadState* __tstate = wxPyBeginAllowThreads();
5208 result = (bool)wxShutdown(arg1);
5209 wxPyEndAllowThreads(__tstate);
5210 if (PyErr_Occurred()) SWIG_fail;
5211 }
5212 {
5213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5214 }
5215 return resultobj;
5216 fail:
5217 return NULL;
5218 }
5219
5220
5221 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5222 PyObject *resultobj = 0;
5223 int arg1 ;
5224 int val1 ;
5225 int ecode1 = 0 ;
5226 PyObject * obj0 = 0 ;
5227 char * kwnames[] = {
5228 (char *) "secs", NULL
5229 };
5230
5231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5232 ecode1 = SWIG_AsVal_int(obj0, &val1);
5233 if (!SWIG_IsOK(ecode1)) {
5234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5235 }
5236 arg1 = static_cast< int >(val1);
5237 {
5238 PyThreadState* __tstate = wxPyBeginAllowThreads();
5239 wxSleep(arg1);
5240 wxPyEndAllowThreads(__tstate);
5241 if (PyErr_Occurred()) SWIG_fail;
5242 }
5243 resultobj = SWIG_Py_Void();
5244 return resultobj;
5245 fail:
5246 return NULL;
5247 }
5248
5249
5250 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5251 PyObject *resultobj = 0;
5252 unsigned long arg1 ;
5253 unsigned long val1 ;
5254 int ecode1 = 0 ;
5255 PyObject * obj0 = 0 ;
5256 char * kwnames[] = {
5257 (char *) "milliseconds", NULL
5258 };
5259
5260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5261 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5262 if (!SWIG_IsOK(ecode1)) {
5263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5264 }
5265 arg1 = static_cast< unsigned long >(val1);
5266 {
5267 PyThreadState* __tstate = wxPyBeginAllowThreads();
5268 wxMilliSleep(arg1);
5269 wxPyEndAllowThreads(__tstate);
5270 if (PyErr_Occurred()) SWIG_fail;
5271 }
5272 resultobj = SWIG_Py_Void();
5273 return resultobj;
5274 fail:
5275 return NULL;
5276 }
5277
5278
5279 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5280 PyObject *resultobj = 0;
5281 unsigned long arg1 ;
5282 unsigned long val1 ;
5283 int ecode1 = 0 ;
5284 PyObject * obj0 = 0 ;
5285 char * kwnames[] = {
5286 (char *) "microseconds", NULL
5287 };
5288
5289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5290 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5291 if (!SWIG_IsOK(ecode1)) {
5292 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5293 }
5294 arg1 = static_cast< unsigned long >(val1);
5295 {
5296 PyThreadState* __tstate = wxPyBeginAllowThreads();
5297 wxMicroSleep(arg1);
5298 wxPyEndAllowThreads(__tstate);
5299 if (PyErr_Occurred()) SWIG_fail;
5300 }
5301 resultobj = SWIG_Py_Void();
5302 return resultobj;
5303 fail:
5304 return NULL;
5305 }
5306
5307
5308 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5309 PyObject *resultobj = 0;
5310 bool arg1 ;
5311 bool val1 ;
5312 int ecode1 = 0 ;
5313 PyObject * obj0 = 0 ;
5314 char * kwnames[] = {
5315 (char *) "enable", NULL
5316 };
5317
5318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5319 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5320 if (!SWIG_IsOK(ecode1)) {
5321 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5322 }
5323 arg1 = static_cast< bool >(val1);
5324 {
5325 PyThreadState* __tstate = wxPyBeginAllowThreads();
5326 wxEnableTopLevelWindows(arg1);
5327 wxPyEndAllowThreads(__tstate);
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 resultobj = SWIG_Py_Void();
5331 return resultobj;
5332 fail:
5333 return NULL;
5334 }
5335
5336
5337 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5338 PyObject *resultobj = 0;
5339 wxString *arg1 = 0 ;
5340 wxString result;
5341 bool temp1 = false ;
5342 PyObject * obj0 = 0 ;
5343 char * kwnames[] = {
5344 (char *) "in", NULL
5345 };
5346
5347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5348 {
5349 arg1 = wxString_in_helper(obj0);
5350 if (arg1 == NULL) SWIG_fail;
5351 temp1 = true;
5352 }
5353 {
5354 PyThreadState* __tstate = wxPyBeginAllowThreads();
5355 result = wxStripMenuCodes((wxString const &)*arg1);
5356 wxPyEndAllowThreads(__tstate);
5357 if (PyErr_Occurred()) SWIG_fail;
5358 }
5359 {
5360 #if wxUSE_UNICODE
5361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5362 #else
5363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5364 #endif
5365 }
5366 {
5367 if (temp1)
5368 delete arg1;
5369 }
5370 return resultobj;
5371 fail:
5372 {
5373 if (temp1)
5374 delete arg1;
5375 }
5376 return NULL;
5377 }
5378
5379
5380 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5381 PyObject *resultobj = 0;
5382 wxString result;
5383
5384 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5385 {
5386 PyThreadState* __tstate = wxPyBeginAllowThreads();
5387 result = wxGetEmailAddress();
5388 wxPyEndAllowThreads(__tstate);
5389 if (PyErr_Occurred()) SWIG_fail;
5390 }
5391 {
5392 #if wxUSE_UNICODE
5393 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5394 #else
5395 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5396 #endif
5397 }
5398 return resultobj;
5399 fail:
5400 return NULL;
5401 }
5402
5403
5404 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5405 PyObject *resultobj = 0;
5406 wxString result;
5407
5408 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5409 {
5410 PyThreadState* __tstate = wxPyBeginAllowThreads();
5411 result = wxGetHostName();
5412 wxPyEndAllowThreads(__tstate);
5413 if (PyErr_Occurred()) SWIG_fail;
5414 }
5415 {
5416 #if wxUSE_UNICODE
5417 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5418 #else
5419 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5420 #endif
5421 }
5422 return resultobj;
5423 fail:
5424 return NULL;
5425 }
5426
5427
5428 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5429 PyObject *resultobj = 0;
5430 wxString result;
5431
5432 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5433 {
5434 PyThreadState* __tstate = wxPyBeginAllowThreads();
5435 result = wxGetFullHostName();
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 {
5440 #if wxUSE_UNICODE
5441 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5442 #else
5443 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5444 #endif
5445 }
5446 return resultobj;
5447 fail:
5448 return NULL;
5449 }
5450
5451
5452 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5453 PyObject *resultobj = 0;
5454 wxString result;
5455
5456 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5457 {
5458 PyThreadState* __tstate = wxPyBeginAllowThreads();
5459 result = wxGetUserId();
5460 wxPyEndAllowThreads(__tstate);
5461 if (PyErr_Occurred()) SWIG_fail;
5462 }
5463 {
5464 #if wxUSE_UNICODE
5465 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5466 #else
5467 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5468 #endif
5469 }
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5477 PyObject *resultobj = 0;
5478 wxString result;
5479
5480 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5481 {
5482 PyThreadState* __tstate = wxPyBeginAllowThreads();
5483 result = wxGetUserName();
5484 wxPyEndAllowThreads(__tstate);
5485 if (PyErr_Occurred()) SWIG_fail;
5486 }
5487 {
5488 #if wxUSE_UNICODE
5489 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5490 #else
5491 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5492 #endif
5493 }
5494 return resultobj;
5495 fail:
5496 return NULL;
5497 }
5498
5499
5500 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5501 PyObject *resultobj = 0;
5502 wxString result;
5503
5504 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5505 {
5506 PyThreadState* __tstate = wxPyBeginAllowThreads();
5507 result = wxGetHomeDir();
5508 wxPyEndAllowThreads(__tstate);
5509 if (PyErr_Occurred()) SWIG_fail;
5510 }
5511 {
5512 #if wxUSE_UNICODE
5513 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5514 #else
5515 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5516 #endif
5517 }
5518 return resultobj;
5519 fail:
5520 return NULL;
5521 }
5522
5523
5524 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5525 PyObject *resultobj = 0;
5526 wxString const &arg1_defvalue = wxPyEmptyString ;
5527 wxString *arg1 = (wxString *) &arg1_defvalue ;
5528 wxString result;
5529 bool temp1 = false ;
5530 PyObject * obj0 = 0 ;
5531 char * kwnames[] = {
5532 (char *) "user", NULL
5533 };
5534
5535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5536 if (obj0) {
5537 {
5538 arg1 = wxString_in_helper(obj0);
5539 if (arg1 == NULL) SWIG_fail;
5540 temp1 = true;
5541 }
5542 }
5543 {
5544 PyThreadState* __tstate = wxPyBeginAllowThreads();
5545 result = wxGetUserHome((wxString const &)*arg1);
5546 wxPyEndAllowThreads(__tstate);
5547 if (PyErr_Occurred()) SWIG_fail;
5548 }
5549 {
5550 #if wxUSE_UNICODE
5551 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5552 #else
5553 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5554 #endif
5555 }
5556 {
5557 if (temp1)
5558 delete arg1;
5559 }
5560 return resultobj;
5561 fail:
5562 {
5563 if (temp1)
5564 delete arg1;
5565 }
5566 return NULL;
5567 }
5568
5569
5570 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5571 PyObject *resultobj = 0;
5572 unsigned long result;
5573
5574 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5575 {
5576 PyThreadState* __tstate = wxPyBeginAllowThreads();
5577 result = (unsigned long)wxGetProcessId();
5578 wxPyEndAllowThreads(__tstate);
5579 if (PyErr_Occurred()) SWIG_fail;
5580 }
5581 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5589 PyObject *resultobj = 0;
5590
5591 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5592 {
5593 PyThreadState* __tstate = wxPyBeginAllowThreads();
5594 wxTrap();
5595 wxPyEndAllowThreads(__tstate);
5596 if (PyErr_Occurred()) SWIG_fail;
5597 }
5598 resultobj = SWIG_Py_Void();
5599 return resultobj;
5600 fail:
5601 return NULL;
5602 }
5603
5604
5605 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5606 PyObject *resultobj = 0;
5607 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5608 wxString *arg1 = (wxString *) &arg1_defvalue ;
5609 wxString const &arg2_defvalue = wxPyEmptyString ;
5610 wxString *arg2 = (wxString *) &arg2_defvalue ;
5611 wxString const &arg3_defvalue = wxPyEmptyString ;
5612 wxString *arg3 = (wxString *) &arg3_defvalue ;
5613 wxString const &arg4_defvalue = wxPyEmptyString ;
5614 wxString *arg4 = (wxString *) &arg4_defvalue ;
5615 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5616 wxString *arg5 = (wxString *) &arg5_defvalue ;
5617 int arg6 = (int) 0 ;
5618 wxWindow *arg7 = (wxWindow *) NULL ;
5619 int arg8 = (int) -1 ;
5620 int arg9 = (int) -1 ;
5621 wxString result;
5622 bool temp1 = false ;
5623 bool temp2 = false ;
5624 bool temp3 = false ;
5625 bool temp4 = false ;
5626 bool temp5 = false ;
5627 int val6 ;
5628 int ecode6 = 0 ;
5629 void *argp7 = 0 ;
5630 int res7 = 0 ;
5631 int val8 ;
5632 int ecode8 = 0 ;
5633 int val9 ;
5634 int ecode9 = 0 ;
5635 PyObject * obj0 = 0 ;
5636 PyObject * obj1 = 0 ;
5637 PyObject * obj2 = 0 ;
5638 PyObject * obj3 = 0 ;
5639 PyObject * obj4 = 0 ;
5640 PyObject * obj5 = 0 ;
5641 PyObject * obj6 = 0 ;
5642 PyObject * obj7 = 0 ;
5643 PyObject * obj8 = 0 ;
5644 char * kwnames[] = {
5645 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5646 };
5647
5648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5649 if (obj0) {
5650 {
5651 arg1 = wxString_in_helper(obj0);
5652 if (arg1 == NULL) SWIG_fail;
5653 temp1 = true;
5654 }
5655 }
5656 if (obj1) {
5657 {
5658 arg2 = wxString_in_helper(obj1);
5659 if (arg2 == NULL) SWIG_fail;
5660 temp2 = true;
5661 }
5662 }
5663 if (obj2) {
5664 {
5665 arg3 = wxString_in_helper(obj2);
5666 if (arg3 == NULL) SWIG_fail;
5667 temp3 = true;
5668 }
5669 }
5670 if (obj3) {
5671 {
5672 arg4 = wxString_in_helper(obj3);
5673 if (arg4 == NULL) SWIG_fail;
5674 temp4 = true;
5675 }
5676 }
5677 if (obj4) {
5678 {
5679 arg5 = wxString_in_helper(obj4);
5680 if (arg5 == NULL) SWIG_fail;
5681 temp5 = true;
5682 }
5683 }
5684 if (obj5) {
5685 ecode6 = SWIG_AsVal_int(obj5, &val6);
5686 if (!SWIG_IsOK(ecode6)) {
5687 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5688 }
5689 arg6 = static_cast< int >(val6);
5690 }
5691 if (obj6) {
5692 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5693 if (!SWIG_IsOK(res7)) {
5694 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5695 }
5696 arg7 = reinterpret_cast< wxWindow * >(argp7);
5697 }
5698 if (obj7) {
5699 ecode8 = SWIG_AsVal_int(obj7, &val8);
5700 if (!SWIG_IsOK(ecode8)) {
5701 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5702 }
5703 arg8 = static_cast< int >(val8);
5704 }
5705 if (obj8) {
5706 ecode9 = SWIG_AsVal_int(obj8, &val9);
5707 if (!SWIG_IsOK(ecode9)) {
5708 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5709 }
5710 arg9 = static_cast< int >(val9);
5711 }
5712 {
5713 if (!wxPyCheckForApp()) SWIG_fail;
5714 PyThreadState* __tstate = wxPyBeginAllowThreads();
5715 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5716 wxPyEndAllowThreads(__tstate);
5717 if (PyErr_Occurred()) SWIG_fail;
5718 }
5719 {
5720 #if wxUSE_UNICODE
5721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5722 #else
5723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5724 #endif
5725 }
5726 {
5727 if (temp1)
5728 delete arg1;
5729 }
5730 {
5731 if (temp2)
5732 delete arg2;
5733 }
5734 {
5735 if (temp3)
5736 delete arg3;
5737 }
5738 {
5739 if (temp4)
5740 delete arg4;
5741 }
5742 {
5743 if (temp5)
5744 delete arg5;
5745 }
5746 return resultobj;
5747 fail:
5748 {
5749 if (temp1)
5750 delete arg1;
5751 }
5752 {
5753 if (temp2)
5754 delete arg2;
5755 }
5756 {
5757 if (temp3)
5758 delete arg3;
5759 }
5760 {
5761 if (temp4)
5762 delete arg4;
5763 }
5764 {
5765 if (temp5)
5766 delete arg5;
5767 }
5768 return NULL;
5769 }
5770
5771
5772 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5773 PyObject *resultobj = 0;
5774 wxString *arg1 = 0 ;
5775 wxString *arg2 = 0 ;
5776 wxString const &arg3_defvalue = wxPyEmptyString ;
5777 wxString *arg3 = (wxString *) &arg3_defvalue ;
5778 wxWindow *arg4 = (wxWindow *) NULL ;
5779 wxString result;
5780 bool temp1 = false ;
5781 bool temp2 = false ;
5782 bool temp3 = false ;
5783 void *argp4 = 0 ;
5784 int res4 = 0 ;
5785 PyObject * obj0 = 0 ;
5786 PyObject * obj1 = 0 ;
5787 PyObject * obj2 = 0 ;
5788 PyObject * obj3 = 0 ;
5789 char * kwnames[] = {
5790 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5791 };
5792
5793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5794 {
5795 arg1 = wxString_in_helper(obj0);
5796 if (arg1 == NULL) SWIG_fail;
5797 temp1 = true;
5798 }
5799 {
5800 arg2 = wxString_in_helper(obj1);
5801 if (arg2 == NULL) SWIG_fail;
5802 temp2 = true;
5803 }
5804 if (obj2) {
5805 {
5806 arg3 = wxString_in_helper(obj2);
5807 if (arg3 == NULL) SWIG_fail;
5808 temp3 = true;
5809 }
5810 }
5811 if (obj3) {
5812 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5813 if (!SWIG_IsOK(res4)) {
5814 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5815 }
5816 arg4 = reinterpret_cast< wxWindow * >(argp4);
5817 }
5818 {
5819 if (!wxPyCheckForApp()) SWIG_fail;
5820 PyThreadState* __tstate = wxPyBeginAllowThreads();
5821 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5822 wxPyEndAllowThreads(__tstate);
5823 if (PyErr_Occurred()) SWIG_fail;
5824 }
5825 {
5826 #if wxUSE_UNICODE
5827 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5828 #else
5829 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5830 #endif
5831 }
5832 {
5833 if (temp1)
5834 delete arg1;
5835 }
5836 {
5837 if (temp2)
5838 delete arg2;
5839 }
5840 {
5841 if (temp3)
5842 delete arg3;
5843 }
5844 return resultobj;
5845 fail:
5846 {
5847 if (temp1)
5848 delete arg1;
5849 }
5850 {
5851 if (temp2)
5852 delete arg2;
5853 }
5854 {
5855 if (temp3)
5856 delete arg3;
5857 }
5858 return NULL;
5859 }
5860
5861
5862 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5863 PyObject *resultobj = 0;
5864 wxString *arg1 = 0 ;
5865 wxString *arg2 = 0 ;
5866 wxString const &arg3_defvalue = wxPyEmptyString ;
5867 wxString *arg3 = (wxString *) &arg3_defvalue ;
5868 wxWindow *arg4 = (wxWindow *) NULL ;
5869 wxString result;
5870 bool temp1 = false ;
5871 bool temp2 = false ;
5872 bool temp3 = false ;
5873 void *argp4 = 0 ;
5874 int res4 = 0 ;
5875 PyObject * obj0 = 0 ;
5876 PyObject * obj1 = 0 ;
5877 PyObject * obj2 = 0 ;
5878 PyObject * obj3 = 0 ;
5879 char * kwnames[] = {
5880 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5881 };
5882
5883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5884 {
5885 arg1 = wxString_in_helper(obj0);
5886 if (arg1 == NULL) SWIG_fail;
5887 temp1 = true;
5888 }
5889 {
5890 arg2 = wxString_in_helper(obj1);
5891 if (arg2 == NULL) SWIG_fail;
5892 temp2 = true;
5893 }
5894 if (obj2) {
5895 {
5896 arg3 = wxString_in_helper(obj2);
5897 if (arg3 == NULL) SWIG_fail;
5898 temp3 = true;
5899 }
5900 }
5901 if (obj3) {
5902 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5903 if (!SWIG_IsOK(res4)) {
5904 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5905 }
5906 arg4 = reinterpret_cast< wxWindow * >(argp4);
5907 }
5908 {
5909 if (!wxPyCheckForApp()) SWIG_fail;
5910 PyThreadState* __tstate = wxPyBeginAllowThreads();
5911 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5912 wxPyEndAllowThreads(__tstate);
5913 if (PyErr_Occurred()) SWIG_fail;
5914 }
5915 {
5916 #if wxUSE_UNICODE
5917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5918 #else
5919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5920 #endif
5921 }
5922 {
5923 if (temp1)
5924 delete arg1;
5925 }
5926 {
5927 if (temp2)
5928 delete arg2;
5929 }
5930 {
5931 if (temp3)
5932 delete arg3;
5933 }
5934 return resultobj;
5935 fail:
5936 {
5937 if (temp1)
5938 delete arg1;
5939 }
5940 {
5941 if (temp2)
5942 delete arg2;
5943 }
5944 {
5945 if (temp3)
5946 delete arg3;
5947 }
5948 return NULL;
5949 }
5950
5951
5952 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5953 PyObject *resultobj = 0;
5954 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5955 wxString *arg1 = (wxString *) &arg1_defvalue ;
5956 wxString const &arg2_defvalue = wxPyEmptyString ;
5957 wxString *arg2 = (wxString *) &arg2_defvalue ;
5958 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5959 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5960 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5961 wxWindow *arg5 = (wxWindow *) NULL ;
5962 wxString result;
5963 bool temp1 = false ;
5964 bool temp2 = false ;
5965 long val3 ;
5966 int ecode3 = 0 ;
5967 wxPoint temp4 ;
5968 void *argp5 = 0 ;
5969 int res5 = 0 ;
5970 PyObject * obj0 = 0 ;
5971 PyObject * obj1 = 0 ;
5972 PyObject * obj2 = 0 ;
5973 PyObject * obj3 = 0 ;
5974 PyObject * obj4 = 0 ;
5975 char * kwnames[] = {
5976 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5977 };
5978
5979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5980 if (obj0) {
5981 {
5982 arg1 = wxString_in_helper(obj0);
5983 if (arg1 == NULL) SWIG_fail;
5984 temp1 = true;
5985 }
5986 }
5987 if (obj1) {
5988 {
5989 arg2 = wxString_in_helper(obj1);
5990 if (arg2 == NULL) SWIG_fail;
5991 temp2 = true;
5992 }
5993 }
5994 if (obj2) {
5995 ecode3 = SWIG_AsVal_long(obj2, &val3);
5996 if (!SWIG_IsOK(ecode3)) {
5997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5998 }
5999 arg3 = static_cast< long >(val3);
6000 }
6001 if (obj3) {
6002 {
6003 arg4 = &temp4;
6004 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6005 }
6006 }
6007 if (obj4) {
6008 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6009 if (!SWIG_IsOK(res5)) {
6010 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6011 }
6012 arg5 = reinterpret_cast< wxWindow * >(argp5);
6013 }
6014 {
6015 if (!wxPyCheckForApp()) SWIG_fail;
6016 PyThreadState* __tstate = wxPyBeginAllowThreads();
6017 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6018 wxPyEndAllowThreads(__tstate);
6019 if (PyErr_Occurred()) SWIG_fail;
6020 }
6021 {
6022 #if wxUSE_UNICODE
6023 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6024 #else
6025 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6026 #endif
6027 }
6028 {
6029 if (temp1)
6030 delete arg1;
6031 }
6032 {
6033 if (temp2)
6034 delete arg2;
6035 }
6036 return resultobj;
6037 fail:
6038 {
6039 if (temp1)
6040 delete arg1;
6041 }
6042 {
6043 if (temp2)
6044 delete arg2;
6045 }
6046 return NULL;
6047 }
6048
6049
6050 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6051 PyObject *resultobj = 0;
6052 wxString *arg1 = 0 ;
6053 wxString const &arg2_defvalue = wxPyEmptyString ;
6054 wxString *arg2 = (wxString *) &arg2_defvalue ;
6055 wxString const &arg3_defvalue = wxPyEmptyString ;
6056 wxString *arg3 = (wxString *) &arg3_defvalue ;
6057 wxWindow *arg4 = (wxWindow *) NULL ;
6058 int arg5 = (int) -1 ;
6059 int arg6 = (int) -1 ;
6060 bool arg7 = (bool) true ;
6061 wxString result;
6062 bool temp1 = false ;
6063 bool temp2 = false ;
6064 bool temp3 = false ;
6065 void *argp4 = 0 ;
6066 int res4 = 0 ;
6067 int val5 ;
6068 int ecode5 = 0 ;
6069 int val6 ;
6070 int ecode6 = 0 ;
6071 bool val7 ;
6072 int ecode7 = 0 ;
6073 PyObject * obj0 = 0 ;
6074 PyObject * obj1 = 0 ;
6075 PyObject * obj2 = 0 ;
6076 PyObject * obj3 = 0 ;
6077 PyObject * obj4 = 0 ;
6078 PyObject * obj5 = 0 ;
6079 PyObject * obj6 = 0 ;
6080 char * kwnames[] = {
6081 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6082 };
6083
6084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6085 {
6086 arg1 = wxString_in_helper(obj0);
6087 if (arg1 == NULL) SWIG_fail;
6088 temp1 = true;
6089 }
6090 if (obj1) {
6091 {
6092 arg2 = wxString_in_helper(obj1);
6093 if (arg2 == NULL) SWIG_fail;
6094 temp2 = true;
6095 }
6096 }
6097 if (obj2) {
6098 {
6099 arg3 = wxString_in_helper(obj2);
6100 if (arg3 == NULL) SWIG_fail;
6101 temp3 = true;
6102 }
6103 }
6104 if (obj3) {
6105 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6106 if (!SWIG_IsOK(res4)) {
6107 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6108 }
6109 arg4 = reinterpret_cast< wxWindow * >(argp4);
6110 }
6111 if (obj4) {
6112 ecode5 = SWIG_AsVal_int(obj4, &val5);
6113 if (!SWIG_IsOK(ecode5)) {
6114 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6115 }
6116 arg5 = static_cast< int >(val5);
6117 }
6118 if (obj5) {
6119 ecode6 = SWIG_AsVal_int(obj5, &val6);
6120 if (!SWIG_IsOK(ecode6)) {
6121 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6122 }
6123 arg6 = static_cast< int >(val6);
6124 }
6125 if (obj6) {
6126 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6127 if (!SWIG_IsOK(ecode7)) {
6128 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6129 }
6130 arg7 = static_cast< bool >(val7);
6131 }
6132 {
6133 if (!wxPyCheckForApp()) SWIG_fail;
6134 PyThreadState* __tstate = wxPyBeginAllowThreads();
6135 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6136 wxPyEndAllowThreads(__tstate);
6137 if (PyErr_Occurred()) SWIG_fail;
6138 }
6139 {
6140 #if wxUSE_UNICODE
6141 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6142 #else
6143 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6144 #endif
6145 }
6146 {
6147 if (temp1)
6148 delete arg1;
6149 }
6150 {
6151 if (temp2)
6152 delete arg2;
6153 }
6154 {
6155 if (temp3)
6156 delete arg3;
6157 }
6158 return resultobj;
6159 fail:
6160 {
6161 if (temp1)
6162 delete arg1;
6163 }
6164 {
6165 if (temp2)
6166 delete arg2;
6167 }
6168 {
6169 if (temp3)
6170 delete arg3;
6171 }
6172 return NULL;
6173 }
6174
6175
6176 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6177 PyObject *resultobj = 0;
6178 wxString *arg1 = 0 ;
6179 wxString const &arg2_defvalue = wxPyEmptyString ;
6180 wxString *arg2 = (wxString *) &arg2_defvalue ;
6181 wxString const &arg3_defvalue = wxPyEmptyString ;
6182 wxString *arg3 = (wxString *) &arg3_defvalue ;
6183 wxWindow *arg4 = (wxWindow *) NULL ;
6184 wxString result;
6185 bool temp1 = false ;
6186 bool temp2 = false ;
6187 bool temp3 = false ;
6188 void *argp4 = 0 ;
6189 int res4 = 0 ;
6190 PyObject * obj0 = 0 ;
6191 PyObject * obj1 = 0 ;
6192 PyObject * obj2 = 0 ;
6193 PyObject * obj3 = 0 ;
6194 char * kwnames[] = {
6195 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6196 };
6197
6198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6199 {
6200 arg1 = wxString_in_helper(obj0);
6201 if (arg1 == NULL) SWIG_fail;
6202 temp1 = true;
6203 }
6204 if (obj1) {
6205 {
6206 arg2 = wxString_in_helper(obj1);
6207 if (arg2 == NULL) SWIG_fail;
6208 temp2 = true;
6209 }
6210 }
6211 if (obj2) {
6212 {
6213 arg3 = wxString_in_helper(obj2);
6214 if (arg3 == NULL) SWIG_fail;
6215 temp3 = true;
6216 }
6217 }
6218 if (obj3) {
6219 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6220 if (!SWIG_IsOK(res4)) {
6221 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6222 }
6223 arg4 = reinterpret_cast< wxWindow * >(argp4);
6224 }
6225 {
6226 if (!wxPyCheckForApp()) SWIG_fail;
6227 PyThreadState* __tstate = wxPyBeginAllowThreads();
6228 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6229 wxPyEndAllowThreads(__tstate);
6230 if (PyErr_Occurred()) SWIG_fail;
6231 }
6232 {
6233 #if wxUSE_UNICODE
6234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6235 #else
6236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6237 #endif
6238 }
6239 {
6240 if (temp1)
6241 delete arg1;
6242 }
6243 {
6244 if (temp2)
6245 delete arg2;
6246 }
6247 {
6248 if (temp3)
6249 delete arg3;
6250 }
6251 return resultobj;
6252 fail:
6253 {
6254 if (temp1)
6255 delete arg1;
6256 }
6257 {
6258 if (temp2)
6259 delete arg2;
6260 }
6261 {
6262 if (temp3)
6263 delete arg3;
6264 }
6265 return NULL;
6266 }
6267
6268
6269 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6270 PyObject *resultobj = 0;
6271 wxString *arg1 = 0 ;
6272 wxString *arg2 = 0 ;
6273 int arg3 ;
6274 wxString *arg4 = (wxString *) 0 ;
6275 wxWindow *arg5 = (wxWindow *) NULL ;
6276 int arg6 = (int) -1 ;
6277 int arg7 = (int) -1 ;
6278 bool arg8 = (bool) true ;
6279 int arg9 = (int) 150 ;
6280 int arg10 = (int) 200 ;
6281 wxString result;
6282 bool temp1 = false ;
6283 bool temp2 = false ;
6284 void *argp5 = 0 ;
6285 int res5 = 0 ;
6286 int val6 ;
6287 int ecode6 = 0 ;
6288 int val7 ;
6289 int ecode7 = 0 ;
6290 bool val8 ;
6291 int ecode8 = 0 ;
6292 int val9 ;
6293 int ecode9 = 0 ;
6294 int val10 ;
6295 int ecode10 = 0 ;
6296 PyObject * obj0 = 0 ;
6297 PyObject * obj1 = 0 ;
6298 PyObject * obj2 = 0 ;
6299 PyObject * obj3 = 0 ;
6300 PyObject * obj4 = 0 ;
6301 PyObject * obj5 = 0 ;
6302 PyObject * obj6 = 0 ;
6303 PyObject * obj7 = 0 ;
6304 PyObject * obj8 = 0 ;
6305 char * kwnames[] = {
6306 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6307 };
6308
6309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6310 {
6311 arg1 = wxString_in_helper(obj0);
6312 if (arg1 == NULL) SWIG_fail;
6313 temp1 = true;
6314 }
6315 {
6316 arg2 = wxString_in_helper(obj1);
6317 if (arg2 == NULL) SWIG_fail;
6318 temp2 = true;
6319 }
6320 {
6321 arg3 = PyList_Size(obj2);
6322 arg4 = wxString_LIST_helper(obj2);
6323 if (arg4 == NULL) SWIG_fail;
6324 }
6325 if (obj3) {
6326 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6327 if (!SWIG_IsOK(res5)) {
6328 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6329 }
6330 arg5 = reinterpret_cast< wxWindow * >(argp5);
6331 }
6332 if (obj4) {
6333 ecode6 = SWIG_AsVal_int(obj4, &val6);
6334 if (!SWIG_IsOK(ecode6)) {
6335 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6336 }
6337 arg6 = static_cast< int >(val6);
6338 }
6339 if (obj5) {
6340 ecode7 = SWIG_AsVal_int(obj5, &val7);
6341 if (!SWIG_IsOK(ecode7)) {
6342 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6343 }
6344 arg7 = static_cast< int >(val7);
6345 }
6346 if (obj6) {
6347 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6348 if (!SWIG_IsOK(ecode8)) {
6349 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6350 }
6351 arg8 = static_cast< bool >(val8);
6352 }
6353 if (obj7) {
6354 ecode9 = SWIG_AsVal_int(obj7, &val9);
6355 if (!SWIG_IsOK(ecode9)) {
6356 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6357 }
6358 arg9 = static_cast< int >(val9);
6359 }
6360 if (obj8) {
6361 ecode10 = SWIG_AsVal_int(obj8, &val10);
6362 if (!SWIG_IsOK(ecode10)) {
6363 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6364 }
6365 arg10 = static_cast< int >(val10);
6366 }
6367 {
6368 if (!wxPyCheckForApp()) SWIG_fail;
6369 PyThreadState* __tstate = wxPyBeginAllowThreads();
6370 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6371 wxPyEndAllowThreads(__tstate);
6372 if (PyErr_Occurred()) SWIG_fail;
6373 }
6374 {
6375 #if wxUSE_UNICODE
6376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6377 #else
6378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6379 #endif
6380 }
6381 {
6382 if (temp1)
6383 delete arg1;
6384 }
6385 {
6386 if (temp2)
6387 delete arg2;
6388 }
6389 {
6390 if (arg4) delete [] arg4;
6391 }
6392 return resultobj;
6393 fail:
6394 {
6395 if (temp1)
6396 delete arg1;
6397 }
6398 {
6399 if (temp2)
6400 delete arg2;
6401 }
6402 {
6403 if (arg4) delete [] arg4;
6404 }
6405 return NULL;
6406 }
6407
6408
6409 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6410 PyObject *resultobj = 0;
6411 wxString *arg1 = 0 ;
6412 wxString *arg2 = 0 ;
6413 int arg3 ;
6414 wxString *arg4 = (wxString *) 0 ;
6415 wxWindow *arg5 = (wxWindow *) NULL ;
6416 int arg6 = (int) -1 ;
6417 int arg7 = (int) -1 ;
6418 bool arg8 = (bool) true ;
6419 int arg9 = (int) 150 ;
6420 int arg10 = (int) 200 ;
6421 int result;
6422 bool temp1 = false ;
6423 bool temp2 = false ;
6424 void *argp5 = 0 ;
6425 int res5 = 0 ;
6426 int val6 ;
6427 int ecode6 = 0 ;
6428 int val7 ;
6429 int ecode7 = 0 ;
6430 bool val8 ;
6431 int ecode8 = 0 ;
6432 int val9 ;
6433 int ecode9 = 0 ;
6434 int val10 ;
6435 int ecode10 = 0 ;
6436 PyObject * obj0 = 0 ;
6437 PyObject * obj1 = 0 ;
6438 PyObject * obj2 = 0 ;
6439 PyObject * obj3 = 0 ;
6440 PyObject * obj4 = 0 ;
6441 PyObject * obj5 = 0 ;
6442 PyObject * obj6 = 0 ;
6443 PyObject * obj7 = 0 ;
6444 PyObject * obj8 = 0 ;
6445 char * kwnames[] = {
6446 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6447 };
6448
6449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6450 {
6451 arg1 = wxString_in_helper(obj0);
6452 if (arg1 == NULL) SWIG_fail;
6453 temp1 = true;
6454 }
6455 {
6456 arg2 = wxString_in_helper(obj1);
6457 if (arg2 == NULL) SWIG_fail;
6458 temp2 = true;
6459 }
6460 {
6461 arg3 = PyList_Size(obj2);
6462 arg4 = wxString_LIST_helper(obj2);
6463 if (arg4 == NULL) SWIG_fail;
6464 }
6465 if (obj3) {
6466 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6467 if (!SWIG_IsOK(res5)) {
6468 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6469 }
6470 arg5 = reinterpret_cast< wxWindow * >(argp5);
6471 }
6472 if (obj4) {
6473 ecode6 = SWIG_AsVal_int(obj4, &val6);
6474 if (!SWIG_IsOK(ecode6)) {
6475 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6476 }
6477 arg6 = static_cast< int >(val6);
6478 }
6479 if (obj5) {
6480 ecode7 = SWIG_AsVal_int(obj5, &val7);
6481 if (!SWIG_IsOK(ecode7)) {
6482 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6483 }
6484 arg7 = static_cast< int >(val7);
6485 }
6486 if (obj6) {
6487 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6488 if (!SWIG_IsOK(ecode8)) {
6489 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6490 }
6491 arg8 = static_cast< bool >(val8);
6492 }
6493 if (obj7) {
6494 ecode9 = SWIG_AsVal_int(obj7, &val9);
6495 if (!SWIG_IsOK(ecode9)) {
6496 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6497 }
6498 arg9 = static_cast< int >(val9);
6499 }
6500 if (obj8) {
6501 ecode10 = SWIG_AsVal_int(obj8, &val10);
6502 if (!SWIG_IsOK(ecode10)) {
6503 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6504 }
6505 arg10 = static_cast< int >(val10);
6506 }
6507 {
6508 if (!wxPyCheckForApp()) SWIG_fail;
6509 PyThreadState* __tstate = wxPyBeginAllowThreads();
6510 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6511 wxPyEndAllowThreads(__tstate);
6512 if (PyErr_Occurred()) SWIG_fail;
6513 }
6514 resultobj = SWIG_From_int(static_cast< int >(result));
6515 {
6516 if (temp1)
6517 delete arg1;
6518 }
6519 {
6520 if (temp2)
6521 delete arg2;
6522 }
6523 {
6524 if (arg4) delete [] arg4;
6525 }
6526 return resultobj;
6527 fail:
6528 {
6529 if (temp1)
6530 delete arg1;
6531 }
6532 {
6533 if (temp2)
6534 delete arg2;
6535 }
6536 {
6537 if (arg4) delete [] arg4;
6538 }
6539 return NULL;
6540 }
6541
6542
6543 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6544 PyObject *resultobj = 0;
6545 wxString *arg1 = 0 ;
6546 wxString const &arg2_defvalue = wxPyEmptyString ;
6547 wxString *arg2 = (wxString *) &arg2_defvalue ;
6548 int arg3 = (int) wxOK|wxCENTRE ;
6549 wxWindow *arg4 = (wxWindow *) NULL ;
6550 int arg5 = (int) -1 ;
6551 int arg6 = (int) -1 ;
6552 int result;
6553 bool temp1 = false ;
6554 bool temp2 = false ;
6555 int val3 ;
6556 int ecode3 = 0 ;
6557 void *argp4 = 0 ;
6558 int res4 = 0 ;
6559 int val5 ;
6560 int ecode5 = 0 ;
6561 int val6 ;
6562 int ecode6 = 0 ;
6563 PyObject * obj0 = 0 ;
6564 PyObject * obj1 = 0 ;
6565 PyObject * obj2 = 0 ;
6566 PyObject * obj3 = 0 ;
6567 PyObject * obj4 = 0 ;
6568 PyObject * obj5 = 0 ;
6569 char * kwnames[] = {
6570 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6571 };
6572
6573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6574 {
6575 arg1 = wxString_in_helper(obj0);
6576 if (arg1 == NULL) SWIG_fail;
6577 temp1 = true;
6578 }
6579 if (obj1) {
6580 {
6581 arg2 = wxString_in_helper(obj1);
6582 if (arg2 == NULL) SWIG_fail;
6583 temp2 = true;
6584 }
6585 }
6586 if (obj2) {
6587 ecode3 = SWIG_AsVal_int(obj2, &val3);
6588 if (!SWIG_IsOK(ecode3)) {
6589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6590 }
6591 arg3 = static_cast< int >(val3);
6592 }
6593 if (obj3) {
6594 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6595 if (!SWIG_IsOK(res4)) {
6596 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6597 }
6598 arg4 = reinterpret_cast< wxWindow * >(argp4);
6599 }
6600 if (obj4) {
6601 ecode5 = SWIG_AsVal_int(obj4, &val5);
6602 if (!SWIG_IsOK(ecode5)) {
6603 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6604 }
6605 arg5 = static_cast< int >(val5);
6606 }
6607 if (obj5) {
6608 ecode6 = SWIG_AsVal_int(obj5, &val6);
6609 if (!SWIG_IsOK(ecode6)) {
6610 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6611 }
6612 arg6 = static_cast< int >(val6);
6613 }
6614 {
6615 if (!wxPyCheckForApp()) SWIG_fail;
6616 PyThreadState* __tstate = wxPyBeginAllowThreads();
6617 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6618 wxPyEndAllowThreads(__tstate);
6619 if (PyErr_Occurred()) SWIG_fail;
6620 }
6621 resultobj = SWIG_From_int(static_cast< int >(result));
6622 {
6623 if (temp1)
6624 delete arg1;
6625 }
6626 {
6627 if (temp2)
6628 delete arg2;
6629 }
6630 return resultobj;
6631 fail:
6632 {
6633 if (temp1)
6634 delete arg1;
6635 }
6636 {
6637 if (temp2)
6638 delete arg2;
6639 }
6640 return NULL;
6641 }
6642
6643
6644 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6645 PyObject *resultobj = 0;
6646 wxString *arg1 = 0 ;
6647 wxString *arg2 = 0 ;
6648 wxString *arg3 = 0 ;
6649 long arg4 ;
6650 long arg5 = (long) 0 ;
6651 long arg6 = (long) 100 ;
6652 wxWindow *arg7 = (wxWindow *) NULL ;
6653 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6654 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6655 long result;
6656 bool temp1 = false ;
6657 bool temp2 = false ;
6658 bool temp3 = false ;
6659 long val4 ;
6660 int ecode4 = 0 ;
6661 long val5 ;
6662 int ecode5 = 0 ;
6663 long val6 ;
6664 int ecode6 = 0 ;
6665 void *argp7 = 0 ;
6666 int res7 = 0 ;
6667 wxPoint temp8 ;
6668 PyObject * obj0 = 0 ;
6669 PyObject * obj1 = 0 ;
6670 PyObject * obj2 = 0 ;
6671 PyObject * obj3 = 0 ;
6672 PyObject * obj4 = 0 ;
6673 PyObject * obj5 = 0 ;
6674 PyObject * obj6 = 0 ;
6675 PyObject * obj7 = 0 ;
6676 char * kwnames[] = {
6677 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6678 };
6679
6680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6681 {
6682 arg1 = wxString_in_helper(obj0);
6683 if (arg1 == NULL) SWIG_fail;
6684 temp1 = true;
6685 }
6686 {
6687 arg2 = wxString_in_helper(obj1);
6688 if (arg2 == NULL) SWIG_fail;
6689 temp2 = true;
6690 }
6691 {
6692 arg3 = wxString_in_helper(obj2);
6693 if (arg3 == NULL) SWIG_fail;
6694 temp3 = true;
6695 }
6696 ecode4 = SWIG_AsVal_long(obj3, &val4);
6697 if (!SWIG_IsOK(ecode4)) {
6698 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6699 }
6700 arg4 = static_cast< long >(val4);
6701 if (obj4) {
6702 ecode5 = SWIG_AsVal_long(obj4, &val5);
6703 if (!SWIG_IsOK(ecode5)) {
6704 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6705 }
6706 arg5 = static_cast< long >(val5);
6707 }
6708 if (obj5) {
6709 ecode6 = SWIG_AsVal_long(obj5, &val6);
6710 if (!SWIG_IsOK(ecode6)) {
6711 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6712 }
6713 arg6 = static_cast< long >(val6);
6714 }
6715 if (obj6) {
6716 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6717 if (!SWIG_IsOK(res7)) {
6718 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6719 }
6720 arg7 = reinterpret_cast< wxWindow * >(argp7);
6721 }
6722 if (obj7) {
6723 {
6724 arg8 = &temp8;
6725 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6726 }
6727 }
6728 {
6729 if (!wxPyCheckForApp()) SWIG_fail;
6730 PyThreadState* __tstate = wxPyBeginAllowThreads();
6731 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6732 wxPyEndAllowThreads(__tstate);
6733 if (PyErr_Occurred()) SWIG_fail;
6734 }
6735 resultobj = SWIG_From_long(static_cast< long >(result));
6736 {
6737 if (temp1)
6738 delete arg1;
6739 }
6740 {
6741 if (temp2)
6742 delete arg2;
6743 }
6744 {
6745 if (temp3)
6746 delete arg3;
6747 }
6748 return resultobj;
6749 fail:
6750 {
6751 if (temp1)
6752 delete arg1;
6753 }
6754 {
6755 if (temp2)
6756 delete arg2;
6757 }
6758 {
6759 if (temp3)
6760 delete arg3;
6761 }
6762 return NULL;
6763 }
6764
6765
6766 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6767 PyObject *resultobj = 0;
6768 bool result;
6769
6770 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6771 {
6772 if (!wxPyCheckForApp()) SWIG_fail;
6773 PyThreadState* __tstate = wxPyBeginAllowThreads();
6774 result = (bool)wxColourDisplay();
6775 wxPyEndAllowThreads(__tstate);
6776 if (PyErr_Occurred()) SWIG_fail;
6777 }
6778 {
6779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6780 }
6781 return resultobj;
6782 fail:
6783 return NULL;
6784 }
6785
6786
6787 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6788 PyObject *resultobj = 0;
6789 int result;
6790
6791 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6792 {
6793 if (!wxPyCheckForApp()) SWIG_fail;
6794 PyThreadState* __tstate = wxPyBeginAllowThreads();
6795 result = (int)wxDisplayDepth();
6796 wxPyEndAllowThreads(__tstate);
6797 if (PyErr_Occurred()) SWIG_fail;
6798 }
6799 resultobj = SWIG_From_int(static_cast< int >(result));
6800 return resultobj;
6801 fail:
6802 return NULL;
6803 }
6804
6805
6806 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6807 PyObject *resultobj = 0;
6808 int result;
6809
6810 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6811 {
6812 if (!wxPyCheckForApp()) SWIG_fail;
6813 PyThreadState* __tstate = wxPyBeginAllowThreads();
6814 result = (int)wxGetDisplayDepth();
6815 wxPyEndAllowThreads(__tstate);
6816 if (PyErr_Occurred()) SWIG_fail;
6817 }
6818 resultobj = SWIG_From_int(static_cast< int >(result));
6819 return resultobj;
6820 fail:
6821 return NULL;
6822 }
6823
6824
6825 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6826 PyObject *resultobj = 0;
6827 int *arg1 = (int *) 0 ;
6828 int *arg2 = (int *) 0 ;
6829 int temp1 ;
6830 int res1 = SWIG_TMPOBJ ;
6831 int temp2 ;
6832 int res2 = SWIG_TMPOBJ ;
6833
6834 arg1 = &temp1;
6835 arg2 = &temp2;
6836 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6837 {
6838 if (!wxPyCheckForApp()) SWIG_fail;
6839 PyThreadState* __tstate = wxPyBeginAllowThreads();
6840 wxDisplaySize(arg1,arg2);
6841 wxPyEndAllowThreads(__tstate);
6842 if (PyErr_Occurred()) SWIG_fail;
6843 }
6844 resultobj = SWIG_Py_Void();
6845 if (SWIG_IsTmpObj(res1)) {
6846 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6847 } else {
6848 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6849 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6850 }
6851 if (SWIG_IsTmpObj(res2)) {
6852 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6853 } else {
6854 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6856 }
6857 return resultobj;
6858 fail:
6859 return NULL;
6860 }
6861
6862
6863 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6864 PyObject *resultobj = 0;
6865 wxSize result;
6866
6867 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6868 {
6869 if (!wxPyCheckForApp()) SWIG_fail;
6870 PyThreadState* __tstate = wxPyBeginAllowThreads();
6871 result = wxGetDisplaySize();
6872 wxPyEndAllowThreads(__tstate);
6873 if (PyErr_Occurred()) SWIG_fail;
6874 }
6875 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6876 return resultobj;
6877 fail:
6878 return NULL;
6879 }
6880
6881
6882 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6883 PyObject *resultobj = 0;
6884 int *arg1 = (int *) 0 ;
6885 int *arg2 = (int *) 0 ;
6886 int temp1 ;
6887 int res1 = SWIG_TMPOBJ ;
6888 int temp2 ;
6889 int res2 = SWIG_TMPOBJ ;
6890
6891 arg1 = &temp1;
6892 arg2 = &temp2;
6893 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6894 {
6895 if (!wxPyCheckForApp()) SWIG_fail;
6896 PyThreadState* __tstate = wxPyBeginAllowThreads();
6897 wxDisplaySizeMM(arg1,arg2);
6898 wxPyEndAllowThreads(__tstate);
6899 if (PyErr_Occurred()) SWIG_fail;
6900 }
6901 resultobj = SWIG_Py_Void();
6902 if (SWIG_IsTmpObj(res1)) {
6903 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6904 } else {
6905 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6906 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6907 }
6908 if (SWIG_IsTmpObj(res2)) {
6909 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6910 } else {
6911 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6912 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6913 }
6914 return resultobj;
6915 fail:
6916 return NULL;
6917 }
6918
6919
6920 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6921 PyObject *resultobj = 0;
6922 wxSize result;
6923
6924 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6925 {
6926 if (!wxPyCheckForApp()) SWIG_fail;
6927 PyThreadState* __tstate = wxPyBeginAllowThreads();
6928 result = wxGetDisplaySizeMM();
6929 wxPyEndAllowThreads(__tstate);
6930 if (PyErr_Occurred()) SWIG_fail;
6931 }
6932 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6933 return resultobj;
6934 fail:
6935 return NULL;
6936 }
6937
6938
6939 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6940 PyObject *resultobj = 0;
6941 int *arg1 = (int *) 0 ;
6942 int *arg2 = (int *) 0 ;
6943 int *arg3 = (int *) 0 ;
6944 int *arg4 = (int *) 0 ;
6945 int temp1 ;
6946 int res1 = SWIG_TMPOBJ ;
6947 int temp2 ;
6948 int res2 = SWIG_TMPOBJ ;
6949 int temp3 ;
6950 int res3 = SWIG_TMPOBJ ;
6951 int temp4 ;
6952 int res4 = SWIG_TMPOBJ ;
6953
6954 arg1 = &temp1;
6955 arg2 = &temp2;
6956 arg3 = &temp3;
6957 arg4 = &temp4;
6958 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6959 {
6960 if (!wxPyCheckForApp()) SWIG_fail;
6961 PyThreadState* __tstate = wxPyBeginAllowThreads();
6962 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6963 wxPyEndAllowThreads(__tstate);
6964 if (PyErr_Occurred()) SWIG_fail;
6965 }
6966 resultobj = SWIG_Py_Void();
6967 if (SWIG_IsTmpObj(res1)) {
6968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6969 } else {
6970 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6972 }
6973 if (SWIG_IsTmpObj(res2)) {
6974 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6975 } else {
6976 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6977 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6978 }
6979 if (SWIG_IsTmpObj(res3)) {
6980 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6981 } else {
6982 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6984 }
6985 if (SWIG_IsTmpObj(res4)) {
6986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6987 } else {
6988 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6990 }
6991 return resultobj;
6992 fail:
6993 return NULL;
6994 }
6995
6996
6997 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6998 PyObject *resultobj = 0;
6999 wxRect result;
7000
7001 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
7002 {
7003 if (!wxPyCheckForApp()) SWIG_fail;
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 result = wxGetClientDisplayRect();
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj = 0;
7018 wxCursor *arg1 = 0 ;
7019 void *argp1 = 0 ;
7020 int res1 = 0 ;
7021 PyObject * obj0 = 0 ;
7022 char * kwnames[] = {
7023 (char *) "cursor", NULL
7024 };
7025
7026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7027 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7028 if (!SWIG_IsOK(res1)) {
7029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7030 }
7031 if (!argp1) {
7032 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7033 }
7034 arg1 = reinterpret_cast< wxCursor * >(argp1);
7035 {
7036 if (!wxPyCheckForApp()) SWIG_fail;
7037 PyThreadState* __tstate = wxPyBeginAllowThreads();
7038 wxSetCursor(*arg1);
7039 wxPyEndAllowThreads(__tstate);
7040 if (PyErr_Occurred()) SWIG_fail;
7041 }
7042 resultobj = SWIG_Py_Void();
7043 return resultobj;
7044 fail:
7045 return NULL;
7046 }
7047
7048
7049 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7050 PyObject *resultobj = 0;
7051 void *result = 0 ;
7052
7053 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7054 {
7055 if (!wxPyCheckForApp()) SWIG_fail;
7056 PyThreadState* __tstate = wxPyBeginAllowThreads();
7057 result = (void *)wxGetXDisplay();
7058 wxPyEndAllowThreads(__tstate);
7059 if (PyErr_Occurred()) SWIG_fail;
7060 }
7061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7062 return resultobj;
7063 fail:
7064 return NULL;
7065 }
7066
7067
7068 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7069 PyObject *resultobj = 0;
7070 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7071 void *argp1 = 0 ;
7072 int res1 = 0 ;
7073 PyObject * obj0 = 0 ;
7074 char * kwnames[] = {
7075 (char *) "cursor", NULL
7076 };
7077
7078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7079 if (obj0) {
7080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7081 if (!SWIG_IsOK(res1)) {
7082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7083 }
7084 arg1 = reinterpret_cast< wxCursor * >(argp1);
7085 }
7086 {
7087 if (!wxPyCheckForApp()) SWIG_fail;
7088 PyThreadState* __tstate = wxPyBeginAllowThreads();
7089 wxBeginBusyCursor(arg1);
7090 wxPyEndAllowThreads(__tstate);
7091 if (PyErr_Occurred()) SWIG_fail;
7092 }
7093 resultobj = SWIG_Py_Void();
7094 return resultobj;
7095 fail:
7096 return NULL;
7097 }
7098
7099
7100 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7101 PyObject *resultobj = 0;
7102 wxPoint result;
7103
7104 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7105 {
7106 if (!wxPyCheckForApp()) SWIG_fail;
7107 PyThreadState* __tstate = wxPyBeginAllowThreads();
7108 result = wxGetMousePosition();
7109 wxPyEndAllowThreads(__tstate);
7110 if (PyErr_Occurred()) SWIG_fail;
7111 }
7112 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7113 return resultobj;
7114 fail:
7115 return NULL;
7116 }
7117
7118
7119 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7120 PyObject *resultobj = 0;
7121 wxWindow *result = 0 ;
7122
7123 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7124 {
7125 if (!wxPyCheckForApp()) SWIG_fail;
7126 PyThreadState* __tstate = wxPyBeginAllowThreads();
7127 result = (wxWindow *)FindWindowAtPointer();
7128 wxPyEndAllowThreads(__tstate);
7129 if (PyErr_Occurred()) SWIG_fail;
7130 }
7131 {
7132 resultobj = wxPyMake_wxObject(result, 0);
7133 }
7134 return resultobj;
7135 fail:
7136 return NULL;
7137 }
7138
7139
7140 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7141 PyObject *resultobj = 0;
7142 wxWindow *result = 0 ;
7143
7144 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7145 {
7146 if (!wxPyCheckForApp()) SWIG_fail;
7147 PyThreadState* __tstate = wxPyBeginAllowThreads();
7148 result = (wxWindow *)wxGetActiveWindow();
7149 wxPyEndAllowThreads(__tstate);
7150 if (PyErr_Occurred()) SWIG_fail;
7151 }
7152 {
7153 resultobj = wxPyMake_wxObject(result, 0);
7154 }
7155 return resultobj;
7156 fail:
7157 return NULL;
7158 }
7159
7160
7161 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7162 PyObject *resultobj = 0;
7163 wxPoint *arg1 = 0 ;
7164 wxWindow *result = 0 ;
7165 wxPoint temp1 ;
7166 PyObject * obj0 = 0 ;
7167 char * kwnames[] = {
7168 (char *) "pt", NULL
7169 };
7170
7171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7172 {
7173 arg1 = &temp1;
7174 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7175 }
7176 {
7177 if (!wxPyCheckForApp()) SWIG_fail;
7178 PyThreadState* __tstate = wxPyBeginAllowThreads();
7179 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7180 wxPyEndAllowThreads(__tstate);
7181 if (PyErr_Occurred()) SWIG_fail;
7182 }
7183 {
7184 resultobj = wxPyMake_wxObject(result, 0);
7185 }
7186 return resultobj;
7187 fail:
7188 return NULL;
7189 }
7190
7191
7192 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7193 PyObject *resultobj = 0;
7194 wxPoint *arg1 = 0 ;
7195 wxWindow *result = 0 ;
7196 wxPoint temp1 ;
7197 PyObject * obj0 = 0 ;
7198 char * kwnames[] = {
7199 (char *) "pt", NULL
7200 };
7201
7202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7203 {
7204 arg1 = &temp1;
7205 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7206 }
7207 {
7208 if (!wxPyCheckForApp()) SWIG_fail;
7209 PyThreadState* __tstate = wxPyBeginAllowThreads();
7210 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7211 wxPyEndAllowThreads(__tstate);
7212 if (PyErr_Occurred()) SWIG_fail;
7213 }
7214 {
7215 resultobj = wxPyMake_wxObject(result, 0);
7216 }
7217 return resultobj;
7218 fail:
7219 return NULL;
7220 }
7221
7222
7223 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7224 PyObject *resultobj = 0;
7225 wxWindow *arg1 = (wxWindow *) 0 ;
7226 wxWindow *result = 0 ;
7227 void *argp1 = 0 ;
7228 int res1 = 0 ;
7229 PyObject * obj0 = 0 ;
7230 char * kwnames[] = {
7231 (char *) "win", NULL
7232 };
7233
7234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7236 if (!SWIG_IsOK(res1)) {
7237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7238 }
7239 arg1 = reinterpret_cast< wxWindow * >(argp1);
7240 {
7241 if (!wxPyCheckForApp()) SWIG_fail;
7242 PyThreadState* __tstate = wxPyBeginAllowThreads();
7243 result = (wxWindow *)wxGetTopLevelParent(arg1);
7244 wxPyEndAllowThreads(__tstate);
7245 if (PyErr_Occurred()) SWIG_fail;
7246 }
7247 {
7248 resultobj = wxPyMake_wxObject(result, 0);
7249 }
7250 return resultobj;
7251 fail:
7252 return NULL;
7253 }
7254
7255
7256 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7257 PyObject *resultobj = 0;
7258 wxString *arg1 = 0 ;
7259 bool result;
7260 bool temp1 = false ;
7261 PyObject * obj0 = 0 ;
7262 char * kwnames[] = {
7263 (char *) "url", NULL
7264 };
7265
7266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7267 {
7268 arg1 = wxString_in_helper(obj0);
7269 if (arg1 == NULL) SWIG_fail;
7270 temp1 = true;
7271 }
7272 {
7273 PyThreadState* __tstate = wxPyBeginAllowThreads();
7274 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7275 wxPyEndAllowThreads(__tstate);
7276 if (PyErr_Occurred()) SWIG_fail;
7277 }
7278 {
7279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7280 }
7281 {
7282 if (temp1)
7283 delete arg1;
7284 }
7285 return resultobj;
7286 fail:
7287 {
7288 if (temp1)
7289 delete arg1;
7290 }
7291 return NULL;
7292 }
7293
7294
7295 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7296 PyObject *resultobj = 0;
7297 wxKeyCode arg1 ;
7298 bool result;
7299 int val1 ;
7300 int ecode1 = 0 ;
7301 PyObject * obj0 = 0 ;
7302 char * kwnames[] = {
7303 (char *) "key", NULL
7304 };
7305
7306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7307 ecode1 = SWIG_AsVal_int(obj0, &val1);
7308 if (!SWIG_IsOK(ecode1)) {
7309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7310 }
7311 arg1 = static_cast< wxKeyCode >(val1);
7312 {
7313 if (!wxPyCheckForApp()) SWIG_fail;
7314 PyThreadState* __tstate = wxPyBeginAllowThreads();
7315 result = (bool)wxGetKeyState(arg1);
7316 wxPyEndAllowThreads(__tstate);
7317 if (PyErr_Occurred()) SWIG_fail;
7318 }
7319 {
7320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7321 }
7322 return resultobj;
7323 fail:
7324 return NULL;
7325 }
7326
7327
7328 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7329 PyObject *resultobj = 0;
7330 wxMouseState *result = 0 ;
7331
7332 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7333 {
7334 PyThreadState* __tstate = wxPyBeginAllowThreads();
7335 result = (wxMouseState *)new wxMouseState();
7336 wxPyEndAllowThreads(__tstate);
7337 if (PyErr_Occurred()) SWIG_fail;
7338 }
7339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7340 return resultobj;
7341 fail:
7342 return NULL;
7343 }
7344
7345
7346 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7347 PyObject *resultobj = 0;
7348 wxMouseState *arg1 = (wxMouseState *) 0 ;
7349 void *argp1 = 0 ;
7350 int res1 = 0 ;
7351 PyObject *swig_obj[1] ;
7352
7353 if (!args) SWIG_fail;
7354 swig_obj[0] = args;
7355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7356 if (!SWIG_IsOK(res1)) {
7357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7358 }
7359 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7360 {
7361 PyThreadState* __tstate = wxPyBeginAllowThreads();
7362 delete arg1;
7363
7364 wxPyEndAllowThreads(__tstate);
7365 if (PyErr_Occurred()) SWIG_fail;
7366 }
7367 resultobj = SWIG_Py_Void();
7368 return resultobj;
7369 fail:
7370 return NULL;
7371 }
7372
7373
7374 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7375 PyObject *resultobj = 0;
7376 wxMouseState *arg1 = (wxMouseState *) 0 ;
7377 int result;
7378 void *argp1 = 0 ;
7379 int res1 = 0 ;
7380 PyObject *swig_obj[1] ;
7381
7382 if (!args) SWIG_fail;
7383 swig_obj[0] = args;
7384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7385 if (!SWIG_IsOK(res1)) {
7386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7387 }
7388 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7389 {
7390 PyThreadState* __tstate = wxPyBeginAllowThreads();
7391 result = (int)(arg1)->GetX();
7392 wxPyEndAllowThreads(__tstate);
7393 if (PyErr_Occurred()) SWIG_fail;
7394 }
7395 resultobj = SWIG_From_int(static_cast< int >(result));
7396 return resultobj;
7397 fail:
7398 return NULL;
7399 }
7400
7401
7402 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7403 PyObject *resultobj = 0;
7404 wxMouseState *arg1 = (wxMouseState *) 0 ;
7405 int result;
7406 void *argp1 = 0 ;
7407 int res1 = 0 ;
7408 PyObject *swig_obj[1] ;
7409
7410 if (!args) SWIG_fail;
7411 swig_obj[0] = args;
7412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7413 if (!SWIG_IsOK(res1)) {
7414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7415 }
7416 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7417 {
7418 PyThreadState* __tstate = wxPyBeginAllowThreads();
7419 result = (int)(arg1)->GetY();
7420 wxPyEndAllowThreads(__tstate);
7421 if (PyErr_Occurred()) SWIG_fail;
7422 }
7423 resultobj = SWIG_From_int(static_cast< int >(result));
7424 return resultobj;
7425 fail:
7426 return NULL;
7427 }
7428
7429
7430 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7431 PyObject *resultobj = 0;
7432 wxMouseState *arg1 = (wxMouseState *) 0 ;
7433 bool result;
7434 void *argp1 = 0 ;
7435 int res1 = 0 ;
7436 PyObject *swig_obj[1] ;
7437
7438 if (!args) SWIG_fail;
7439 swig_obj[0] = args;
7440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7441 if (!SWIG_IsOK(res1)) {
7442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7443 }
7444 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7445 {
7446 PyThreadState* __tstate = wxPyBeginAllowThreads();
7447 result = (bool)(arg1)->LeftDown();
7448 wxPyEndAllowThreads(__tstate);
7449 if (PyErr_Occurred()) SWIG_fail;
7450 }
7451 {
7452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7453 }
7454 return resultobj;
7455 fail:
7456 return NULL;
7457 }
7458
7459
7460 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7461 PyObject *resultobj = 0;
7462 wxMouseState *arg1 = (wxMouseState *) 0 ;
7463 bool result;
7464 void *argp1 = 0 ;
7465 int res1 = 0 ;
7466 PyObject *swig_obj[1] ;
7467
7468 if (!args) SWIG_fail;
7469 swig_obj[0] = args;
7470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7471 if (!SWIG_IsOK(res1)) {
7472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7473 }
7474 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7475 {
7476 PyThreadState* __tstate = wxPyBeginAllowThreads();
7477 result = (bool)(arg1)->MiddleDown();
7478 wxPyEndAllowThreads(__tstate);
7479 if (PyErr_Occurred()) SWIG_fail;
7480 }
7481 {
7482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7483 }
7484 return resultobj;
7485 fail:
7486 return NULL;
7487 }
7488
7489
7490 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7491 PyObject *resultobj = 0;
7492 wxMouseState *arg1 = (wxMouseState *) 0 ;
7493 bool result;
7494 void *argp1 = 0 ;
7495 int res1 = 0 ;
7496 PyObject *swig_obj[1] ;
7497
7498 if (!args) SWIG_fail;
7499 swig_obj[0] = args;
7500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7501 if (!SWIG_IsOK(res1)) {
7502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7503 }
7504 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7505 {
7506 PyThreadState* __tstate = wxPyBeginAllowThreads();
7507 result = (bool)(arg1)->RightDown();
7508 wxPyEndAllowThreads(__tstate);
7509 if (PyErr_Occurred()) SWIG_fail;
7510 }
7511 {
7512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7513 }
7514 return resultobj;
7515 fail:
7516 return NULL;
7517 }
7518
7519
7520 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7521 PyObject *resultobj = 0;
7522 wxMouseState *arg1 = (wxMouseState *) 0 ;
7523 bool result;
7524 void *argp1 = 0 ;
7525 int res1 = 0 ;
7526 PyObject *swig_obj[1] ;
7527
7528 if (!args) SWIG_fail;
7529 swig_obj[0] = args;
7530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7531 if (!SWIG_IsOK(res1)) {
7532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7533 }
7534 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7535 {
7536 PyThreadState* __tstate = wxPyBeginAllowThreads();
7537 result = (bool)(arg1)->ControlDown();
7538 wxPyEndAllowThreads(__tstate);
7539 if (PyErr_Occurred()) SWIG_fail;
7540 }
7541 {
7542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7543 }
7544 return resultobj;
7545 fail:
7546 return NULL;
7547 }
7548
7549
7550 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7551 PyObject *resultobj = 0;
7552 wxMouseState *arg1 = (wxMouseState *) 0 ;
7553 bool result;
7554 void *argp1 = 0 ;
7555 int res1 = 0 ;
7556 PyObject *swig_obj[1] ;
7557
7558 if (!args) SWIG_fail;
7559 swig_obj[0] = args;
7560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7561 if (!SWIG_IsOK(res1)) {
7562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7563 }
7564 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7565 {
7566 PyThreadState* __tstate = wxPyBeginAllowThreads();
7567 result = (bool)(arg1)->ShiftDown();
7568 wxPyEndAllowThreads(__tstate);
7569 if (PyErr_Occurred()) SWIG_fail;
7570 }
7571 {
7572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7573 }
7574 return resultobj;
7575 fail:
7576 return NULL;
7577 }
7578
7579
7580 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7581 PyObject *resultobj = 0;
7582 wxMouseState *arg1 = (wxMouseState *) 0 ;
7583 bool result;
7584 void *argp1 = 0 ;
7585 int res1 = 0 ;
7586 PyObject *swig_obj[1] ;
7587
7588 if (!args) SWIG_fail;
7589 swig_obj[0] = args;
7590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7591 if (!SWIG_IsOK(res1)) {
7592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7593 }
7594 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7595 {
7596 PyThreadState* __tstate = wxPyBeginAllowThreads();
7597 result = (bool)(arg1)->AltDown();
7598 wxPyEndAllowThreads(__tstate);
7599 if (PyErr_Occurred()) SWIG_fail;
7600 }
7601 {
7602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7603 }
7604 return resultobj;
7605 fail:
7606 return NULL;
7607 }
7608
7609
7610 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7611 PyObject *resultobj = 0;
7612 wxMouseState *arg1 = (wxMouseState *) 0 ;
7613 bool result;
7614 void *argp1 = 0 ;
7615 int res1 = 0 ;
7616 PyObject *swig_obj[1] ;
7617
7618 if (!args) SWIG_fail;
7619 swig_obj[0] = args;
7620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7621 if (!SWIG_IsOK(res1)) {
7622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7623 }
7624 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7625 {
7626 PyThreadState* __tstate = wxPyBeginAllowThreads();
7627 result = (bool)(arg1)->MetaDown();
7628 wxPyEndAllowThreads(__tstate);
7629 if (PyErr_Occurred()) SWIG_fail;
7630 }
7631 {
7632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7633 }
7634 return resultobj;
7635 fail:
7636 return NULL;
7637 }
7638
7639
7640 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7641 PyObject *resultobj = 0;
7642 wxMouseState *arg1 = (wxMouseState *) 0 ;
7643 bool result;
7644 void *argp1 = 0 ;
7645 int res1 = 0 ;
7646 PyObject *swig_obj[1] ;
7647
7648 if (!args) SWIG_fail;
7649 swig_obj[0] = args;
7650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7651 if (!SWIG_IsOK(res1)) {
7652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7653 }
7654 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7655 {
7656 PyThreadState* __tstate = wxPyBeginAllowThreads();
7657 result = (bool)(arg1)->CmdDown();
7658 wxPyEndAllowThreads(__tstate);
7659 if (PyErr_Occurred()) SWIG_fail;
7660 }
7661 {
7662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7663 }
7664 return resultobj;
7665 fail:
7666 return NULL;
7667 }
7668
7669
7670 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7671 PyObject *resultobj = 0;
7672 wxMouseState *arg1 = (wxMouseState *) 0 ;
7673 int arg2 ;
7674 void *argp1 = 0 ;
7675 int res1 = 0 ;
7676 int val2 ;
7677 int ecode2 = 0 ;
7678 PyObject * obj0 = 0 ;
7679 PyObject * obj1 = 0 ;
7680 char * kwnames[] = {
7681 (char *) "self",(char *) "x", NULL
7682 };
7683
7684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7686 if (!SWIG_IsOK(res1)) {
7687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7688 }
7689 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7690 ecode2 = SWIG_AsVal_int(obj1, &val2);
7691 if (!SWIG_IsOK(ecode2)) {
7692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7693 }
7694 arg2 = static_cast< int >(val2);
7695 {
7696 PyThreadState* __tstate = wxPyBeginAllowThreads();
7697 (arg1)->SetX(arg2);
7698 wxPyEndAllowThreads(__tstate);
7699 if (PyErr_Occurred()) SWIG_fail;
7700 }
7701 resultobj = SWIG_Py_Void();
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7709 PyObject *resultobj = 0;
7710 wxMouseState *arg1 = (wxMouseState *) 0 ;
7711 int arg2 ;
7712 void *argp1 = 0 ;
7713 int res1 = 0 ;
7714 int val2 ;
7715 int ecode2 = 0 ;
7716 PyObject * obj0 = 0 ;
7717 PyObject * obj1 = 0 ;
7718 char * kwnames[] = {
7719 (char *) "self",(char *) "y", NULL
7720 };
7721
7722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7724 if (!SWIG_IsOK(res1)) {
7725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7726 }
7727 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7728 ecode2 = SWIG_AsVal_int(obj1, &val2);
7729 if (!SWIG_IsOK(ecode2)) {
7730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7731 }
7732 arg2 = static_cast< int >(val2);
7733 {
7734 PyThreadState* __tstate = wxPyBeginAllowThreads();
7735 (arg1)->SetY(arg2);
7736 wxPyEndAllowThreads(__tstate);
7737 if (PyErr_Occurred()) SWIG_fail;
7738 }
7739 resultobj = SWIG_Py_Void();
7740 return resultobj;
7741 fail:
7742 return NULL;
7743 }
7744
7745
7746 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7747 PyObject *resultobj = 0;
7748 wxMouseState *arg1 = (wxMouseState *) 0 ;
7749 bool arg2 ;
7750 void *argp1 = 0 ;
7751 int res1 = 0 ;
7752 bool val2 ;
7753 int ecode2 = 0 ;
7754 PyObject * obj0 = 0 ;
7755 PyObject * obj1 = 0 ;
7756 char * kwnames[] = {
7757 (char *) "self",(char *) "down", NULL
7758 };
7759
7760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7762 if (!SWIG_IsOK(res1)) {
7763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7764 }
7765 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7766 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7767 if (!SWIG_IsOK(ecode2)) {
7768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7769 }
7770 arg2 = static_cast< bool >(val2);
7771 {
7772 PyThreadState* __tstate = wxPyBeginAllowThreads();
7773 (arg1)->SetLeftDown(arg2);
7774 wxPyEndAllowThreads(__tstate);
7775 if (PyErr_Occurred()) SWIG_fail;
7776 }
7777 resultobj = SWIG_Py_Void();
7778 return resultobj;
7779 fail:
7780 return NULL;
7781 }
7782
7783
7784 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7785 PyObject *resultobj = 0;
7786 wxMouseState *arg1 = (wxMouseState *) 0 ;
7787 bool arg2 ;
7788 void *argp1 = 0 ;
7789 int res1 = 0 ;
7790 bool val2 ;
7791 int ecode2 = 0 ;
7792 PyObject * obj0 = 0 ;
7793 PyObject * obj1 = 0 ;
7794 char * kwnames[] = {
7795 (char *) "self",(char *) "down", NULL
7796 };
7797
7798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7800 if (!SWIG_IsOK(res1)) {
7801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7802 }
7803 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7804 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7805 if (!SWIG_IsOK(ecode2)) {
7806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7807 }
7808 arg2 = static_cast< bool >(val2);
7809 {
7810 PyThreadState* __tstate = wxPyBeginAllowThreads();
7811 (arg1)->SetMiddleDown(arg2);
7812 wxPyEndAllowThreads(__tstate);
7813 if (PyErr_Occurred()) SWIG_fail;
7814 }
7815 resultobj = SWIG_Py_Void();
7816 return resultobj;
7817 fail:
7818 return NULL;
7819 }
7820
7821
7822 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7823 PyObject *resultobj = 0;
7824 wxMouseState *arg1 = (wxMouseState *) 0 ;
7825 bool arg2 ;
7826 void *argp1 = 0 ;
7827 int res1 = 0 ;
7828 bool val2 ;
7829 int ecode2 = 0 ;
7830 PyObject * obj0 = 0 ;
7831 PyObject * obj1 = 0 ;
7832 char * kwnames[] = {
7833 (char *) "self",(char *) "down", NULL
7834 };
7835
7836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7838 if (!SWIG_IsOK(res1)) {
7839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7840 }
7841 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7842 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7843 if (!SWIG_IsOK(ecode2)) {
7844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7845 }
7846 arg2 = static_cast< bool >(val2);
7847 {
7848 PyThreadState* __tstate = wxPyBeginAllowThreads();
7849 (arg1)->SetRightDown(arg2);
7850 wxPyEndAllowThreads(__tstate);
7851 if (PyErr_Occurred()) SWIG_fail;
7852 }
7853 resultobj = SWIG_Py_Void();
7854 return resultobj;
7855 fail:
7856 return NULL;
7857 }
7858
7859
7860 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7861 PyObject *resultobj = 0;
7862 wxMouseState *arg1 = (wxMouseState *) 0 ;
7863 bool arg2 ;
7864 void *argp1 = 0 ;
7865 int res1 = 0 ;
7866 bool val2 ;
7867 int ecode2 = 0 ;
7868 PyObject * obj0 = 0 ;
7869 PyObject * obj1 = 0 ;
7870 char * kwnames[] = {
7871 (char *) "self",(char *) "down", NULL
7872 };
7873
7874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7876 if (!SWIG_IsOK(res1)) {
7877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7878 }
7879 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7880 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7881 if (!SWIG_IsOK(ecode2)) {
7882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7883 }
7884 arg2 = static_cast< bool >(val2);
7885 {
7886 PyThreadState* __tstate = wxPyBeginAllowThreads();
7887 (arg1)->SetControlDown(arg2);
7888 wxPyEndAllowThreads(__tstate);
7889 if (PyErr_Occurred()) SWIG_fail;
7890 }
7891 resultobj = SWIG_Py_Void();
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7899 PyObject *resultobj = 0;
7900 wxMouseState *arg1 = (wxMouseState *) 0 ;
7901 bool arg2 ;
7902 void *argp1 = 0 ;
7903 int res1 = 0 ;
7904 bool val2 ;
7905 int ecode2 = 0 ;
7906 PyObject * obj0 = 0 ;
7907 PyObject * obj1 = 0 ;
7908 char * kwnames[] = {
7909 (char *) "self",(char *) "down", NULL
7910 };
7911
7912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7914 if (!SWIG_IsOK(res1)) {
7915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7916 }
7917 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7918 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7919 if (!SWIG_IsOK(ecode2)) {
7920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7921 }
7922 arg2 = static_cast< bool >(val2);
7923 {
7924 PyThreadState* __tstate = wxPyBeginAllowThreads();
7925 (arg1)->SetShiftDown(arg2);
7926 wxPyEndAllowThreads(__tstate);
7927 if (PyErr_Occurred()) SWIG_fail;
7928 }
7929 resultobj = SWIG_Py_Void();
7930 return resultobj;
7931 fail:
7932 return NULL;
7933 }
7934
7935
7936 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7937 PyObject *resultobj = 0;
7938 wxMouseState *arg1 = (wxMouseState *) 0 ;
7939 bool arg2 ;
7940 void *argp1 = 0 ;
7941 int res1 = 0 ;
7942 bool val2 ;
7943 int ecode2 = 0 ;
7944 PyObject * obj0 = 0 ;
7945 PyObject * obj1 = 0 ;
7946 char * kwnames[] = {
7947 (char *) "self",(char *) "down", NULL
7948 };
7949
7950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7952 if (!SWIG_IsOK(res1)) {
7953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7954 }
7955 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7956 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7957 if (!SWIG_IsOK(ecode2)) {
7958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7959 }
7960 arg2 = static_cast< bool >(val2);
7961 {
7962 PyThreadState* __tstate = wxPyBeginAllowThreads();
7963 (arg1)->SetAltDown(arg2);
7964 wxPyEndAllowThreads(__tstate);
7965 if (PyErr_Occurred()) SWIG_fail;
7966 }
7967 resultobj = SWIG_Py_Void();
7968 return resultobj;
7969 fail:
7970 return NULL;
7971 }
7972
7973
7974 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7975 PyObject *resultobj = 0;
7976 wxMouseState *arg1 = (wxMouseState *) 0 ;
7977 bool arg2 ;
7978 void *argp1 = 0 ;
7979 int res1 = 0 ;
7980 bool val2 ;
7981 int ecode2 = 0 ;
7982 PyObject * obj0 = 0 ;
7983 PyObject * obj1 = 0 ;
7984 char * kwnames[] = {
7985 (char *) "self",(char *) "down", NULL
7986 };
7987
7988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7990 if (!SWIG_IsOK(res1)) {
7991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7992 }
7993 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7994 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7995 if (!SWIG_IsOK(ecode2)) {
7996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7997 }
7998 arg2 = static_cast< bool >(val2);
7999 {
8000 PyThreadState* __tstate = wxPyBeginAllowThreads();
8001 (arg1)->SetMetaDown(arg2);
8002 wxPyEndAllowThreads(__tstate);
8003 if (PyErr_Occurred()) SWIG_fail;
8004 }
8005 resultobj = SWIG_Py_Void();
8006 return resultobj;
8007 fail:
8008 return NULL;
8009 }
8010
8011
8012 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8013 PyObject *obj;
8014 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8015 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8016 return SWIG_Py_Void();
8017 }
8018
8019 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8020 return SWIG_Python_InitShadowInstance(args);
8021 }
8022
8023 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8024 PyObject *resultobj = 0;
8025 wxMouseState result;
8026
8027 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8028 {
8029 PyThreadState* __tstate = wxPyBeginAllowThreads();
8030 result = wxGetMouseState();
8031 wxPyEndAllowThreads(__tstate);
8032 if (PyErr_Occurred()) SWIG_fail;
8033 }
8034 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8035 return resultobj;
8036 fail:
8037 return NULL;
8038 }
8039
8040
8041 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8042 PyObject *resultobj = 0;
8043
8044 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8045 {
8046 if (!wxPyCheckForApp()) SWIG_fail;
8047 PyThreadState* __tstate = wxPyBeginAllowThreads();
8048 wxWakeUpMainThread();
8049 wxPyEndAllowThreads(__tstate);
8050 if (PyErr_Occurred()) SWIG_fail;
8051 }
8052 resultobj = SWIG_Py_Void();
8053 return resultobj;
8054 fail:
8055 return NULL;
8056 }
8057
8058
8059 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8060 PyObject *resultobj = 0;
8061
8062 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8063 {
8064 if (!wxPyCheckForApp()) SWIG_fail;
8065 PyThreadState* __tstate = wxPyBeginAllowThreads();
8066 wxMutexGuiEnter();
8067 wxPyEndAllowThreads(__tstate);
8068 if (PyErr_Occurred()) SWIG_fail;
8069 }
8070 resultobj = SWIG_Py_Void();
8071 return resultobj;
8072 fail:
8073 return NULL;
8074 }
8075
8076
8077 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8078 PyObject *resultobj = 0;
8079
8080 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8081 {
8082 if (!wxPyCheckForApp()) SWIG_fail;
8083 PyThreadState* __tstate = wxPyBeginAllowThreads();
8084 wxMutexGuiLeave();
8085 wxPyEndAllowThreads(__tstate);
8086 if (PyErr_Occurred()) SWIG_fail;
8087 }
8088 resultobj = SWIG_Py_Void();
8089 return resultobj;
8090 fail:
8091 return NULL;
8092 }
8093
8094
8095 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8096 PyObject *resultobj = 0;
8097 wxMutexGuiLocker *result = 0 ;
8098
8099 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8100 {
8101 if (!wxPyCheckForApp()) SWIG_fail;
8102 PyThreadState* __tstate = wxPyBeginAllowThreads();
8103 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8108 return resultobj;
8109 fail:
8110 return NULL;
8111 }
8112
8113
8114 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8115 PyObject *resultobj = 0;
8116 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8117 void *argp1 = 0 ;
8118 int res1 = 0 ;
8119 PyObject *swig_obj[1] ;
8120
8121 if (!args) SWIG_fail;
8122 swig_obj[0] = args;
8123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8124 if (!SWIG_IsOK(res1)) {
8125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8126 }
8127 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8128 {
8129 PyThreadState* __tstate = wxPyBeginAllowThreads();
8130 delete arg1;
8131
8132 wxPyEndAllowThreads(__tstate);
8133 if (PyErr_Occurred()) SWIG_fail;
8134 }
8135 resultobj = SWIG_Py_Void();
8136 return resultobj;
8137 fail:
8138 return NULL;
8139 }
8140
8141
8142 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8143 PyObject *obj;
8144 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8145 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8146 return SWIG_Py_Void();
8147 }
8148
8149 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8150 return SWIG_Python_InitShadowInstance(args);
8151 }
8152
8153 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8154 PyObject *resultobj = 0;
8155 bool result;
8156
8157 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8158 {
8159 PyThreadState* __tstate = wxPyBeginAllowThreads();
8160 result = (bool)wxThread_IsMain();
8161 wxPyEndAllowThreads(__tstate);
8162 if (PyErr_Occurred()) SWIG_fail;
8163 }
8164 {
8165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8166 }
8167 return resultobj;
8168 fail:
8169 return NULL;
8170 }
8171
8172
8173 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8174 PyObject *resultobj = 0;
8175 wxString *arg1 = 0 ;
8176 wxToolTip *result = 0 ;
8177 bool temp1 = false ;
8178 PyObject * obj0 = 0 ;
8179 char * kwnames[] = {
8180 (char *) "tip", NULL
8181 };
8182
8183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8184 {
8185 arg1 = wxString_in_helper(obj0);
8186 if (arg1 == NULL) SWIG_fail;
8187 temp1 = true;
8188 }
8189 {
8190 if (!wxPyCheckForApp()) SWIG_fail;
8191 PyThreadState* __tstate = wxPyBeginAllowThreads();
8192 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8193 wxPyEndAllowThreads(__tstate);
8194 if (PyErr_Occurred()) SWIG_fail;
8195 }
8196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8197 {
8198 if (temp1)
8199 delete arg1;
8200 }
8201 return resultobj;
8202 fail:
8203 {
8204 if (temp1)
8205 delete arg1;
8206 }
8207 return NULL;
8208 }
8209
8210
8211 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8212 PyObject *resultobj = 0;
8213 wxToolTip *arg1 = (wxToolTip *) 0 ;
8214 void *argp1 = 0 ;
8215 int res1 = 0 ;
8216 PyObject *swig_obj[1] ;
8217
8218 if (!args) SWIG_fail;
8219 swig_obj[0] = args;
8220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8221 if (!SWIG_IsOK(res1)) {
8222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8223 }
8224 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8225 {
8226 PyThreadState* __tstate = wxPyBeginAllowThreads();
8227 delete arg1;
8228
8229 wxPyEndAllowThreads(__tstate);
8230 if (PyErr_Occurred()) SWIG_fail;
8231 }
8232 resultobj = SWIG_Py_Void();
8233 return resultobj;
8234 fail:
8235 return NULL;
8236 }
8237
8238
8239 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8240 PyObject *resultobj = 0;
8241 wxToolTip *arg1 = (wxToolTip *) 0 ;
8242 wxString *arg2 = 0 ;
8243 void *argp1 = 0 ;
8244 int res1 = 0 ;
8245 bool temp2 = false ;
8246 PyObject * obj0 = 0 ;
8247 PyObject * obj1 = 0 ;
8248 char * kwnames[] = {
8249 (char *) "self",(char *) "tip", NULL
8250 };
8251
8252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8254 if (!SWIG_IsOK(res1)) {
8255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8256 }
8257 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8258 {
8259 arg2 = wxString_in_helper(obj1);
8260 if (arg2 == NULL) SWIG_fail;
8261 temp2 = true;
8262 }
8263 {
8264 PyThreadState* __tstate = wxPyBeginAllowThreads();
8265 (arg1)->SetTip((wxString const &)*arg2);
8266 wxPyEndAllowThreads(__tstate);
8267 if (PyErr_Occurred()) SWIG_fail;
8268 }
8269 resultobj = SWIG_Py_Void();
8270 {
8271 if (temp2)
8272 delete arg2;
8273 }
8274 return resultobj;
8275 fail:
8276 {
8277 if (temp2)
8278 delete arg2;
8279 }
8280 return NULL;
8281 }
8282
8283
8284 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8285 PyObject *resultobj = 0;
8286 wxToolTip *arg1 = (wxToolTip *) 0 ;
8287 wxString result;
8288 void *argp1 = 0 ;
8289 int res1 = 0 ;
8290 PyObject *swig_obj[1] ;
8291
8292 if (!args) SWIG_fail;
8293 swig_obj[0] = args;
8294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8295 if (!SWIG_IsOK(res1)) {
8296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8297 }
8298 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8299 {
8300 PyThreadState* __tstate = wxPyBeginAllowThreads();
8301 result = (arg1)->GetTip();
8302 wxPyEndAllowThreads(__tstate);
8303 if (PyErr_Occurred()) SWIG_fail;
8304 }
8305 {
8306 #if wxUSE_UNICODE
8307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8308 #else
8309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8310 #endif
8311 }
8312 return resultobj;
8313 fail:
8314 return NULL;
8315 }
8316
8317
8318 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8319 PyObject *resultobj = 0;
8320 wxToolTip *arg1 = (wxToolTip *) 0 ;
8321 wxWindow *result = 0 ;
8322 void *argp1 = 0 ;
8323 int res1 = 0 ;
8324 PyObject *swig_obj[1] ;
8325
8326 if (!args) SWIG_fail;
8327 swig_obj[0] = args;
8328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8329 if (!SWIG_IsOK(res1)) {
8330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8331 }
8332 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8333 {
8334 PyThreadState* __tstate = wxPyBeginAllowThreads();
8335 result = (wxWindow *)(arg1)->GetWindow();
8336 wxPyEndAllowThreads(__tstate);
8337 if (PyErr_Occurred()) SWIG_fail;
8338 }
8339 {
8340 resultobj = wxPyMake_wxObject(result, 0);
8341 }
8342 return resultobj;
8343 fail:
8344 return NULL;
8345 }
8346
8347
8348 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8349 PyObject *resultobj = 0;
8350 bool arg1 ;
8351 bool val1 ;
8352 int ecode1 = 0 ;
8353 PyObject * obj0 = 0 ;
8354 char * kwnames[] = {
8355 (char *) "flag", NULL
8356 };
8357
8358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8359 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8360 if (!SWIG_IsOK(ecode1)) {
8361 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8362 }
8363 arg1 = static_cast< bool >(val1);
8364 {
8365 PyThreadState* __tstate = wxPyBeginAllowThreads();
8366 wxToolTip::Enable(arg1);
8367 wxPyEndAllowThreads(__tstate);
8368 if (PyErr_Occurred()) SWIG_fail;
8369 }
8370 resultobj = SWIG_Py_Void();
8371 return resultobj;
8372 fail:
8373 return NULL;
8374 }
8375
8376
8377 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8378 PyObject *resultobj = 0;
8379 long arg1 ;
8380 long val1 ;
8381 int ecode1 = 0 ;
8382 PyObject * obj0 = 0 ;
8383 char * kwnames[] = {
8384 (char *) "milliseconds", NULL
8385 };
8386
8387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8388 ecode1 = SWIG_AsVal_long(obj0, &val1);
8389 if (!SWIG_IsOK(ecode1)) {
8390 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8391 }
8392 arg1 = static_cast< long >(val1);
8393 {
8394 PyThreadState* __tstate = wxPyBeginAllowThreads();
8395 wxToolTip::SetDelay(arg1);
8396 wxPyEndAllowThreads(__tstate);
8397 if (PyErr_Occurred()) SWIG_fail;
8398 }
8399 resultobj = SWIG_Py_Void();
8400 return resultobj;
8401 fail:
8402 return NULL;
8403 }
8404
8405
8406 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8407 PyObject *obj;
8408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8409 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8410 return SWIG_Py_Void();
8411 }
8412
8413 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8414 return SWIG_Python_InitShadowInstance(args);
8415 }
8416
8417 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8418 PyObject *resultobj = 0;
8419 wxWindow *arg1 = (wxWindow *) 0 ;
8420 wxSize *arg2 = 0 ;
8421 wxCaret *result = 0 ;
8422 void *argp1 = 0 ;
8423 int res1 = 0 ;
8424 wxSize temp2 ;
8425 PyObject * obj0 = 0 ;
8426 PyObject * obj1 = 0 ;
8427 char * kwnames[] = {
8428 (char *) "window",(char *) "size", NULL
8429 };
8430
8431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8433 if (!SWIG_IsOK(res1)) {
8434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8435 }
8436 arg1 = reinterpret_cast< wxWindow * >(argp1);
8437 {
8438 arg2 = &temp2;
8439 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8440 }
8441 {
8442 if (!wxPyCheckForApp()) SWIG_fail;
8443 PyThreadState* __tstate = wxPyBeginAllowThreads();
8444 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8445 wxPyEndAllowThreads(__tstate);
8446 if (PyErr_Occurred()) SWIG_fail;
8447 }
8448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8449 return resultobj;
8450 fail:
8451 return NULL;
8452 }
8453
8454
8455 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8456 PyObject *resultobj = 0;
8457 wxCaret *arg1 = (wxCaret *) 0 ;
8458 void *argp1 = 0 ;
8459 int res1 = 0 ;
8460 PyObject *swig_obj[1] ;
8461
8462 if (!args) SWIG_fail;
8463 swig_obj[0] = args;
8464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8465 if (!SWIG_IsOK(res1)) {
8466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8467 }
8468 arg1 = reinterpret_cast< wxCaret * >(argp1);
8469 {
8470 PyThreadState* __tstate = wxPyBeginAllowThreads();
8471 delete arg1;
8472
8473 wxPyEndAllowThreads(__tstate);
8474 if (PyErr_Occurred()) SWIG_fail;
8475 }
8476 resultobj = SWIG_Py_Void();
8477 return resultobj;
8478 fail:
8479 return NULL;
8480 }
8481
8482
8483 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8484 PyObject *resultobj = 0;
8485 wxCaret *arg1 = (wxCaret *) 0 ;
8486 void *argp1 = 0 ;
8487 int res1 = 0 ;
8488 PyObject *swig_obj[1] ;
8489
8490 if (!args) SWIG_fail;
8491 swig_obj[0] = args;
8492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8493 if (!SWIG_IsOK(res1)) {
8494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8495 }
8496 arg1 = reinterpret_cast< wxCaret * >(argp1);
8497 {
8498 PyThreadState* __tstate = wxPyBeginAllowThreads();
8499 wxCaret_Destroy(arg1);
8500 wxPyEndAllowThreads(__tstate);
8501 if (PyErr_Occurred()) SWIG_fail;
8502 }
8503 resultobj = SWIG_Py_Void();
8504 return resultobj;
8505 fail:
8506 return NULL;
8507 }
8508
8509
8510 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8511 PyObject *resultobj = 0;
8512 wxCaret *arg1 = (wxCaret *) 0 ;
8513 bool result;
8514 void *argp1 = 0 ;
8515 int res1 = 0 ;
8516 PyObject *swig_obj[1] ;
8517
8518 if (!args) SWIG_fail;
8519 swig_obj[0] = args;
8520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8521 if (!SWIG_IsOK(res1)) {
8522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8523 }
8524 arg1 = reinterpret_cast< wxCaret * >(argp1);
8525 {
8526 PyThreadState* __tstate = wxPyBeginAllowThreads();
8527 result = (bool)(arg1)->IsOk();
8528 wxPyEndAllowThreads(__tstate);
8529 if (PyErr_Occurred()) SWIG_fail;
8530 }
8531 {
8532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8533 }
8534 return resultobj;
8535 fail:
8536 return NULL;
8537 }
8538
8539
8540 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8541 PyObject *resultobj = 0;
8542 wxCaret *arg1 = (wxCaret *) 0 ;
8543 bool result;
8544 void *argp1 = 0 ;
8545 int res1 = 0 ;
8546 PyObject *swig_obj[1] ;
8547
8548 if (!args) SWIG_fail;
8549 swig_obj[0] = args;
8550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8551 if (!SWIG_IsOK(res1)) {
8552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8553 }
8554 arg1 = reinterpret_cast< wxCaret * >(argp1);
8555 {
8556 PyThreadState* __tstate = wxPyBeginAllowThreads();
8557 result = (bool)(arg1)->IsVisible();
8558 wxPyEndAllowThreads(__tstate);
8559 if (PyErr_Occurred()) SWIG_fail;
8560 }
8561 {
8562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8563 }
8564 return resultobj;
8565 fail:
8566 return NULL;
8567 }
8568
8569
8570 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8571 PyObject *resultobj = 0;
8572 wxCaret *arg1 = (wxCaret *) 0 ;
8573 wxPoint result;
8574 void *argp1 = 0 ;
8575 int res1 = 0 ;
8576 PyObject *swig_obj[1] ;
8577
8578 if (!args) SWIG_fail;
8579 swig_obj[0] = args;
8580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8581 if (!SWIG_IsOK(res1)) {
8582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8583 }
8584 arg1 = reinterpret_cast< wxCaret * >(argp1);
8585 {
8586 PyThreadState* __tstate = wxPyBeginAllowThreads();
8587 result = (arg1)->GetPosition();
8588 wxPyEndAllowThreads(__tstate);
8589 if (PyErr_Occurred()) SWIG_fail;
8590 }
8591 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8592 return resultobj;
8593 fail:
8594 return NULL;
8595 }
8596
8597
8598 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8599 PyObject *resultobj = 0;
8600 wxCaret *arg1 = (wxCaret *) 0 ;
8601 int *arg2 = (int *) 0 ;
8602 int *arg3 = (int *) 0 ;
8603 void *argp1 = 0 ;
8604 int res1 = 0 ;
8605 int temp2 ;
8606 int res2 = SWIG_TMPOBJ ;
8607 int temp3 ;
8608 int res3 = SWIG_TMPOBJ ;
8609 PyObject *swig_obj[1] ;
8610
8611 arg2 = &temp2;
8612 arg3 = &temp3;
8613 if (!args) SWIG_fail;
8614 swig_obj[0] = args;
8615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8616 if (!SWIG_IsOK(res1)) {
8617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8618 }
8619 arg1 = reinterpret_cast< wxCaret * >(argp1);
8620 {
8621 PyThreadState* __tstate = wxPyBeginAllowThreads();
8622 (arg1)->GetPosition(arg2,arg3);
8623 wxPyEndAllowThreads(__tstate);
8624 if (PyErr_Occurred()) SWIG_fail;
8625 }
8626 resultobj = SWIG_Py_Void();
8627 if (SWIG_IsTmpObj(res2)) {
8628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8629 } else {
8630 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8632 }
8633 if (SWIG_IsTmpObj(res3)) {
8634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8635 } else {
8636 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8638 }
8639 return resultobj;
8640 fail:
8641 return NULL;
8642 }
8643
8644
8645 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8646 PyObject *resultobj = 0;
8647 wxCaret *arg1 = (wxCaret *) 0 ;
8648 wxSize result;
8649 void *argp1 = 0 ;
8650 int res1 = 0 ;
8651 PyObject *swig_obj[1] ;
8652
8653 if (!args) SWIG_fail;
8654 swig_obj[0] = args;
8655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8656 if (!SWIG_IsOK(res1)) {
8657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8658 }
8659 arg1 = reinterpret_cast< wxCaret * >(argp1);
8660 {
8661 PyThreadState* __tstate = wxPyBeginAllowThreads();
8662 result = (arg1)->GetSize();
8663 wxPyEndAllowThreads(__tstate);
8664 if (PyErr_Occurred()) SWIG_fail;
8665 }
8666 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8667 return resultobj;
8668 fail:
8669 return NULL;
8670 }
8671
8672
8673 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8674 PyObject *resultobj = 0;
8675 wxCaret *arg1 = (wxCaret *) 0 ;
8676 int *arg2 = (int *) 0 ;
8677 int *arg3 = (int *) 0 ;
8678 void *argp1 = 0 ;
8679 int res1 = 0 ;
8680 int temp2 ;
8681 int res2 = SWIG_TMPOBJ ;
8682 int temp3 ;
8683 int res3 = SWIG_TMPOBJ ;
8684 PyObject *swig_obj[1] ;
8685
8686 arg2 = &temp2;
8687 arg3 = &temp3;
8688 if (!args) SWIG_fail;
8689 swig_obj[0] = args;
8690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8691 if (!SWIG_IsOK(res1)) {
8692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8693 }
8694 arg1 = reinterpret_cast< wxCaret * >(argp1);
8695 {
8696 PyThreadState* __tstate = wxPyBeginAllowThreads();
8697 (arg1)->GetSize(arg2,arg3);
8698 wxPyEndAllowThreads(__tstate);
8699 if (PyErr_Occurred()) SWIG_fail;
8700 }
8701 resultobj = SWIG_Py_Void();
8702 if (SWIG_IsTmpObj(res2)) {
8703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8704 } else {
8705 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8707 }
8708 if (SWIG_IsTmpObj(res3)) {
8709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8710 } else {
8711 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8712 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8713 }
8714 return resultobj;
8715 fail:
8716 return NULL;
8717 }
8718
8719
8720 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8721 PyObject *resultobj = 0;
8722 wxCaret *arg1 = (wxCaret *) 0 ;
8723 wxWindow *result = 0 ;
8724 void *argp1 = 0 ;
8725 int res1 = 0 ;
8726 PyObject *swig_obj[1] ;
8727
8728 if (!args) SWIG_fail;
8729 swig_obj[0] = args;
8730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8731 if (!SWIG_IsOK(res1)) {
8732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8733 }
8734 arg1 = reinterpret_cast< wxCaret * >(argp1);
8735 {
8736 PyThreadState* __tstate = wxPyBeginAllowThreads();
8737 result = (wxWindow *)(arg1)->GetWindow();
8738 wxPyEndAllowThreads(__tstate);
8739 if (PyErr_Occurred()) SWIG_fail;
8740 }
8741 {
8742 resultobj = wxPyMake_wxObject(result, 0);
8743 }
8744 return resultobj;
8745 fail:
8746 return NULL;
8747 }
8748
8749
8750 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8751 PyObject *resultobj = 0;
8752 wxCaret *arg1 = (wxCaret *) 0 ;
8753 int arg2 ;
8754 int arg3 ;
8755 void *argp1 = 0 ;
8756 int res1 = 0 ;
8757 int val2 ;
8758 int ecode2 = 0 ;
8759 int val3 ;
8760 int ecode3 = 0 ;
8761 PyObject * obj0 = 0 ;
8762 PyObject * obj1 = 0 ;
8763 PyObject * obj2 = 0 ;
8764 char * kwnames[] = {
8765 (char *) "self",(char *) "x",(char *) "y", NULL
8766 };
8767
8768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8770 if (!SWIG_IsOK(res1)) {
8771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8772 }
8773 arg1 = reinterpret_cast< wxCaret * >(argp1);
8774 ecode2 = SWIG_AsVal_int(obj1, &val2);
8775 if (!SWIG_IsOK(ecode2)) {
8776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8777 }
8778 arg2 = static_cast< int >(val2);
8779 ecode3 = SWIG_AsVal_int(obj2, &val3);
8780 if (!SWIG_IsOK(ecode3)) {
8781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8782 }
8783 arg3 = static_cast< int >(val3);
8784 {
8785 PyThreadState* __tstate = wxPyBeginAllowThreads();
8786 (arg1)->Move(arg2,arg3);
8787 wxPyEndAllowThreads(__tstate);
8788 if (PyErr_Occurred()) SWIG_fail;
8789 }
8790 resultobj = SWIG_Py_Void();
8791 return resultobj;
8792 fail:
8793 return NULL;
8794 }
8795
8796
8797 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8798 PyObject *resultobj = 0;
8799 wxCaret *arg1 = (wxCaret *) 0 ;
8800 wxPoint *arg2 = 0 ;
8801 void *argp1 = 0 ;
8802 int res1 = 0 ;
8803 wxPoint temp2 ;
8804 PyObject * obj0 = 0 ;
8805 PyObject * obj1 = 0 ;
8806 char * kwnames[] = {
8807 (char *) "self",(char *) "pt", NULL
8808 };
8809
8810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8812 if (!SWIG_IsOK(res1)) {
8813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8814 }
8815 arg1 = reinterpret_cast< wxCaret * >(argp1);
8816 {
8817 arg2 = &temp2;
8818 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8819 }
8820 {
8821 PyThreadState* __tstate = wxPyBeginAllowThreads();
8822 (arg1)->Move((wxPoint const &)*arg2);
8823 wxPyEndAllowThreads(__tstate);
8824 if (PyErr_Occurred()) SWIG_fail;
8825 }
8826 resultobj = SWIG_Py_Void();
8827 return resultobj;
8828 fail:
8829 return NULL;
8830 }
8831
8832
8833 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8834 PyObject *resultobj = 0;
8835 wxCaret *arg1 = (wxCaret *) 0 ;
8836 int arg2 ;
8837 int arg3 ;
8838 void *argp1 = 0 ;
8839 int res1 = 0 ;
8840 int val2 ;
8841 int ecode2 = 0 ;
8842 int val3 ;
8843 int ecode3 = 0 ;
8844 PyObject * obj0 = 0 ;
8845 PyObject * obj1 = 0 ;
8846 PyObject * obj2 = 0 ;
8847 char * kwnames[] = {
8848 (char *) "self",(char *) "width",(char *) "height", NULL
8849 };
8850
8851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8853 if (!SWIG_IsOK(res1)) {
8854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8855 }
8856 arg1 = reinterpret_cast< wxCaret * >(argp1);
8857 ecode2 = SWIG_AsVal_int(obj1, &val2);
8858 if (!SWIG_IsOK(ecode2)) {
8859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8860 }
8861 arg2 = static_cast< int >(val2);
8862 ecode3 = SWIG_AsVal_int(obj2, &val3);
8863 if (!SWIG_IsOK(ecode3)) {
8864 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8865 }
8866 arg3 = static_cast< int >(val3);
8867 {
8868 PyThreadState* __tstate = wxPyBeginAllowThreads();
8869 (arg1)->SetSize(arg2,arg3);
8870 wxPyEndAllowThreads(__tstate);
8871 if (PyErr_Occurred()) SWIG_fail;
8872 }
8873 resultobj = SWIG_Py_Void();
8874 return resultobj;
8875 fail:
8876 return NULL;
8877 }
8878
8879
8880 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8881 PyObject *resultobj = 0;
8882 wxCaret *arg1 = (wxCaret *) 0 ;
8883 wxSize *arg2 = 0 ;
8884 void *argp1 = 0 ;
8885 int res1 = 0 ;
8886 wxSize temp2 ;
8887 PyObject * obj0 = 0 ;
8888 PyObject * obj1 = 0 ;
8889 char * kwnames[] = {
8890 (char *) "self",(char *) "size", NULL
8891 };
8892
8893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8895 if (!SWIG_IsOK(res1)) {
8896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8897 }
8898 arg1 = reinterpret_cast< wxCaret * >(argp1);
8899 {
8900 arg2 = &temp2;
8901 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8902 }
8903 {
8904 PyThreadState* __tstate = wxPyBeginAllowThreads();
8905 (arg1)->SetSize((wxSize const &)*arg2);
8906 wxPyEndAllowThreads(__tstate);
8907 if (PyErr_Occurred()) SWIG_fail;
8908 }
8909 resultobj = SWIG_Py_Void();
8910 return resultobj;
8911 fail:
8912 return NULL;
8913 }
8914
8915
8916 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8917 PyObject *resultobj = 0;
8918 wxCaret *arg1 = (wxCaret *) 0 ;
8919 int arg2 = (int) true ;
8920 void *argp1 = 0 ;
8921 int res1 = 0 ;
8922 int val2 ;
8923 int ecode2 = 0 ;
8924 PyObject * obj0 = 0 ;
8925 PyObject * obj1 = 0 ;
8926 char * kwnames[] = {
8927 (char *) "self",(char *) "show", NULL
8928 };
8929
8930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8932 if (!SWIG_IsOK(res1)) {
8933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8934 }
8935 arg1 = reinterpret_cast< wxCaret * >(argp1);
8936 if (obj1) {
8937 ecode2 = SWIG_AsVal_int(obj1, &val2);
8938 if (!SWIG_IsOK(ecode2)) {
8939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8940 }
8941 arg2 = static_cast< int >(val2);
8942 }
8943 {
8944 PyThreadState* __tstate = wxPyBeginAllowThreads();
8945 (arg1)->Show(arg2);
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 resultobj = SWIG_Py_Void();
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8957 PyObject *resultobj = 0;
8958 wxCaret *arg1 = (wxCaret *) 0 ;
8959 void *argp1 = 0 ;
8960 int res1 = 0 ;
8961 PyObject *swig_obj[1] ;
8962
8963 if (!args) SWIG_fail;
8964 swig_obj[0] = args;
8965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8966 if (!SWIG_IsOK(res1)) {
8967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8968 }
8969 arg1 = reinterpret_cast< wxCaret * >(argp1);
8970 {
8971 PyThreadState* __tstate = wxPyBeginAllowThreads();
8972 (arg1)->Hide();
8973 wxPyEndAllowThreads(__tstate);
8974 if (PyErr_Occurred()) SWIG_fail;
8975 }
8976 resultobj = SWIG_Py_Void();
8977 return resultobj;
8978 fail:
8979 return NULL;
8980 }
8981
8982
8983 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8984 PyObject *resultobj = 0;
8985 int result;
8986
8987 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8988 {
8989 PyThreadState* __tstate = wxPyBeginAllowThreads();
8990 result = (int)wxCaret::GetBlinkTime();
8991 wxPyEndAllowThreads(__tstate);
8992 if (PyErr_Occurred()) SWIG_fail;
8993 }
8994 resultobj = SWIG_From_int(static_cast< int >(result));
8995 return resultobj;
8996 fail:
8997 return NULL;
8998 }
8999
9000
9001 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9002 PyObject *resultobj = 0;
9003 int arg1 ;
9004 int val1 ;
9005 int ecode1 = 0 ;
9006 PyObject * obj0 = 0 ;
9007 char * kwnames[] = {
9008 (char *) "milliseconds", NULL
9009 };
9010
9011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9012 ecode1 = SWIG_AsVal_int(obj0, &val1);
9013 if (!SWIG_IsOK(ecode1)) {
9014 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9015 }
9016 arg1 = static_cast< int >(val1);
9017 {
9018 PyThreadState* __tstate = wxPyBeginAllowThreads();
9019 wxCaret::SetBlinkTime(arg1);
9020 wxPyEndAllowThreads(__tstate);
9021 if (PyErr_Occurred()) SWIG_fail;
9022 }
9023 resultobj = SWIG_Py_Void();
9024 return resultobj;
9025 fail:
9026 return NULL;
9027 }
9028
9029
9030 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9031 PyObject *obj;
9032 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9033 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9034 return SWIG_Py_Void();
9035 }
9036
9037 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9038 return SWIG_Python_InitShadowInstance(args);
9039 }
9040
9041 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9042 PyObject *resultobj = 0;
9043 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9044 wxBusyCursor *result = 0 ;
9045 void *argp1 = 0 ;
9046 int res1 = 0 ;
9047 PyObject * obj0 = 0 ;
9048 char * kwnames[] = {
9049 (char *) "cursor", NULL
9050 };
9051
9052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9053 if (obj0) {
9054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9055 if (!SWIG_IsOK(res1)) {
9056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9057 }
9058 arg1 = reinterpret_cast< wxCursor * >(argp1);
9059 }
9060 {
9061 if (!wxPyCheckForApp()) SWIG_fail;
9062 PyThreadState* __tstate = wxPyBeginAllowThreads();
9063 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9064 wxPyEndAllowThreads(__tstate);
9065 if (PyErr_Occurred()) SWIG_fail;
9066 }
9067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9068 return resultobj;
9069 fail:
9070 return NULL;
9071 }
9072
9073
9074 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9075 PyObject *resultobj = 0;
9076 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9077 void *argp1 = 0 ;
9078 int res1 = 0 ;
9079 PyObject *swig_obj[1] ;
9080
9081 if (!args) SWIG_fail;
9082 swig_obj[0] = args;
9083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9084 if (!SWIG_IsOK(res1)) {
9085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9086 }
9087 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9088 {
9089 PyThreadState* __tstate = wxPyBeginAllowThreads();
9090 delete arg1;
9091
9092 wxPyEndAllowThreads(__tstate);
9093 if (PyErr_Occurred()) SWIG_fail;
9094 }
9095 resultobj = SWIG_Py_Void();
9096 return resultobj;
9097 fail:
9098 return NULL;
9099 }
9100
9101
9102 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9103 PyObject *obj;
9104 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9105 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9106 return SWIG_Py_Void();
9107 }
9108
9109 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9110 return SWIG_Python_InitShadowInstance(args);
9111 }
9112
9113 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9114 PyObject *resultobj = 0;
9115 wxWindow *arg1 = (wxWindow *) NULL ;
9116 wxWindowDisabler *result = 0 ;
9117 void *argp1 = 0 ;
9118 int res1 = 0 ;
9119 PyObject * obj0 = 0 ;
9120 char * kwnames[] = {
9121 (char *) "winToSkip", NULL
9122 };
9123
9124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9125 if (obj0) {
9126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9127 if (!SWIG_IsOK(res1)) {
9128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9129 }
9130 arg1 = reinterpret_cast< wxWindow * >(argp1);
9131 }
9132 {
9133 if (!wxPyCheckForApp()) SWIG_fail;
9134 PyThreadState* __tstate = wxPyBeginAllowThreads();
9135 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9136 wxPyEndAllowThreads(__tstate);
9137 if (PyErr_Occurred()) SWIG_fail;
9138 }
9139 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9140 return resultobj;
9141 fail:
9142 return NULL;
9143 }
9144
9145
9146 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9147 PyObject *resultobj = 0;
9148 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9149 void *argp1 = 0 ;
9150 int res1 = 0 ;
9151 PyObject *swig_obj[1] ;
9152
9153 if (!args) SWIG_fail;
9154 swig_obj[0] = args;
9155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9156 if (!SWIG_IsOK(res1)) {
9157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9158 }
9159 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9160 {
9161 PyThreadState* __tstate = wxPyBeginAllowThreads();
9162 delete arg1;
9163
9164 wxPyEndAllowThreads(__tstate);
9165 if (PyErr_Occurred()) SWIG_fail;
9166 }
9167 resultobj = SWIG_Py_Void();
9168 return resultobj;
9169 fail:
9170 return NULL;
9171 }
9172
9173
9174 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9175 PyObject *obj;
9176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9177 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9178 return SWIG_Py_Void();
9179 }
9180
9181 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9182 return SWIG_Python_InitShadowInstance(args);
9183 }
9184
9185 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9186 PyObject *resultobj = 0;
9187 wxString *arg1 = 0 ;
9188 wxBusyInfo *result = 0 ;
9189 bool temp1 = false ;
9190 PyObject * obj0 = 0 ;
9191 char * kwnames[] = {
9192 (char *) "message", NULL
9193 };
9194
9195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9196 {
9197 arg1 = wxString_in_helper(obj0);
9198 if (arg1 == NULL) SWIG_fail;
9199 temp1 = true;
9200 }
9201 {
9202 if (!wxPyCheckForApp()) SWIG_fail;
9203 PyThreadState* __tstate = wxPyBeginAllowThreads();
9204 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9205 wxPyEndAllowThreads(__tstate);
9206 if (PyErr_Occurred()) SWIG_fail;
9207 }
9208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9209 {
9210 if (temp1)
9211 delete arg1;
9212 }
9213 return resultobj;
9214 fail:
9215 {
9216 if (temp1)
9217 delete arg1;
9218 }
9219 return NULL;
9220 }
9221
9222
9223 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9224 PyObject *resultobj = 0;
9225 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9226 void *argp1 = 0 ;
9227 int res1 = 0 ;
9228 PyObject *swig_obj[1] ;
9229
9230 if (!args) SWIG_fail;
9231 swig_obj[0] = args;
9232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9233 if (!SWIG_IsOK(res1)) {
9234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9235 }
9236 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9237 {
9238 PyThreadState* __tstate = wxPyBeginAllowThreads();
9239 delete arg1;
9240
9241 wxPyEndAllowThreads(__tstate);
9242 if (PyErr_Occurred()) SWIG_fail;
9243 }
9244 resultobj = SWIG_Py_Void();
9245 return resultobj;
9246 fail:
9247 return NULL;
9248 }
9249
9250
9251 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9252 PyObject *obj;
9253 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9254 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9255 return SWIG_Py_Void();
9256 }
9257
9258 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9259 return SWIG_Python_InitShadowInstance(args);
9260 }
9261
9262 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9263 PyObject *resultobj = 0;
9264 wxStopWatch *result = 0 ;
9265
9266 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9267 {
9268 PyThreadState* __tstate = wxPyBeginAllowThreads();
9269 result = (wxStopWatch *)new wxStopWatch();
9270 wxPyEndAllowThreads(__tstate);
9271 if (PyErr_Occurred()) SWIG_fail;
9272 }
9273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9274 return resultobj;
9275 fail:
9276 return NULL;
9277 }
9278
9279
9280 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9281 PyObject *resultobj = 0;
9282 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9283 long arg2 = (long) 0 ;
9284 void *argp1 = 0 ;
9285 int res1 = 0 ;
9286 long val2 ;
9287 int ecode2 = 0 ;
9288 PyObject * obj0 = 0 ;
9289 PyObject * obj1 = 0 ;
9290 char * kwnames[] = {
9291 (char *) "self",(char *) "t0", NULL
9292 };
9293
9294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9296 if (!SWIG_IsOK(res1)) {
9297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9298 }
9299 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9300 if (obj1) {
9301 ecode2 = SWIG_AsVal_long(obj1, &val2);
9302 if (!SWIG_IsOK(ecode2)) {
9303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9304 }
9305 arg2 = static_cast< long >(val2);
9306 }
9307 {
9308 PyThreadState* __tstate = wxPyBeginAllowThreads();
9309 (arg1)->Start(arg2);
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_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9321 PyObject *resultobj = 0;
9322 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9323 void *argp1 = 0 ;
9324 int res1 = 0 ;
9325 PyObject *swig_obj[1] ;
9326
9327 if (!args) SWIG_fail;
9328 swig_obj[0] = args;
9329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9330 if (!SWIG_IsOK(res1)) {
9331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9332 }
9333 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9334 {
9335 PyThreadState* __tstate = wxPyBeginAllowThreads();
9336 (arg1)->Pause();
9337 wxPyEndAllowThreads(__tstate);
9338 if (PyErr_Occurred()) SWIG_fail;
9339 }
9340 resultobj = SWIG_Py_Void();
9341 return resultobj;
9342 fail:
9343 return NULL;
9344 }
9345
9346
9347 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9348 PyObject *resultobj = 0;
9349 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9350 void *argp1 = 0 ;
9351 int res1 = 0 ;
9352 PyObject *swig_obj[1] ;
9353
9354 if (!args) SWIG_fail;
9355 swig_obj[0] = args;
9356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9357 if (!SWIG_IsOK(res1)) {
9358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9359 }
9360 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9361 {
9362 PyThreadState* __tstate = wxPyBeginAllowThreads();
9363 (arg1)->Resume();
9364 wxPyEndAllowThreads(__tstate);
9365 if (PyErr_Occurred()) SWIG_fail;
9366 }
9367 resultobj = SWIG_Py_Void();
9368 return resultobj;
9369 fail:
9370 return NULL;
9371 }
9372
9373
9374 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9375 PyObject *resultobj = 0;
9376 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9377 long result;
9378 void *argp1 = 0 ;
9379 int res1 = 0 ;
9380 PyObject *swig_obj[1] ;
9381
9382 if (!args) SWIG_fail;
9383 swig_obj[0] = args;
9384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9385 if (!SWIG_IsOK(res1)) {
9386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9387 }
9388 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9389 {
9390 PyThreadState* __tstate = wxPyBeginAllowThreads();
9391 result = (long)((wxStopWatch const *)arg1)->Time();
9392 wxPyEndAllowThreads(__tstate);
9393 if (PyErr_Occurred()) SWIG_fail;
9394 }
9395 resultobj = SWIG_From_long(static_cast< long >(result));
9396 return resultobj;
9397 fail:
9398 return NULL;
9399 }
9400
9401
9402 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9403 PyObject *obj;
9404 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9405 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9406 return SWIG_Py_Void();
9407 }
9408
9409 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9410 return SWIG_Python_InitShadowInstance(args);
9411 }
9412
9413 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9414 PyObject *resultobj = 0;
9415 int arg1 = (int) 9 ;
9416 int arg2 = (int) wxID_FILE1 ;
9417 wxFileHistory *result = 0 ;
9418 int val1 ;
9419 int ecode1 = 0 ;
9420 int val2 ;
9421 int ecode2 = 0 ;
9422 PyObject * obj0 = 0 ;
9423 PyObject * obj1 = 0 ;
9424 char * kwnames[] = {
9425 (char *) "maxFiles",(char *) "idBase", NULL
9426 };
9427
9428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9429 if (obj0) {
9430 ecode1 = SWIG_AsVal_int(obj0, &val1);
9431 if (!SWIG_IsOK(ecode1)) {
9432 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9433 }
9434 arg1 = static_cast< int >(val1);
9435 }
9436 if (obj1) {
9437 ecode2 = SWIG_AsVal_int(obj1, &val2);
9438 if (!SWIG_IsOK(ecode2)) {
9439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9440 }
9441 arg2 = static_cast< int >(val2);
9442 }
9443 {
9444 PyThreadState* __tstate = wxPyBeginAllowThreads();
9445 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9446 wxPyEndAllowThreads(__tstate);
9447 if (PyErr_Occurred()) SWIG_fail;
9448 }
9449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9450 return resultobj;
9451 fail:
9452 return NULL;
9453 }
9454
9455
9456 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9457 PyObject *resultobj = 0;
9458 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9459 void *argp1 = 0 ;
9460 int res1 = 0 ;
9461 PyObject *swig_obj[1] ;
9462
9463 if (!args) SWIG_fail;
9464 swig_obj[0] = args;
9465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9466 if (!SWIG_IsOK(res1)) {
9467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9468 }
9469 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9470 {
9471 PyThreadState* __tstate = wxPyBeginAllowThreads();
9472 delete arg1;
9473
9474 wxPyEndAllowThreads(__tstate);
9475 if (PyErr_Occurred()) SWIG_fail;
9476 }
9477 resultobj = SWIG_Py_Void();
9478 return resultobj;
9479 fail:
9480 return NULL;
9481 }
9482
9483
9484 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9485 PyObject *resultobj = 0;
9486 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9487 wxString *arg2 = 0 ;
9488 void *argp1 = 0 ;
9489 int res1 = 0 ;
9490 bool temp2 = false ;
9491 PyObject * obj0 = 0 ;
9492 PyObject * obj1 = 0 ;
9493 char * kwnames[] = {
9494 (char *) "self",(char *) "file", NULL
9495 };
9496
9497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9499 if (!SWIG_IsOK(res1)) {
9500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9501 }
9502 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9503 {
9504 arg2 = wxString_in_helper(obj1);
9505 if (arg2 == NULL) SWIG_fail;
9506 temp2 = true;
9507 }
9508 {
9509 PyThreadState* __tstate = wxPyBeginAllowThreads();
9510 (arg1)->AddFileToHistory((wxString const &)*arg2);
9511 wxPyEndAllowThreads(__tstate);
9512 if (PyErr_Occurred()) SWIG_fail;
9513 }
9514 resultobj = SWIG_Py_Void();
9515 {
9516 if (temp2)
9517 delete arg2;
9518 }
9519 return resultobj;
9520 fail:
9521 {
9522 if (temp2)
9523 delete arg2;
9524 }
9525 return NULL;
9526 }
9527
9528
9529 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9530 PyObject *resultobj = 0;
9531 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9532 int arg2 ;
9533 void *argp1 = 0 ;
9534 int res1 = 0 ;
9535 int val2 ;
9536 int ecode2 = 0 ;
9537 PyObject * obj0 = 0 ;
9538 PyObject * obj1 = 0 ;
9539 char * kwnames[] = {
9540 (char *) "self",(char *) "i", NULL
9541 };
9542
9543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9545 if (!SWIG_IsOK(res1)) {
9546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9547 }
9548 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9549 ecode2 = SWIG_AsVal_int(obj1, &val2);
9550 if (!SWIG_IsOK(ecode2)) {
9551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9552 }
9553 arg2 = static_cast< int >(val2);
9554 {
9555 PyThreadState* __tstate = wxPyBeginAllowThreads();
9556 (arg1)->RemoveFileFromHistory(arg2);
9557 wxPyEndAllowThreads(__tstate);
9558 if (PyErr_Occurred()) SWIG_fail;
9559 }
9560 resultobj = SWIG_Py_Void();
9561 return resultobj;
9562 fail:
9563 return NULL;
9564 }
9565
9566
9567 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9568 PyObject *resultobj = 0;
9569 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9570 int result;
9571 void *argp1 = 0 ;
9572 int res1 = 0 ;
9573 PyObject *swig_obj[1] ;
9574
9575 if (!args) SWIG_fail;
9576 swig_obj[0] = args;
9577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9578 if (!SWIG_IsOK(res1)) {
9579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9580 }
9581 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9582 {
9583 PyThreadState* __tstate = wxPyBeginAllowThreads();
9584 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9585 wxPyEndAllowThreads(__tstate);
9586 if (PyErr_Occurred()) SWIG_fail;
9587 }
9588 resultobj = SWIG_From_int(static_cast< int >(result));
9589 return resultobj;
9590 fail:
9591 return NULL;
9592 }
9593
9594
9595 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9596 PyObject *resultobj = 0;
9597 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9598 wxMenu *arg2 = (wxMenu *) 0 ;
9599 void *argp1 = 0 ;
9600 int res1 = 0 ;
9601 void *argp2 = 0 ;
9602 int res2 = 0 ;
9603 PyObject * obj0 = 0 ;
9604 PyObject * obj1 = 0 ;
9605 char * kwnames[] = {
9606 (char *) "self",(char *) "menu", NULL
9607 };
9608
9609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9611 if (!SWIG_IsOK(res1)) {
9612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9613 }
9614 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9615 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9616 if (!SWIG_IsOK(res2)) {
9617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9618 }
9619 arg2 = reinterpret_cast< wxMenu * >(argp2);
9620 {
9621 PyThreadState* __tstate = wxPyBeginAllowThreads();
9622 (arg1)->UseMenu(arg2);
9623 wxPyEndAllowThreads(__tstate);
9624 if (PyErr_Occurred()) SWIG_fail;
9625 }
9626 resultobj = SWIG_Py_Void();
9627 return resultobj;
9628 fail:
9629 return NULL;
9630 }
9631
9632
9633 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9634 PyObject *resultobj = 0;
9635 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9636 wxMenu *arg2 = (wxMenu *) 0 ;
9637 void *argp1 = 0 ;
9638 int res1 = 0 ;
9639 void *argp2 = 0 ;
9640 int res2 = 0 ;
9641 PyObject * obj0 = 0 ;
9642 PyObject * obj1 = 0 ;
9643 char * kwnames[] = {
9644 (char *) "self",(char *) "menu", NULL
9645 };
9646
9647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9649 if (!SWIG_IsOK(res1)) {
9650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9651 }
9652 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9653 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9654 if (!SWIG_IsOK(res2)) {
9655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9656 }
9657 arg2 = reinterpret_cast< wxMenu * >(argp2);
9658 {
9659 PyThreadState* __tstate = wxPyBeginAllowThreads();
9660 (arg1)->RemoveMenu(arg2);
9661 wxPyEndAllowThreads(__tstate);
9662 if (PyErr_Occurred()) SWIG_fail;
9663 }
9664 resultobj = SWIG_Py_Void();
9665 return resultobj;
9666 fail:
9667 return NULL;
9668 }
9669
9670
9671 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9672 PyObject *resultobj = 0;
9673 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9674 wxConfigBase *arg2 = 0 ;
9675 void *argp1 = 0 ;
9676 int res1 = 0 ;
9677 void *argp2 = 0 ;
9678 int res2 = 0 ;
9679 PyObject * obj0 = 0 ;
9680 PyObject * obj1 = 0 ;
9681 char * kwnames[] = {
9682 (char *) "self",(char *) "config", NULL
9683 };
9684
9685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9687 if (!SWIG_IsOK(res1)) {
9688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9689 }
9690 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9691 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9692 if (!SWIG_IsOK(res2)) {
9693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9694 }
9695 if (!argp2) {
9696 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9697 }
9698 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9699 {
9700 PyThreadState* __tstate = wxPyBeginAllowThreads();
9701 (arg1)->Load(*arg2);
9702 wxPyEndAllowThreads(__tstate);
9703 if (PyErr_Occurred()) SWIG_fail;
9704 }
9705 resultobj = SWIG_Py_Void();
9706 return resultobj;
9707 fail:
9708 return NULL;
9709 }
9710
9711
9712 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9713 PyObject *resultobj = 0;
9714 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9715 wxConfigBase *arg2 = 0 ;
9716 void *argp1 = 0 ;
9717 int res1 = 0 ;
9718 void *argp2 = 0 ;
9719 int res2 = 0 ;
9720 PyObject * obj0 = 0 ;
9721 PyObject * obj1 = 0 ;
9722 char * kwnames[] = {
9723 (char *) "self",(char *) "config", NULL
9724 };
9725
9726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9728 if (!SWIG_IsOK(res1)) {
9729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9730 }
9731 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9732 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9733 if (!SWIG_IsOK(res2)) {
9734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9735 }
9736 if (!argp2) {
9737 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9738 }
9739 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9740 {
9741 PyThreadState* __tstate = wxPyBeginAllowThreads();
9742 (arg1)->Save(*arg2);
9743 wxPyEndAllowThreads(__tstate);
9744 if (PyErr_Occurred()) SWIG_fail;
9745 }
9746 resultobj = SWIG_Py_Void();
9747 return resultobj;
9748 fail:
9749 return NULL;
9750 }
9751
9752
9753 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9754 PyObject *resultobj = 0;
9755 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9756 void *argp1 = 0 ;
9757 int res1 = 0 ;
9758 PyObject *swig_obj[1] ;
9759
9760 if (!args) SWIG_fail;
9761 swig_obj[0] = args;
9762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9763 if (!SWIG_IsOK(res1)) {
9764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9765 }
9766 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9767 {
9768 PyThreadState* __tstate = wxPyBeginAllowThreads();
9769 (arg1)->AddFilesToMenu();
9770 wxPyEndAllowThreads(__tstate);
9771 if (PyErr_Occurred()) SWIG_fail;
9772 }
9773 resultobj = SWIG_Py_Void();
9774 return resultobj;
9775 fail:
9776 return NULL;
9777 }
9778
9779
9780 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9781 PyObject *resultobj = 0;
9782 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9783 wxMenu *arg2 = (wxMenu *) 0 ;
9784 void *argp1 = 0 ;
9785 int res1 = 0 ;
9786 void *argp2 = 0 ;
9787 int res2 = 0 ;
9788 PyObject * obj0 = 0 ;
9789 PyObject * obj1 = 0 ;
9790 char * kwnames[] = {
9791 (char *) "self",(char *) "menu", NULL
9792 };
9793
9794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9796 if (!SWIG_IsOK(res1)) {
9797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9798 }
9799 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9800 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9801 if (!SWIG_IsOK(res2)) {
9802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9803 }
9804 arg2 = reinterpret_cast< wxMenu * >(argp2);
9805 {
9806 PyThreadState* __tstate = wxPyBeginAllowThreads();
9807 (arg1)->AddFilesToMenu(arg2);
9808 wxPyEndAllowThreads(__tstate);
9809 if (PyErr_Occurred()) SWIG_fail;
9810 }
9811 resultobj = SWIG_Py_Void();
9812 return resultobj;
9813 fail:
9814 return NULL;
9815 }
9816
9817
9818 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9819 PyObject *resultobj = 0;
9820 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9821 int arg2 ;
9822 wxString result;
9823 void *argp1 = 0 ;
9824 int res1 = 0 ;
9825 int val2 ;
9826 int ecode2 = 0 ;
9827 PyObject * obj0 = 0 ;
9828 PyObject * obj1 = 0 ;
9829 char * kwnames[] = {
9830 (char *) "self",(char *) "i", NULL
9831 };
9832
9833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9835 if (!SWIG_IsOK(res1)) {
9836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9837 }
9838 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9839 ecode2 = SWIG_AsVal_int(obj1, &val2);
9840 if (!SWIG_IsOK(ecode2)) {
9841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9842 }
9843 arg2 = static_cast< int >(val2);
9844 {
9845 PyThreadState* __tstate = wxPyBeginAllowThreads();
9846 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9847 wxPyEndAllowThreads(__tstate);
9848 if (PyErr_Occurred()) SWIG_fail;
9849 }
9850 {
9851 #if wxUSE_UNICODE
9852 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9853 #else
9854 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9855 #endif
9856 }
9857 return resultobj;
9858 fail:
9859 return NULL;
9860 }
9861
9862
9863 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9864 PyObject *resultobj = 0;
9865 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9866 int result;
9867 void *argp1 = 0 ;
9868 int res1 = 0 ;
9869 PyObject *swig_obj[1] ;
9870
9871 if (!args) SWIG_fail;
9872 swig_obj[0] = args;
9873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9874 if (!SWIG_IsOK(res1)) {
9875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9876 }
9877 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9878 {
9879 PyThreadState* __tstate = wxPyBeginAllowThreads();
9880 result = (int)((wxFileHistory const *)arg1)->GetCount();
9881 wxPyEndAllowThreads(__tstate);
9882 if (PyErr_Occurred()) SWIG_fail;
9883 }
9884 resultobj = SWIG_From_int(static_cast< int >(result));
9885 return resultobj;
9886 fail:
9887 return NULL;
9888 }
9889
9890
9891 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9892 PyObject *obj;
9893 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9894 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9895 return SWIG_Py_Void();
9896 }
9897
9898 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9899 return SWIG_Python_InitShadowInstance(args);
9900 }
9901
9902 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9903 PyObject *resultobj = 0;
9904 wxString *arg1 = 0 ;
9905 wxString const &arg2_defvalue = wxPyEmptyString ;
9906 wxString *arg2 = (wxString *) &arg2_defvalue ;
9907 wxSingleInstanceChecker *result = 0 ;
9908 bool temp1 = false ;
9909 bool temp2 = false ;
9910 PyObject * obj0 = 0 ;
9911 PyObject * obj1 = 0 ;
9912 char * kwnames[] = {
9913 (char *) "name",(char *) "path", NULL
9914 };
9915
9916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9917 {
9918 arg1 = wxString_in_helper(obj0);
9919 if (arg1 == NULL) SWIG_fail;
9920 temp1 = true;
9921 }
9922 if (obj1) {
9923 {
9924 arg2 = wxString_in_helper(obj1);
9925 if (arg2 == NULL) SWIG_fail;
9926 temp2 = true;
9927 }
9928 }
9929 {
9930 PyThreadState* __tstate = wxPyBeginAllowThreads();
9931 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9932 wxPyEndAllowThreads(__tstate);
9933 if (PyErr_Occurred()) SWIG_fail;
9934 }
9935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9936 {
9937 if (temp1)
9938 delete arg1;
9939 }
9940 {
9941 if (temp2)
9942 delete arg2;
9943 }
9944 return resultobj;
9945 fail:
9946 {
9947 if (temp1)
9948 delete arg1;
9949 }
9950 {
9951 if (temp2)
9952 delete arg2;
9953 }
9954 return NULL;
9955 }
9956
9957
9958 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9959 PyObject *resultobj = 0;
9960 wxSingleInstanceChecker *result = 0 ;
9961
9962 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9963 {
9964 PyThreadState* __tstate = wxPyBeginAllowThreads();
9965 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9966 wxPyEndAllowThreads(__tstate);
9967 if (PyErr_Occurred()) SWIG_fail;
9968 }
9969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9970 return resultobj;
9971 fail:
9972 return NULL;
9973 }
9974
9975
9976 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9977 PyObject *resultobj = 0;
9978 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9979 void *argp1 = 0 ;
9980 int res1 = 0 ;
9981 PyObject *swig_obj[1] ;
9982
9983 if (!args) SWIG_fail;
9984 swig_obj[0] = args;
9985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9986 if (!SWIG_IsOK(res1)) {
9987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9988 }
9989 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9990 {
9991 PyThreadState* __tstate = wxPyBeginAllowThreads();
9992 delete arg1;
9993
9994 wxPyEndAllowThreads(__tstate);
9995 if (PyErr_Occurred()) SWIG_fail;
9996 }
9997 resultobj = SWIG_Py_Void();
9998 return resultobj;
9999 fail:
10000 return NULL;
10001 }
10002
10003
10004 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10005 PyObject *resultobj = 0;
10006 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10007 wxString *arg2 = 0 ;
10008 wxString const &arg3_defvalue = wxPyEmptyString ;
10009 wxString *arg3 = (wxString *) &arg3_defvalue ;
10010 bool result;
10011 void *argp1 = 0 ;
10012 int res1 = 0 ;
10013 bool temp2 = false ;
10014 bool temp3 = false ;
10015 PyObject * obj0 = 0 ;
10016 PyObject * obj1 = 0 ;
10017 PyObject * obj2 = 0 ;
10018 char * kwnames[] = {
10019 (char *) "self",(char *) "name",(char *) "path", NULL
10020 };
10021
10022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10024 if (!SWIG_IsOK(res1)) {
10025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10026 }
10027 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10028 {
10029 arg2 = wxString_in_helper(obj1);
10030 if (arg2 == NULL) SWIG_fail;
10031 temp2 = true;
10032 }
10033 if (obj2) {
10034 {
10035 arg3 = wxString_in_helper(obj2);
10036 if (arg3 == NULL) SWIG_fail;
10037 temp3 = true;
10038 }
10039 }
10040 {
10041 PyThreadState* __tstate = wxPyBeginAllowThreads();
10042 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10043 wxPyEndAllowThreads(__tstate);
10044 if (PyErr_Occurred()) SWIG_fail;
10045 }
10046 {
10047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10048 }
10049 {
10050 if (temp2)
10051 delete arg2;
10052 }
10053 {
10054 if (temp3)
10055 delete arg3;
10056 }
10057 return resultobj;
10058 fail:
10059 {
10060 if (temp2)
10061 delete arg2;
10062 }
10063 {
10064 if (temp3)
10065 delete arg3;
10066 }
10067 return NULL;
10068 }
10069
10070
10071 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10072 PyObject *resultobj = 0;
10073 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10074 bool result;
10075 void *argp1 = 0 ;
10076 int res1 = 0 ;
10077 PyObject *swig_obj[1] ;
10078
10079 if (!args) SWIG_fail;
10080 swig_obj[0] = args;
10081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10082 if (!SWIG_IsOK(res1)) {
10083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10084 }
10085 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10086 {
10087 PyThreadState* __tstate = wxPyBeginAllowThreads();
10088 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10089 wxPyEndAllowThreads(__tstate);
10090 if (PyErr_Occurred()) SWIG_fail;
10091 }
10092 {
10093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10094 }
10095 return resultobj;
10096 fail:
10097 return NULL;
10098 }
10099
10100
10101 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10102 PyObject *obj;
10103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10104 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10105 return SWIG_Py_Void();
10106 }
10107
10108 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10109 return SWIG_Python_InitShadowInstance(args);
10110 }
10111
10112 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10113 PyObject *resultobj = 0;
10114 wxPlatformInfo *result = 0 ;
10115
10116 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10117 {
10118 PyThreadState* __tstate = wxPyBeginAllowThreads();
10119 result = (wxPlatformInfo *)new wxPlatformInfo();
10120 wxPyEndAllowThreads(__tstate);
10121 if (PyErr_Occurred()) SWIG_fail;
10122 }
10123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10124 return resultobj;
10125 fail:
10126 return NULL;
10127 }
10128
10129
10130 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10131 PyObject *resultobj = 0;
10132 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10133 wxPlatformInfo *arg2 = 0 ;
10134 bool result;
10135 void *argp1 = 0 ;
10136 int res1 = 0 ;
10137 void *argp2 = 0 ;
10138 int res2 = 0 ;
10139 PyObject * obj0 = 0 ;
10140 PyObject * obj1 = 0 ;
10141 char * kwnames[] = {
10142 (char *) "self",(char *) "t", NULL
10143 };
10144
10145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10147 if (!SWIG_IsOK(res1)) {
10148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10149 }
10150 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10151 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10152 if (!SWIG_IsOK(res2)) {
10153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10154 }
10155 if (!argp2) {
10156 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10157 }
10158 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10159 {
10160 PyThreadState* __tstate = wxPyBeginAllowThreads();
10161 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10162 wxPyEndAllowThreads(__tstate);
10163 if (PyErr_Occurred()) SWIG_fail;
10164 }
10165 {
10166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10167 }
10168 return resultobj;
10169 fail:
10170 return NULL;
10171 }
10172
10173
10174 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10175 PyObject *resultobj = 0;
10176 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10177 wxPlatformInfo *arg2 = 0 ;
10178 bool result;
10179 void *argp1 = 0 ;
10180 int res1 = 0 ;
10181 void *argp2 = 0 ;
10182 int res2 = 0 ;
10183 PyObject * obj0 = 0 ;
10184 PyObject * obj1 = 0 ;
10185 char * kwnames[] = {
10186 (char *) "self",(char *) "t", NULL
10187 };
10188
10189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10191 if (!SWIG_IsOK(res1)) {
10192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10193 }
10194 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10195 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10196 if (!SWIG_IsOK(res2)) {
10197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10198 }
10199 if (!argp2) {
10200 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10201 }
10202 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10203 {
10204 PyThreadState* __tstate = wxPyBeginAllowThreads();
10205 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10206 wxPyEndAllowThreads(__tstate);
10207 if (PyErr_Occurred()) SWIG_fail;
10208 }
10209 {
10210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10211 }
10212 return resultobj;
10213 fail:
10214 return NULL;
10215 }
10216
10217
10218 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10219 PyObject *resultobj = 0;
10220 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10221 int result;
10222 void *argp1 = 0 ;
10223 int res1 = 0 ;
10224 PyObject *swig_obj[1] ;
10225
10226 if (!args) SWIG_fail;
10227 swig_obj[0] = args;
10228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10229 if (!SWIG_IsOK(res1)) {
10230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10231 }
10232 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10233 {
10234 PyThreadState* __tstate = wxPyBeginAllowThreads();
10235 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10236 wxPyEndAllowThreads(__tstate);
10237 if (PyErr_Occurred()) SWIG_fail;
10238 }
10239 resultobj = SWIG_From_int(static_cast< int >(result));
10240 return resultobj;
10241 fail:
10242 return NULL;
10243 }
10244
10245
10246 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10247 PyObject *resultobj = 0;
10248 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10249 int result;
10250 void *argp1 = 0 ;
10251 int res1 = 0 ;
10252 PyObject *swig_obj[1] ;
10253
10254 if (!args) SWIG_fail;
10255 swig_obj[0] = args;
10256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10257 if (!SWIG_IsOK(res1)) {
10258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10259 }
10260 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10261 {
10262 PyThreadState* __tstate = wxPyBeginAllowThreads();
10263 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10264 wxPyEndAllowThreads(__tstate);
10265 if (PyErr_Occurred()) SWIG_fail;
10266 }
10267 resultobj = SWIG_From_int(static_cast< int >(result));
10268 return resultobj;
10269 fail:
10270 return NULL;
10271 }
10272
10273
10274 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10275 PyObject *resultobj = 0;
10276 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10277 int arg2 ;
10278 int arg3 ;
10279 bool result;
10280 void *argp1 = 0 ;
10281 int res1 = 0 ;
10282 int val2 ;
10283 int ecode2 = 0 ;
10284 int val3 ;
10285 int ecode3 = 0 ;
10286 PyObject * obj0 = 0 ;
10287 PyObject * obj1 = 0 ;
10288 PyObject * obj2 = 0 ;
10289 char * kwnames[] = {
10290 (char *) "self",(char *) "major",(char *) "minor", NULL
10291 };
10292
10293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10295 if (!SWIG_IsOK(res1)) {
10296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10297 }
10298 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10299 ecode2 = SWIG_AsVal_int(obj1, &val2);
10300 if (!SWIG_IsOK(ecode2)) {
10301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10302 }
10303 arg2 = static_cast< int >(val2);
10304 ecode3 = SWIG_AsVal_int(obj2, &val3);
10305 if (!SWIG_IsOK(ecode3)) {
10306 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10307 }
10308 arg3 = static_cast< int >(val3);
10309 {
10310 PyThreadState* __tstate = wxPyBeginAllowThreads();
10311 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10312 wxPyEndAllowThreads(__tstate);
10313 if (PyErr_Occurred()) SWIG_fail;
10314 }
10315 {
10316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10317 }
10318 return resultobj;
10319 fail:
10320 return NULL;
10321 }
10322
10323
10324 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10325 PyObject *resultobj = 0;
10326 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10327 int result;
10328 void *argp1 = 0 ;
10329 int res1 = 0 ;
10330 PyObject *swig_obj[1] ;
10331
10332 if (!args) SWIG_fail;
10333 swig_obj[0] = args;
10334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10335 if (!SWIG_IsOK(res1)) {
10336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10337 }
10338 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10339 {
10340 PyThreadState* __tstate = wxPyBeginAllowThreads();
10341 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10342 wxPyEndAllowThreads(__tstate);
10343 if (PyErr_Occurred()) SWIG_fail;
10344 }
10345 resultobj = SWIG_From_int(static_cast< int >(result));
10346 return resultobj;
10347 fail:
10348 return NULL;
10349 }
10350
10351
10352 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10353 PyObject *resultobj = 0;
10354 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10355 int result;
10356 void *argp1 = 0 ;
10357 int res1 = 0 ;
10358 PyObject *swig_obj[1] ;
10359
10360 if (!args) SWIG_fail;
10361 swig_obj[0] = args;
10362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10363 if (!SWIG_IsOK(res1)) {
10364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10365 }
10366 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10367 {
10368 PyThreadState* __tstate = wxPyBeginAllowThreads();
10369 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10370 wxPyEndAllowThreads(__tstate);
10371 if (PyErr_Occurred()) SWIG_fail;
10372 }
10373 resultobj = SWIG_From_int(static_cast< int >(result));
10374 return resultobj;
10375 fail:
10376 return NULL;
10377 }
10378
10379
10380 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10381 PyObject *resultobj = 0;
10382 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10383 int arg2 ;
10384 int arg3 ;
10385 bool result;
10386 void *argp1 = 0 ;
10387 int res1 = 0 ;
10388 int val2 ;
10389 int ecode2 = 0 ;
10390 int val3 ;
10391 int ecode3 = 0 ;
10392 PyObject * obj0 = 0 ;
10393 PyObject * obj1 = 0 ;
10394 PyObject * obj2 = 0 ;
10395 char * kwnames[] = {
10396 (char *) "self",(char *) "major",(char *) "minor", NULL
10397 };
10398
10399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10401 if (!SWIG_IsOK(res1)) {
10402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10403 }
10404 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10405 ecode2 = SWIG_AsVal_int(obj1, &val2);
10406 if (!SWIG_IsOK(ecode2)) {
10407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10408 }
10409 arg2 = static_cast< int >(val2);
10410 ecode3 = SWIG_AsVal_int(obj2, &val3);
10411 if (!SWIG_IsOK(ecode3)) {
10412 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10413 }
10414 arg3 = static_cast< int >(val3);
10415 {
10416 PyThreadState* __tstate = wxPyBeginAllowThreads();
10417 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10418 wxPyEndAllowThreads(__tstate);
10419 if (PyErr_Occurred()) SWIG_fail;
10420 }
10421 {
10422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10423 }
10424 return resultobj;
10425 fail:
10426 return NULL;
10427 }
10428
10429
10430 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10431 PyObject *resultobj = 0;
10432 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10433 bool result;
10434 void *argp1 = 0 ;
10435 int res1 = 0 ;
10436 PyObject *swig_obj[1] ;
10437
10438 if (!args) SWIG_fail;
10439 swig_obj[0] = args;
10440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10441 if (!SWIG_IsOK(res1)) {
10442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10443 }
10444 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10445 {
10446 PyThreadState* __tstate = wxPyBeginAllowThreads();
10447 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10448 wxPyEndAllowThreads(__tstate);
10449 if (PyErr_Occurred()) SWIG_fail;
10450 }
10451 {
10452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10453 }
10454 return resultobj;
10455 fail:
10456 return NULL;
10457 }
10458
10459
10460 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10461 PyObject *resultobj = 0;
10462 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10463 wxOperatingSystemId result;
10464 void *argp1 = 0 ;
10465 int res1 = 0 ;
10466 PyObject *swig_obj[1] ;
10467
10468 if (!args) SWIG_fail;
10469 swig_obj[0] = args;
10470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10471 if (!SWIG_IsOK(res1)) {
10472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10473 }
10474 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10475 {
10476 PyThreadState* __tstate = wxPyBeginAllowThreads();
10477 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10478 wxPyEndAllowThreads(__tstate);
10479 if (PyErr_Occurred()) SWIG_fail;
10480 }
10481 resultobj = SWIG_From_int(static_cast< int >(result));
10482 return resultobj;
10483 fail:
10484 return NULL;
10485 }
10486
10487
10488 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10489 PyObject *resultobj = 0;
10490 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10491 wxPortId result;
10492 void *argp1 = 0 ;
10493 int res1 = 0 ;
10494 PyObject *swig_obj[1] ;
10495
10496 if (!args) SWIG_fail;
10497 swig_obj[0] = args;
10498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10499 if (!SWIG_IsOK(res1)) {
10500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10501 }
10502 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10503 {
10504 PyThreadState* __tstate = wxPyBeginAllowThreads();
10505 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10506 wxPyEndAllowThreads(__tstate);
10507 if (PyErr_Occurred()) SWIG_fail;
10508 }
10509 resultobj = SWIG_From_int(static_cast< int >(result));
10510 return resultobj;
10511 fail:
10512 return NULL;
10513 }
10514
10515
10516 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10517 PyObject *resultobj = 0;
10518 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10519 wxArchitecture result;
10520 void *argp1 = 0 ;
10521 int res1 = 0 ;
10522 PyObject *swig_obj[1] ;
10523
10524 if (!args) SWIG_fail;
10525 swig_obj[0] = args;
10526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10527 if (!SWIG_IsOK(res1)) {
10528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10529 }
10530 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10531 {
10532 PyThreadState* __tstate = wxPyBeginAllowThreads();
10533 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10534 wxPyEndAllowThreads(__tstate);
10535 if (PyErr_Occurred()) SWIG_fail;
10536 }
10537 resultobj = SWIG_From_int(static_cast< int >(result));
10538 return resultobj;
10539 fail:
10540 return NULL;
10541 }
10542
10543
10544 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10545 PyObject *resultobj = 0;
10546 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10547 wxEndianness result;
10548 void *argp1 = 0 ;
10549 int res1 = 0 ;
10550 PyObject *swig_obj[1] ;
10551
10552 if (!args) SWIG_fail;
10553 swig_obj[0] = args;
10554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10555 if (!SWIG_IsOK(res1)) {
10556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10557 }
10558 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10559 {
10560 PyThreadState* __tstate = wxPyBeginAllowThreads();
10561 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10562 wxPyEndAllowThreads(__tstate);
10563 if (PyErr_Occurred()) SWIG_fail;
10564 }
10565 resultobj = SWIG_From_int(static_cast< int >(result));
10566 return resultobj;
10567 fail:
10568 return NULL;
10569 }
10570
10571
10572 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10573 PyObject *resultobj = 0;
10574 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10575 wxString result;
10576 void *argp1 = 0 ;
10577 int res1 = 0 ;
10578 PyObject *swig_obj[1] ;
10579
10580 if (!args) SWIG_fail;
10581 swig_obj[0] = args;
10582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10583 if (!SWIG_IsOK(res1)) {
10584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10585 }
10586 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10587 {
10588 PyThreadState* __tstate = wxPyBeginAllowThreads();
10589 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10590 wxPyEndAllowThreads(__tstate);
10591 if (PyErr_Occurred()) SWIG_fail;
10592 }
10593 {
10594 #if wxUSE_UNICODE
10595 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10596 #else
10597 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10598 #endif
10599 }
10600 return resultobj;
10601 fail:
10602 return NULL;
10603 }
10604
10605
10606 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10607 PyObject *resultobj = 0;
10608 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10609 wxString result;
10610 void *argp1 = 0 ;
10611 int res1 = 0 ;
10612 PyObject *swig_obj[1] ;
10613
10614 if (!args) SWIG_fail;
10615 swig_obj[0] = args;
10616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10617 if (!SWIG_IsOK(res1)) {
10618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10619 }
10620 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10621 {
10622 PyThreadState* __tstate = wxPyBeginAllowThreads();
10623 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10624 wxPyEndAllowThreads(__tstate);
10625 if (PyErr_Occurred()) SWIG_fail;
10626 }
10627 {
10628 #if wxUSE_UNICODE
10629 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10630 #else
10631 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10632 #endif
10633 }
10634 return resultobj;
10635 fail:
10636 return NULL;
10637 }
10638
10639
10640 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10641 PyObject *resultobj = 0;
10642 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10643 wxString result;
10644 void *argp1 = 0 ;
10645 int res1 = 0 ;
10646 PyObject *swig_obj[1] ;
10647
10648 if (!args) SWIG_fail;
10649 swig_obj[0] = args;
10650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10651 if (!SWIG_IsOK(res1)) {
10652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10653 }
10654 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10655 {
10656 PyThreadState* __tstate = wxPyBeginAllowThreads();
10657 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10658 wxPyEndAllowThreads(__tstate);
10659 if (PyErr_Occurred()) SWIG_fail;
10660 }
10661 {
10662 #if wxUSE_UNICODE
10663 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10664 #else
10665 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10666 #endif
10667 }
10668 return resultobj;
10669 fail:
10670 return NULL;
10671 }
10672
10673
10674 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10675 PyObject *resultobj = 0;
10676 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10677 wxString result;
10678 void *argp1 = 0 ;
10679 int res1 = 0 ;
10680 PyObject *swig_obj[1] ;
10681
10682 if (!args) SWIG_fail;
10683 swig_obj[0] = args;
10684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10685 if (!SWIG_IsOK(res1)) {
10686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10687 }
10688 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10689 {
10690 PyThreadState* __tstate = wxPyBeginAllowThreads();
10691 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10692 wxPyEndAllowThreads(__tstate);
10693 if (PyErr_Occurred()) SWIG_fail;
10694 }
10695 {
10696 #if wxUSE_UNICODE
10697 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10698 #else
10699 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10700 #endif
10701 }
10702 return resultobj;
10703 fail:
10704 return NULL;
10705 }
10706
10707
10708 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10709 PyObject *resultobj = 0;
10710 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10711 wxString result;
10712 void *argp1 = 0 ;
10713 int res1 = 0 ;
10714 PyObject *swig_obj[1] ;
10715
10716 if (!args) SWIG_fail;
10717 swig_obj[0] = args;
10718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10719 if (!SWIG_IsOK(res1)) {
10720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10721 }
10722 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10723 {
10724 PyThreadState* __tstate = wxPyBeginAllowThreads();
10725 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10726 wxPyEndAllowThreads(__tstate);
10727 if (PyErr_Occurred()) SWIG_fail;
10728 }
10729 {
10730 #if wxUSE_UNICODE
10731 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10732 #else
10733 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10734 #endif
10735 }
10736 return resultobj;
10737 fail:
10738 return NULL;
10739 }
10740
10741
10742 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10743 PyObject *resultobj = 0;
10744 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10745 wxString result;
10746 void *argp1 = 0 ;
10747 int res1 = 0 ;
10748 PyObject *swig_obj[1] ;
10749
10750 if (!args) SWIG_fail;
10751 swig_obj[0] = args;
10752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10753 if (!SWIG_IsOK(res1)) {
10754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10755 }
10756 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10757 {
10758 PyThreadState* __tstate = wxPyBeginAllowThreads();
10759 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10760 wxPyEndAllowThreads(__tstate);
10761 if (PyErr_Occurred()) SWIG_fail;
10762 }
10763 {
10764 #if wxUSE_UNICODE
10765 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10766 #else
10767 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10768 #endif
10769 }
10770 return resultobj;
10771 fail:
10772 return NULL;
10773 }
10774
10775
10776 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10777 PyObject *resultobj = 0;
10778 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10779 int arg2 ;
10780 int arg3 ;
10781 void *argp1 = 0 ;
10782 int res1 = 0 ;
10783 int val2 ;
10784 int ecode2 = 0 ;
10785 int val3 ;
10786 int ecode3 = 0 ;
10787 PyObject * obj0 = 0 ;
10788 PyObject * obj1 = 0 ;
10789 PyObject * obj2 = 0 ;
10790 char * kwnames[] = {
10791 (char *) "self",(char *) "major",(char *) "minor", NULL
10792 };
10793
10794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10796 if (!SWIG_IsOK(res1)) {
10797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10798 }
10799 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10800 ecode2 = SWIG_AsVal_int(obj1, &val2);
10801 if (!SWIG_IsOK(ecode2)) {
10802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10803 }
10804 arg2 = static_cast< int >(val2);
10805 ecode3 = SWIG_AsVal_int(obj2, &val3);
10806 if (!SWIG_IsOK(ecode3)) {
10807 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10808 }
10809 arg3 = static_cast< int >(val3);
10810 {
10811 PyThreadState* __tstate = wxPyBeginAllowThreads();
10812 (arg1)->SetOSVersion(arg2,arg3);
10813 wxPyEndAllowThreads(__tstate);
10814 if (PyErr_Occurred()) SWIG_fail;
10815 }
10816 resultobj = SWIG_Py_Void();
10817 return resultobj;
10818 fail:
10819 return NULL;
10820 }
10821
10822
10823 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10824 PyObject *resultobj = 0;
10825 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10826 int arg2 ;
10827 int arg3 ;
10828 void *argp1 = 0 ;
10829 int res1 = 0 ;
10830 int val2 ;
10831 int ecode2 = 0 ;
10832 int val3 ;
10833 int ecode3 = 0 ;
10834 PyObject * obj0 = 0 ;
10835 PyObject * obj1 = 0 ;
10836 PyObject * obj2 = 0 ;
10837 char * kwnames[] = {
10838 (char *) "self",(char *) "major",(char *) "minor", NULL
10839 };
10840
10841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10843 if (!SWIG_IsOK(res1)) {
10844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10845 }
10846 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10847 ecode2 = SWIG_AsVal_int(obj1, &val2);
10848 if (!SWIG_IsOK(ecode2)) {
10849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10850 }
10851 arg2 = static_cast< int >(val2);
10852 ecode3 = SWIG_AsVal_int(obj2, &val3);
10853 if (!SWIG_IsOK(ecode3)) {
10854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10855 }
10856 arg3 = static_cast< int >(val3);
10857 {
10858 PyThreadState* __tstate = wxPyBeginAllowThreads();
10859 (arg1)->SetToolkitVersion(arg2,arg3);
10860 wxPyEndAllowThreads(__tstate);
10861 if (PyErr_Occurred()) SWIG_fail;
10862 }
10863 resultobj = SWIG_Py_Void();
10864 return resultobj;
10865 fail:
10866 return NULL;
10867 }
10868
10869
10870 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10871 PyObject *resultobj = 0;
10872 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10873 wxOperatingSystemId arg2 ;
10874 void *argp1 = 0 ;
10875 int res1 = 0 ;
10876 int val2 ;
10877 int ecode2 = 0 ;
10878 PyObject * obj0 = 0 ;
10879 PyObject * obj1 = 0 ;
10880 char * kwnames[] = {
10881 (char *) "self",(char *) "n", NULL
10882 };
10883
10884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10886 if (!SWIG_IsOK(res1)) {
10887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10888 }
10889 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10890 ecode2 = SWIG_AsVal_int(obj1, &val2);
10891 if (!SWIG_IsOK(ecode2)) {
10892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10893 }
10894 arg2 = static_cast< wxOperatingSystemId >(val2);
10895 {
10896 PyThreadState* __tstate = wxPyBeginAllowThreads();
10897 (arg1)->SetOperatingSystemId(arg2);
10898 wxPyEndAllowThreads(__tstate);
10899 if (PyErr_Occurred()) SWIG_fail;
10900 }
10901 resultobj = SWIG_Py_Void();
10902 return resultobj;
10903 fail:
10904 return NULL;
10905 }
10906
10907
10908 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10909 PyObject *resultobj = 0;
10910 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10911 wxPortId arg2 ;
10912 void *argp1 = 0 ;
10913 int res1 = 0 ;
10914 int val2 ;
10915 int ecode2 = 0 ;
10916 PyObject * obj0 = 0 ;
10917 PyObject * obj1 = 0 ;
10918 char * kwnames[] = {
10919 (char *) "self",(char *) "n", NULL
10920 };
10921
10922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10924 if (!SWIG_IsOK(res1)) {
10925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10926 }
10927 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10928 ecode2 = SWIG_AsVal_int(obj1, &val2);
10929 if (!SWIG_IsOK(ecode2)) {
10930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10931 }
10932 arg2 = static_cast< wxPortId >(val2);
10933 {
10934 PyThreadState* __tstate = wxPyBeginAllowThreads();
10935 (arg1)->SetPortId(arg2);
10936 wxPyEndAllowThreads(__tstate);
10937 if (PyErr_Occurred()) SWIG_fail;
10938 }
10939 resultobj = SWIG_Py_Void();
10940 return resultobj;
10941 fail:
10942 return NULL;
10943 }
10944
10945
10946 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10947 PyObject *resultobj = 0;
10948 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10949 wxArchitecture arg2 ;
10950 void *argp1 = 0 ;
10951 int res1 = 0 ;
10952 int val2 ;
10953 int ecode2 = 0 ;
10954 PyObject * obj0 = 0 ;
10955 PyObject * obj1 = 0 ;
10956 char * kwnames[] = {
10957 (char *) "self",(char *) "n", NULL
10958 };
10959
10960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10962 if (!SWIG_IsOK(res1)) {
10963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10964 }
10965 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10966 ecode2 = SWIG_AsVal_int(obj1, &val2);
10967 if (!SWIG_IsOK(ecode2)) {
10968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
10969 }
10970 arg2 = static_cast< wxArchitecture >(val2);
10971 {
10972 PyThreadState* __tstate = wxPyBeginAllowThreads();
10973 (arg1)->SetArchitecture(arg2);
10974 wxPyEndAllowThreads(__tstate);
10975 if (PyErr_Occurred()) SWIG_fail;
10976 }
10977 resultobj = SWIG_Py_Void();
10978 return resultobj;
10979 fail:
10980 return NULL;
10981 }
10982
10983
10984 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10985 PyObject *resultobj = 0;
10986 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10987 wxEndianness arg2 ;
10988 void *argp1 = 0 ;
10989 int res1 = 0 ;
10990 int val2 ;
10991 int ecode2 = 0 ;
10992 PyObject * obj0 = 0 ;
10993 PyObject * obj1 = 0 ;
10994 char * kwnames[] = {
10995 (char *) "self",(char *) "n", NULL
10996 };
10997
10998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
10999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11000 if (!SWIG_IsOK(res1)) {
11001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11002 }
11003 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11004 ecode2 = SWIG_AsVal_int(obj1, &val2);
11005 if (!SWIG_IsOK(ecode2)) {
11006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11007 }
11008 arg2 = static_cast< wxEndianness >(val2);
11009 {
11010 PyThreadState* __tstate = wxPyBeginAllowThreads();
11011 (arg1)->SetEndianness(arg2);
11012 wxPyEndAllowThreads(__tstate);
11013 if (PyErr_Occurred()) SWIG_fail;
11014 }
11015 resultobj = SWIG_Py_Void();
11016 return resultobj;
11017 fail:
11018 return NULL;
11019 }
11020
11021
11022 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11023 PyObject *resultobj = 0;
11024 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11025 bool result;
11026 void *argp1 = 0 ;
11027 int res1 = 0 ;
11028 PyObject *swig_obj[1] ;
11029
11030 if (!args) SWIG_fail;
11031 swig_obj[0] = args;
11032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11033 if (!SWIG_IsOK(res1)) {
11034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11035 }
11036 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11037 {
11038 PyThreadState* __tstate = wxPyBeginAllowThreads();
11039 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11040 wxPyEndAllowThreads(__tstate);
11041 if (PyErr_Occurred()) SWIG_fail;
11042 }
11043 {
11044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11045 }
11046 return resultobj;
11047 fail:
11048 return NULL;
11049 }
11050
11051
11052 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11053 PyObject *obj;
11054 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11055 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11056 return SWIG_Py_Void();
11057 }
11058
11059 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11060 return SWIG_Python_InitShadowInstance(args);
11061 }
11062
11063 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11064 PyObject *resultobj = 0;
11065 wxWindow *arg1 = (wxWindow *) 0 ;
11066 wxDC *arg2 = 0 ;
11067 bool result;
11068 void *argp1 = 0 ;
11069 int res1 = 0 ;
11070 void *argp2 = 0 ;
11071 int res2 = 0 ;
11072 PyObject * obj0 = 0 ;
11073 PyObject * obj1 = 0 ;
11074 char * kwnames[] = {
11075 (char *) "window",(char *) "dc", NULL
11076 };
11077
11078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11080 if (!SWIG_IsOK(res1)) {
11081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11082 }
11083 arg1 = reinterpret_cast< wxWindow * >(argp1);
11084 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11085 if (!SWIG_IsOK(res2)) {
11086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11087 }
11088 if (!argp2) {
11089 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11090 }
11091 arg2 = reinterpret_cast< wxDC * >(argp2);
11092 {
11093 PyThreadState* __tstate = wxPyBeginAllowThreads();
11094 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11095 wxPyEndAllowThreads(__tstate);
11096 if (PyErr_Occurred()) SWIG_fail;
11097 }
11098 {
11099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11100 }
11101 return resultobj;
11102 fail:
11103 return NULL;
11104 }
11105
11106
11107 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11108 PyObject *resultobj = 0;
11109 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11110 void *argp1 = 0 ;
11111 int res1 = 0 ;
11112 PyObject *swig_obj[1] ;
11113
11114 if (!args) SWIG_fail;
11115 swig_obj[0] = args;
11116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11117 if (!SWIG_IsOK(res1)) {
11118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11119 }
11120 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11121 {
11122 PyThreadState* __tstate = wxPyBeginAllowThreads();
11123 delete arg1;
11124
11125 wxPyEndAllowThreads(__tstate);
11126 if (PyErr_Occurred()) SWIG_fail;
11127 }
11128 resultobj = SWIG_Py_Void();
11129 return resultobj;
11130 fail:
11131 return NULL;
11132 }
11133
11134
11135 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11136 PyObject *resultobj = 0;
11137 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11138 wxString result;
11139 void *argp1 = 0 ;
11140 int res1 = 0 ;
11141 PyObject *swig_obj[1] ;
11142
11143 if (!args) SWIG_fail;
11144 swig_obj[0] = args;
11145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11146 if (!SWIG_IsOK(res1)) {
11147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11148 }
11149 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11150 {
11151 PyThreadState* __tstate = wxPyBeginAllowThreads();
11152 result = (arg1)->GetTip();
11153 wxPyEndAllowThreads(__tstate);
11154 if (PyErr_Occurred()) SWIG_fail;
11155 }
11156 {
11157 #if wxUSE_UNICODE
11158 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11159 #else
11160 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11161 #endif
11162 }
11163 return resultobj;
11164 fail:
11165 return NULL;
11166 }
11167
11168
11169 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11170 PyObject *resultobj = 0;
11171 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11172 size_t result;
11173 void *argp1 = 0 ;
11174 int res1 = 0 ;
11175 PyObject *swig_obj[1] ;
11176
11177 if (!args) SWIG_fail;
11178 swig_obj[0] = args;
11179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11180 if (!SWIG_IsOK(res1)) {
11181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11182 }
11183 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11184 {
11185 PyThreadState* __tstate = wxPyBeginAllowThreads();
11186 result = (size_t)(arg1)->GetCurrentTip();
11187 wxPyEndAllowThreads(__tstate);
11188 if (PyErr_Occurred()) SWIG_fail;
11189 }
11190 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11191 return resultobj;
11192 fail:
11193 return NULL;
11194 }
11195
11196
11197 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11198 PyObject *resultobj = 0;
11199 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11200 wxString *arg2 = 0 ;
11201 wxString result;
11202 void *argp1 = 0 ;
11203 int res1 = 0 ;
11204 bool temp2 = false ;
11205 PyObject * obj0 = 0 ;
11206 PyObject * obj1 = 0 ;
11207 char * kwnames[] = {
11208 (char *) "self",(char *) "tip", NULL
11209 };
11210
11211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11213 if (!SWIG_IsOK(res1)) {
11214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11215 }
11216 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11217 {
11218 arg2 = wxString_in_helper(obj1);
11219 if (arg2 == NULL) SWIG_fail;
11220 temp2 = true;
11221 }
11222 {
11223 PyThreadState* __tstate = wxPyBeginAllowThreads();
11224 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11225 wxPyEndAllowThreads(__tstate);
11226 if (PyErr_Occurred()) SWIG_fail;
11227 }
11228 {
11229 #if wxUSE_UNICODE
11230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11231 #else
11232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11233 #endif
11234 }
11235 {
11236 if (temp2)
11237 delete arg2;
11238 }
11239 return resultobj;
11240 fail:
11241 {
11242 if (temp2)
11243 delete arg2;
11244 }
11245 return NULL;
11246 }
11247
11248
11249 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11250 PyObject *obj;
11251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11252 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11253 return SWIG_Py_Void();
11254 }
11255
11256 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11257 PyObject *resultobj = 0;
11258 size_t arg1 ;
11259 wxPyTipProvider *result = 0 ;
11260 size_t val1 ;
11261 int ecode1 = 0 ;
11262 PyObject * obj0 = 0 ;
11263 char * kwnames[] = {
11264 (char *) "currentTip", NULL
11265 };
11266
11267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11268 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11269 if (!SWIG_IsOK(ecode1)) {
11270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11271 }
11272 arg1 = static_cast< size_t >(val1);
11273 {
11274 PyThreadState* __tstate = wxPyBeginAllowThreads();
11275 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11276 wxPyEndAllowThreads(__tstate);
11277 if (PyErr_Occurred()) SWIG_fail;
11278 }
11279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11280 return resultobj;
11281 fail:
11282 return NULL;
11283 }
11284
11285
11286 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11287 PyObject *resultobj = 0;
11288 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11289 PyObject *arg2 = (PyObject *) 0 ;
11290 PyObject *arg3 = (PyObject *) 0 ;
11291 void *argp1 = 0 ;
11292 int res1 = 0 ;
11293 PyObject * obj0 = 0 ;
11294 PyObject * obj1 = 0 ;
11295 PyObject * obj2 = 0 ;
11296 char * kwnames[] = {
11297 (char *) "self",(char *) "self",(char *) "_class", NULL
11298 };
11299
11300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11302 if (!SWIG_IsOK(res1)) {
11303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11304 }
11305 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11306 arg2 = obj1;
11307 arg3 = obj2;
11308 {
11309 PyThreadState* __tstate = wxPyBeginAllowThreads();
11310 (arg1)->_setCallbackInfo(arg2,arg3);
11311 wxPyEndAllowThreads(__tstate);
11312 if (PyErr_Occurred()) SWIG_fail;
11313 }
11314 resultobj = SWIG_Py_Void();
11315 return resultobj;
11316 fail:
11317 return NULL;
11318 }
11319
11320
11321 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11322 PyObject *obj;
11323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11324 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11325 return SWIG_Py_Void();
11326 }
11327
11328 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11329 return SWIG_Python_InitShadowInstance(args);
11330 }
11331
11332 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11333 PyObject *resultobj = 0;
11334 wxWindow *arg1 = (wxWindow *) 0 ;
11335 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11336 bool arg3 = (bool) true ;
11337 bool result;
11338 void *argp1 = 0 ;
11339 int res1 = 0 ;
11340 void *argp2 = 0 ;
11341 int res2 = 0 ;
11342 bool val3 ;
11343 int ecode3 = 0 ;
11344 PyObject * obj0 = 0 ;
11345 PyObject * obj1 = 0 ;
11346 PyObject * obj2 = 0 ;
11347 char * kwnames[] = {
11348 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11349 };
11350
11351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11353 if (!SWIG_IsOK(res1)) {
11354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11355 }
11356 arg1 = reinterpret_cast< wxWindow * >(argp1);
11357 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11358 if (!SWIG_IsOK(res2)) {
11359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11360 }
11361 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11362 if (obj2) {
11363 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11364 if (!SWIG_IsOK(ecode3)) {
11365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11366 }
11367 arg3 = static_cast< bool >(val3);
11368 }
11369 {
11370 if (!wxPyCheckForApp()) SWIG_fail;
11371 PyThreadState* __tstate = wxPyBeginAllowThreads();
11372 result = (bool)wxShowTip(arg1,arg2,arg3);
11373 wxPyEndAllowThreads(__tstate);
11374 if (PyErr_Occurred()) SWIG_fail;
11375 }
11376 {
11377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11378 }
11379 return resultobj;
11380 fail:
11381 return NULL;
11382 }
11383
11384
11385 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11386 PyObject *resultobj = 0;
11387 wxString *arg1 = 0 ;
11388 size_t arg2 ;
11389 wxTipProvider *result = 0 ;
11390 bool temp1 = false ;
11391 size_t val2 ;
11392 int ecode2 = 0 ;
11393 PyObject * obj0 = 0 ;
11394 PyObject * obj1 = 0 ;
11395 char * kwnames[] = {
11396 (char *) "filename",(char *) "currentTip", NULL
11397 };
11398
11399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11400 {
11401 arg1 = wxString_in_helper(obj0);
11402 if (arg1 == NULL) SWIG_fail;
11403 temp1 = true;
11404 }
11405 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11406 if (!SWIG_IsOK(ecode2)) {
11407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11408 }
11409 arg2 = static_cast< size_t >(val2);
11410 {
11411 if (!wxPyCheckForApp()) SWIG_fail;
11412 PyThreadState* __tstate = wxPyBeginAllowThreads();
11413 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11414 wxPyEndAllowThreads(__tstate);
11415 if (PyErr_Occurred()) SWIG_fail;
11416 }
11417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11418 {
11419 if (temp1)
11420 delete arg1;
11421 }
11422 return resultobj;
11423 fail:
11424 {
11425 if (temp1)
11426 delete arg1;
11427 }
11428 return NULL;
11429 }
11430
11431
11432 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11433 PyObject *resultobj = 0;
11434 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11435 int arg2 = (int) wxID_ANY ;
11436 wxPyTimer *result = 0 ;
11437 void *argp1 = 0 ;
11438 int res1 = 0 ;
11439 int val2 ;
11440 int ecode2 = 0 ;
11441 PyObject * obj0 = 0 ;
11442 PyObject * obj1 = 0 ;
11443 char * kwnames[] = {
11444 (char *) "owner",(char *) "id", NULL
11445 };
11446
11447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11448 if (obj0) {
11449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11450 if (!SWIG_IsOK(res1)) {
11451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11452 }
11453 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11454 }
11455 if (obj1) {
11456 ecode2 = SWIG_AsVal_int(obj1, &val2);
11457 if (!SWIG_IsOK(ecode2)) {
11458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11459 }
11460 arg2 = static_cast< int >(val2);
11461 }
11462 {
11463 if (!wxPyCheckForApp()) SWIG_fail;
11464 PyThreadState* __tstate = wxPyBeginAllowThreads();
11465 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11466 wxPyEndAllowThreads(__tstate);
11467 if (PyErr_Occurred()) SWIG_fail;
11468 }
11469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11470 return resultobj;
11471 fail:
11472 return NULL;
11473 }
11474
11475
11476 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11477 PyObject *resultobj = 0;
11478 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11479 void *argp1 = 0 ;
11480 int res1 = 0 ;
11481 PyObject *swig_obj[1] ;
11482
11483 if (!args) SWIG_fail;
11484 swig_obj[0] = args;
11485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11486 if (!SWIG_IsOK(res1)) {
11487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11488 }
11489 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11490 {
11491 PyThreadState* __tstate = wxPyBeginAllowThreads();
11492 delete arg1;
11493
11494 wxPyEndAllowThreads(__tstate);
11495 if (PyErr_Occurred()) SWIG_fail;
11496 }
11497 resultobj = SWIG_Py_Void();
11498 return resultobj;
11499 fail:
11500 return NULL;
11501 }
11502
11503
11504 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11505 PyObject *resultobj = 0;
11506 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11507 PyObject *arg2 = (PyObject *) 0 ;
11508 PyObject *arg3 = (PyObject *) 0 ;
11509 int arg4 = (int) 1 ;
11510 void *argp1 = 0 ;
11511 int res1 = 0 ;
11512 int val4 ;
11513 int ecode4 = 0 ;
11514 PyObject * obj0 = 0 ;
11515 PyObject * obj1 = 0 ;
11516 PyObject * obj2 = 0 ;
11517 PyObject * obj3 = 0 ;
11518 char * kwnames[] = {
11519 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11520 };
11521
11522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11524 if (!SWIG_IsOK(res1)) {
11525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11526 }
11527 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11528 arg2 = obj1;
11529 arg3 = obj2;
11530 if (obj3) {
11531 ecode4 = SWIG_AsVal_int(obj3, &val4);
11532 if (!SWIG_IsOK(ecode4)) {
11533 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11534 }
11535 arg4 = static_cast< int >(val4);
11536 }
11537 {
11538 PyThreadState* __tstate = wxPyBeginAllowThreads();
11539 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11540 wxPyEndAllowThreads(__tstate);
11541 if (PyErr_Occurred()) SWIG_fail;
11542 }
11543 resultobj = SWIG_Py_Void();
11544 return resultobj;
11545 fail:
11546 return NULL;
11547 }
11548
11549
11550 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11551 PyObject *resultobj = 0;
11552 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11553 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11554 int arg3 = (int) wxID_ANY ;
11555 void *argp1 = 0 ;
11556 int res1 = 0 ;
11557 void *argp2 = 0 ;
11558 int res2 = 0 ;
11559 int val3 ;
11560 int ecode3 = 0 ;
11561 PyObject * obj0 = 0 ;
11562 PyObject * obj1 = 0 ;
11563 PyObject * obj2 = 0 ;
11564 char * kwnames[] = {
11565 (char *) "self",(char *) "owner",(char *) "id", NULL
11566 };
11567
11568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11570 if (!SWIG_IsOK(res1)) {
11571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11572 }
11573 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11574 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11575 if (!SWIG_IsOK(res2)) {
11576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11577 }
11578 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11579 if (obj2) {
11580 ecode3 = SWIG_AsVal_int(obj2, &val3);
11581 if (!SWIG_IsOK(ecode3)) {
11582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11583 }
11584 arg3 = static_cast< int >(val3);
11585 }
11586 {
11587 PyThreadState* __tstate = wxPyBeginAllowThreads();
11588 (arg1)->SetOwner(arg2,arg3);
11589 wxPyEndAllowThreads(__tstate);
11590 if (PyErr_Occurred()) SWIG_fail;
11591 }
11592 resultobj = SWIG_Py_Void();
11593 return resultobj;
11594 fail:
11595 return NULL;
11596 }
11597
11598
11599 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11600 PyObject *resultobj = 0;
11601 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11602 wxEvtHandler *result = 0 ;
11603 void *argp1 = 0 ;
11604 int res1 = 0 ;
11605 PyObject *swig_obj[1] ;
11606
11607 if (!args) SWIG_fail;
11608 swig_obj[0] = args;
11609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11610 if (!SWIG_IsOK(res1)) {
11611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11612 }
11613 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11614 {
11615 PyThreadState* __tstate = wxPyBeginAllowThreads();
11616 result = (wxEvtHandler *)(arg1)->GetOwner();
11617 wxPyEndAllowThreads(__tstate);
11618 if (PyErr_Occurred()) SWIG_fail;
11619 }
11620 {
11621 resultobj = wxPyMake_wxObject(result, 0);
11622 }
11623 return resultobj;
11624 fail:
11625 return NULL;
11626 }
11627
11628
11629 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11630 PyObject *resultobj = 0;
11631 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11632 int arg2 = (int) -1 ;
11633 bool arg3 = (bool) false ;
11634 bool result;
11635 void *argp1 = 0 ;
11636 int res1 = 0 ;
11637 int val2 ;
11638 int ecode2 = 0 ;
11639 bool val3 ;
11640 int ecode3 = 0 ;
11641 PyObject * obj0 = 0 ;
11642 PyObject * obj1 = 0 ;
11643 PyObject * obj2 = 0 ;
11644 char * kwnames[] = {
11645 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11646 };
11647
11648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11650 if (!SWIG_IsOK(res1)) {
11651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11652 }
11653 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11654 if (obj1) {
11655 ecode2 = SWIG_AsVal_int(obj1, &val2);
11656 if (!SWIG_IsOK(ecode2)) {
11657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11658 }
11659 arg2 = static_cast< int >(val2);
11660 }
11661 if (obj2) {
11662 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11663 if (!SWIG_IsOK(ecode3)) {
11664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11665 }
11666 arg3 = static_cast< bool >(val3);
11667 }
11668 {
11669 PyThreadState* __tstate = wxPyBeginAllowThreads();
11670 result = (bool)(arg1)->Start(arg2,arg3);
11671 wxPyEndAllowThreads(__tstate);
11672 if (PyErr_Occurred()) SWIG_fail;
11673 }
11674 {
11675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11676 }
11677 return resultobj;
11678 fail:
11679 return NULL;
11680 }
11681
11682
11683 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11684 PyObject *resultobj = 0;
11685 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11686 void *argp1 = 0 ;
11687 int res1 = 0 ;
11688 PyObject *swig_obj[1] ;
11689
11690 if (!args) SWIG_fail;
11691 swig_obj[0] = args;
11692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11693 if (!SWIG_IsOK(res1)) {
11694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11695 }
11696 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11697 {
11698 PyThreadState* __tstate = wxPyBeginAllowThreads();
11699 (arg1)->Stop();
11700 wxPyEndAllowThreads(__tstate);
11701 if (PyErr_Occurred()) SWIG_fail;
11702 }
11703 resultobj = SWIG_Py_Void();
11704 return resultobj;
11705 fail:
11706 return NULL;
11707 }
11708
11709
11710 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11711 PyObject *resultobj = 0;
11712 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11713 void *argp1 = 0 ;
11714 int res1 = 0 ;
11715 PyObject *swig_obj[1] ;
11716
11717 if (!args) SWIG_fail;
11718 swig_obj[0] = args;
11719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11720 if (!SWIG_IsOK(res1)) {
11721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11722 }
11723 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11724 {
11725 PyThreadState* __tstate = wxPyBeginAllowThreads();
11726 (arg1)->Notify();
11727 wxPyEndAllowThreads(__tstate);
11728 if (PyErr_Occurred()) SWIG_fail;
11729 }
11730 resultobj = SWIG_Py_Void();
11731 return resultobj;
11732 fail:
11733 return NULL;
11734 }
11735
11736
11737 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11738 PyObject *resultobj = 0;
11739 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11740 bool result;
11741 void *argp1 = 0 ;
11742 int res1 = 0 ;
11743 PyObject *swig_obj[1] ;
11744
11745 if (!args) SWIG_fail;
11746 swig_obj[0] = args;
11747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11748 if (!SWIG_IsOK(res1)) {
11749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11750 }
11751 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11752 {
11753 PyThreadState* __tstate = wxPyBeginAllowThreads();
11754 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11755 wxPyEndAllowThreads(__tstate);
11756 if (PyErr_Occurred()) SWIG_fail;
11757 }
11758 {
11759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11760 }
11761 return resultobj;
11762 fail:
11763 return NULL;
11764 }
11765
11766
11767 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11768 PyObject *resultobj = 0;
11769 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11770 int result;
11771 void *argp1 = 0 ;
11772 int res1 = 0 ;
11773 PyObject *swig_obj[1] ;
11774
11775 if (!args) SWIG_fail;
11776 swig_obj[0] = args;
11777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11778 if (!SWIG_IsOK(res1)) {
11779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11780 }
11781 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11782 {
11783 PyThreadState* __tstate = wxPyBeginAllowThreads();
11784 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11785 wxPyEndAllowThreads(__tstate);
11786 if (PyErr_Occurred()) SWIG_fail;
11787 }
11788 resultobj = SWIG_From_int(static_cast< int >(result));
11789 return resultobj;
11790 fail:
11791 return NULL;
11792 }
11793
11794
11795 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11796 PyObject *resultobj = 0;
11797 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11798 int result;
11799 void *argp1 = 0 ;
11800 int res1 = 0 ;
11801 PyObject *swig_obj[1] ;
11802
11803 if (!args) SWIG_fail;
11804 swig_obj[0] = args;
11805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11806 if (!SWIG_IsOK(res1)) {
11807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11808 }
11809 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11810 {
11811 PyThreadState* __tstate = wxPyBeginAllowThreads();
11812 result = (int)((wxPyTimer const *)arg1)->GetId();
11813 wxPyEndAllowThreads(__tstate);
11814 if (PyErr_Occurred()) SWIG_fail;
11815 }
11816 resultobj = SWIG_From_int(static_cast< int >(result));
11817 return resultobj;
11818 fail:
11819 return NULL;
11820 }
11821
11822
11823 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11824 PyObject *resultobj = 0;
11825 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11826 bool result;
11827 void *argp1 = 0 ;
11828 int res1 = 0 ;
11829 PyObject *swig_obj[1] ;
11830
11831 if (!args) SWIG_fail;
11832 swig_obj[0] = args;
11833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11834 if (!SWIG_IsOK(res1)) {
11835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11836 }
11837 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11838 {
11839 PyThreadState* __tstate = wxPyBeginAllowThreads();
11840 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11841 wxPyEndAllowThreads(__tstate);
11842 if (PyErr_Occurred()) SWIG_fail;
11843 }
11844 {
11845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11846 }
11847 return resultobj;
11848 fail:
11849 return NULL;
11850 }
11851
11852
11853 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11854 PyObject *obj;
11855 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11856 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11857 return SWIG_Py_Void();
11858 }
11859
11860 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11861 return SWIG_Python_InitShadowInstance(args);
11862 }
11863
11864 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11865 PyObject *resultobj = 0;
11866 int arg1 = (int) 0 ;
11867 int arg2 = (int) 0 ;
11868 wxTimerEvent *result = 0 ;
11869 int val1 ;
11870 int ecode1 = 0 ;
11871 int val2 ;
11872 int ecode2 = 0 ;
11873 PyObject * obj0 = 0 ;
11874 PyObject * obj1 = 0 ;
11875 char * kwnames[] = {
11876 (char *) "timerid",(char *) "interval", NULL
11877 };
11878
11879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11880 if (obj0) {
11881 ecode1 = SWIG_AsVal_int(obj0, &val1);
11882 if (!SWIG_IsOK(ecode1)) {
11883 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11884 }
11885 arg1 = static_cast< int >(val1);
11886 }
11887 if (obj1) {
11888 ecode2 = SWIG_AsVal_int(obj1, &val2);
11889 if (!SWIG_IsOK(ecode2)) {
11890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11891 }
11892 arg2 = static_cast< int >(val2);
11893 }
11894 {
11895 PyThreadState* __tstate = wxPyBeginAllowThreads();
11896 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11897 wxPyEndAllowThreads(__tstate);
11898 if (PyErr_Occurred()) SWIG_fail;
11899 }
11900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11901 return resultobj;
11902 fail:
11903 return NULL;
11904 }
11905
11906
11907 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11908 PyObject *resultobj = 0;
11909 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11910 int result;
11911 void *argp1 = 0 ;
11912 int res1 = 0 ;
11913 PyObject *swig_obj[1] ;
11914
11915 if (!args) SWIG_fail;
11916 swig_obj[0] = args;
11917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11918 if (!SWIG_IsOK(res1)) {
11919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11920 }
11921 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11922 {
11923 PyThreadState* __tstate = wxPyBeginAllowThreads();
11924 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11925 wxPyEndAllowThreads(__tstate);
11926 if (PyErr_Occurred()) SWIG_fail;
11927 }
11928 resultobj = SWIG_From_int(static_cast< int >(result));
11929 return resultobj;
11930 fail:
11931 return NULL;
11932 }
11933
11934
11935 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11936 PyObject *obj;
11937 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11938 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11939 return SWIG_Py_Void();
11940 }
11941
11942 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11943 return SWIG_Python_InitShadowInstance(args);
11944 }
11945
11946 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11947 PyObject *resultobj = 0;
11948 wxTimer *arg1 = 0 ;
11949 wxTimerRunner *result = 0 ;
11950 void *argp1 = 0 ;
11951 int res1 = 0 ;
11952
11953 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11955 if (!SWIG_IsOK(res1)) {
11956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11957 }
11958 if (!argp1) {
11959 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11960 }
11961 arg1 = reinterpret_cast< wxTimer * >(argp1);
11962 {
11963 if (!wxPyCheckForApp()) SWIG_fail;
11964 PyThreadState* __tstate = wxPyBeginAllowThreads();
11965 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11966 wxPyEndAllowThreads(__tstate);
11967 if (PyErr_Occurred()) SWIG_fail;
11968 }
11969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11970 return resultobj;
11971 fail:
11972 return NULL;
11973 }
11974
11975
11976 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11977 PyObject *resultobj = 0;
11978 wxTimer *arg1 = 0 ;
11979 int arg2 ;
11980 bool arg3 = (bool) false ;
11981 wxTimerRunner *result = 0 ;
11982 void *argp1 = 0 ;
11983 int res1 = 0 ;
11984 int val2 ;
11985 int ecode2 = 0 ;
11986 bool val3 ;
11987 int ecode3 = 0 ;
11988
11989 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
11990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11991 if (!SWIG_IsOK(res1)) {
11992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11993 }
11994 if (!argp1) {
11995 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11996 }
11997 arg1 = reinterpret_cast< wxTimer * >(argp1);
11998 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11999 if (!SWIG_IsOK(ecode2)) {
12000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12001 }
12002 arg2 = static_cast< int >(val2);
12003 if (swig_obj[2]) {
12004 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12005 if (!SWIG_IsOK(ecode3)) {
12006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12007 }
12008 arg3 = static_cast< bool >(val3);
12009 }
12010 {
12011 if (!wxPyCheckForApp()) SWIG_fail;
12012 PyThreadState* __tstate = wxPyBeginAllowThreads();
12013 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12014 wxPyEndAllowThreads(__tstate);
12015 if (PyErr_Occurred()) SWIG_fail;
12016 }
12017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12018 return resultobj;
12019 fail:
12020 return NULL;
12021 }
12022
12023
12024 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12025 int argc;
12026 PyObject *argv[4];
12027
12028 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12029 --argc;
12030 if (argc == 1) {
12031 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12032 }
12033 if ((argc >= 2) && (argc <= 3)) {
12034 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12035 }
12036
12037 fail:
12038 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12039 return NULL;
12040 }
12041
12042
12043 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12044 PyObject *resultobj = 0;
12045 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12046 void *argp1 = 0 ;
12047 int res1 = 0 ;
12048 PyObject *swig_obj[1] ;
12049
12050 if (!args) SWIG_fail;
12051 swig_obj[0] = args;
12052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12053 if (!SWIG_IsOK(res1)) {
12054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12055 }
12056 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12057 {
12058 PyThreadState* __tstate = wxPyBeginAllowThreads();
12059 delete arg1;
12060
12061 wxPyEndAllowThreads(__tstate);
12062 if (PyErr_Occurred()) SWIG_fail;
12063 }
12064 resultobj = SWIG_Py_Void();
12065 return resultobj;
12066 fail:
12067 return NULL;
12068 }
12069
12070
12071 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12072 PyObject *resultobj = 0;
12073 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12074 int arg2 ;
12075 bool arg3 = (bool) false ;
12076 void *argp1 = 0 ;
12077 int res1 = 0 ;
12078 int val2 ;
12079 int ecode2 = 0 ;
12080 bool val3 ;
12081 int ecode3 = 0 ;
12082 PyObject * obj0 = 0 ;
12083 PyObject * obj1 = 0 ;
12084 PyObject * obj2 = 0 ;
12085 char * kwnames[] = {
12086 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12087 };
12088
12089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12091 if (!SWIG_IsOK(res1)) {
12092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12093 }
12094 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12095 ecode2 = SWIG_AsVal_int(obj1, &val2);
12096 if (!SWIG_IsOK(ecode2)) {
12097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12098 }
12099 arg2 = static_cast< int >(val2);
12100 if (obj2) {
12101 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12102 if (!SWIG_IsOK(ecode3)) {
12103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12104 }
12105 arg3 = static_cast< bool >(val3);
12106 }
12107 {
12108 PyThreadState* __tstate = wxPyBeginAllowThreads();
12109 (arg1)->Start(arg2,arg3);
12110 wxPyEndAllowThreads(__tstate);
12111 if (PyErr_Occurred()) SWIG_fail;
12112 }
12113 resultobj = SWIG_Py_Void();
12114 return resultobj;
12115 fail:
12116 return NULL;
12117 }
12118
12119
12120 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12121 PyObject *obj;
12122 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12123 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12124 return SWIG_Py_Void();
12125 }
12126
12127 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12128 return SWIG_Python_InitShadowInstance(args);
12129 }
12130
12131 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12132 PyObject *resultobj = 0;
12133 wxLog *result = 0 ;
12134
12135 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12136 {
12137 PyThreadState* __tstate = wxPyBeginAllowThreads();
12138 result = (wxLog *)new wxLog();
12139 wxPyEndAllowThreads(__tstate);
12140 if (PyErr_Occurred()) SWIG_fail;
12141 }
12142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12143 return resultobj;
12144 fail:
12145 return NULL;
12146 }
12147
12148
12149 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12150 PyObject *resultobj = 0;
12151 wxLog *arg1 = (wxLog *) 0 ;
12152 void *argp1 = 0 ;
12153 int res1 = 0 ;
12154 PyObject *swig_obj[1] ;
12155
12156 if (!args) SWIG_fail;
12157 swig_obj[0] = args;
12158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12159 if (!SWIG_IsOK(res1)) {
12160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12161 }
12162 arg1 = reinterpret_cast< wxLog * >(argp1);
12163 {
12164 PyThreadState* __tstate = wxPyBeginAllowThreads();
12165 delete arg1;
12166
12167 wxPyEndAllowThreads(__tstate);
12168 if (PyErr_Occurred()) SWIG_fail;
12169 }
12170 resultobj = SWIG_Py_Void();
12171 return resultobj;
12172 fail:
12173 return NULL;
12174 }
12175
12176
12177 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12178 PyObject *resultobj = 0;
12179 bool result;
12180
12181 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12182 {
12183 PyThreadState* __tstate = wxPyBeginAllowThreads();
12184 result = (bool)wxLog::IsEnabled();
12185 wxPyEndAllowThreads(__tstate);
12186 if (PyErr_Occurred()) SWIG_fail;
12187 }
12188 {
12189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12190 }
12191 return resultobj;
12192 fail:
12193 return NULL;
12194 }
12195
12196
12197 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12198 PyObject *resultobj = 0;
12199 bool arg1 = (bool) true ;
12200 bool result;
12201 bool val1 ;
12202 int ecode1 = 0 ;
12203 PyObject * obj0 = 0 ;
12204 char * kwnames[] = {
12205 (char *) "doIt", NULL
12206 };
12207
12208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12209 if (obj0) {
12210 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12211 if (!SWIG_IsOK(ecode1)) {
12212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12213 }
12214 arg1 = static_cast< bool >(val1);
12215 }
12216 {
12217 PyThreadState* __tstate = wxPyBeginAllowThreads();
12218 result = (bool)wxLog::EnableLogging(arg1);
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 {
12223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12224 }
12225 return resultobj;
12226 fail:
12227 return NULL;
12228 }
12229
12230
12231 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12232 PyObject *resultobj = 0;
12233 wxLogLevel arg1 ;
12234 wxChar *arg2 = (wxChar *) 0 ;
12235 time_t arg3 ;
12236 unsigned long val1 ;
12237 int ecode1 = 0 ;
12238 void *argp2 = 0 ;
12239 int res2 = 0 ;
12240 unsigned int val3 ;
12241 int ecode3 = 0 ;
12242 PyObject * obj0 = 0 ;
12243 PyObject * obj1 = 0 ;
12244 PyObject * obj2 = 0 ;
12245 char * kwnames[] = {
12246 (char *) "level",(char *) "szString",(char *) "t", NULL
12247 };
12248
12249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12250 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12251 if (!SWIG_IsOK(ecode1)) {
12252 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12253 }
12254 arg1 = static_cast< wxLogLevel >(val1);
12255 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12256 if (!SWIG_IsOK(res2)) {
12257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12258 }
12259 arg2 = reinterpret_cast< wxChar * >(argp2);
12260 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12261 if (!SWIG_IsOK(ecode3)) {
12262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12263 }
12264 arg3 = static_cast< time_t >(val3);
12265 {
12266 PyThreadState* __tstate = wxPyBeginAllowThreads();
12267 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12268 wxPyEndAllowThreads(__tstate);
12269 if (PyErr_Occurred()) SWIG_fail;
12270 }
12271 resultobj = SWIG_Py_Void();
12272 return resultobj;
12273 fail:
12274 return NULL;
12275 }
12276
12277
12278 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12279 PyObject *resultobj = 0;
12280 wxLog *arg1 = (wxLog *) 0 ;
12281 void *argp1 = 0 ;
12282 int res1 = 0 ;
12283 PyObject *swig_obj[1] ;
12284
12285 if (!args) SWIG_fail;
12286 swig_obj[0] = args;
12287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12288 if (!SWIG_IsOK(res1)) {
12289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12290 }
12291 arg1 = reinterpret_cast< wxLog * >(argp1);
12292 {
12293 PyThreadState* __tstate = wxPyBeginAllowThreads();
12294 (arg1)->Flush();
12295 wxPyEndAllowThreads(__tstate);
12296 if (PyErr_Occurred()) SWIG_fail;
12297 }
12298 resultobj = SWIG_Py_Void();
12299 return resultobj;
12300 fail:
12301 return NULL;
12302 }
12303
12304
12305 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12306 PyObject *resultobj = 0;
12307
12308 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12309 {
12310 PyThreadState* __tstate = wxPyBeginAllowThreads();
12311 wxLog::FlushActive();
12312 wxPyEndAllowThreads(__tstate);
12313 if (PyErr_Occurred()) SWIG_fail;
12314 }
12315 resultobj = SWIG_Py_Void();
12316 return resultobj;
12317 fail:
12318 return NULL;
12319 }
12320
12321
12322 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12323 PyObject *resultobj = 0;
12324 wxLog *result = 0 ;
12325
12326 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12327 {
12328 PyThreadState* __tstate = wxPyBeginAllowThreads();
12329 result = (wxLog *)wxLog::GetActiveTarget();
12330 wxPyEndAllowThreads(__tstate);
12331 if (PyErr_Occurred()) SWIG_fail;
12332 }
12333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12334 return resultobj;
12335 fail:
12336 return NULL;
12337 }
12338
12339
12340 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12341 PyObject *resultobj = 0;
12342 wxLog *arg1 = (wxLog *) 0 ;
12343 wxLog *result = 0 ;
12344 int res1 = 0 ;
12345 PyObject * obj0 = 0 ;
12346 char * kwnames[] = {
12347 (char *) "pLogger", NULL
12348 };
12349
12350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12351 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12352 if (!SWIG_IsOK(res1)) {
12353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12354 }
12355 {
12356 PyThreadState* __tstate = wxPyBeginAllowThreads();
12357 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12358 wxPyEndAllowThreads(__tstate);
12359 if (PyErr_Occurred()) SWIG_fail;
12360 }
12361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12362 return resultobj;
12363 fail:
12364 return NULL;
12365 }
12366
12367
12368 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12369 PyObject *resultobj = 0;
12370
12371 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12372 {
12373 PyThreadState* __tstate = wxPyBeginAllowThreads();
12374 wxLog::Suspend();
12375 wxPyEndAllowThreads(__tstate);
12376 if (PyErr_Occurred()) SWIG_fail;
12377 }
12378 resultobj = SWIG_Py_Void();
12379 return resultobj;
12380 fail:
12381 return NULL;
12382 }
12383
12384
12385 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12386 PyObject *resultobj = 0;
12387
12388 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12389 {
12390 PyThreadState* __tstate = wxPyBeginAllowThreads();
12391 wxLog::Resume();
12392 wxPyEndAllowThreads(__tstate);
12393 if (PyErr_Occurred()) SWIG_fail;
12394 }
12395 resultobj = SWIG_Py_Void();
12396 return resultobj;
12397 fail:
12398 return NULL;
12399 }
12400
12401
12402 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12403 PyObject *resultobj = 0;
12404 bool arg1 = (bool) true ;
12405 bool val1 ;
12406 int ecode1 = 0 ;
12407 PyObject * obj0 = 0 ;
12408 char * kwnames[] = {
12409 (char *) "bVerbose", NULL
12410 };
12411
12412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12413 if (obj0) {
12414 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12415 if (!SWIG_IsOK(ecode1)) {
12416 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12417 }
12418 arg1 = static_cast< bool >(val1);
12419 }
12420 {
12421 PyThreadState* __tstate = wxPyBeginAllowThreads();
12422 wxLog::SetVerbose(arg1);
12423 wxPyEndAllowThreads(__tstate);
12424 if (PyErr_Occurred()) SWIG_fail;
12425 }
12426 resultobj = SWIG_Py_Void();
12427 return resultobj;
12428 fail:
12429 return NULL;
12430 }
12431
12432
12433 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12434 PyObject *resultobj = 0;
12435 wxLogLevel arg1 ;
12436 unsigned long val1 ;
12437 int ecode1 = 0 ;
12438 PyObject * obj0 = 0 ;
12439 char * kwnames[] = {
12440 (char *) "logLevel", NULL
12441 };
12442
12443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12444 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12445 if (!SWIG_IsOK(ecode1)) {
12446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12447 }
12448 arg1 = static_cast< wxLogLevel >(val1);
12449 {
12450 PyThreadState* __tstate = wxPyBeginAllowThreads();
12451 wxLog::SetLogLevel(arg1);
12452 wxPyEndAllowThreads(__tstate);
12453 if (PyErr_Occurred()) SWIG_fail;
12454 }
12455 resultobj = SWIG_Py_Void();
12456 return resultobj;
12457 fail:
12458 return NULL;
12459 }
12460
12461
12462 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12463 PyObject *resultobj = 0;
12464
12465 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12466 {
12467 PyThreadState* __tstate = wxPyBeginAllowThreads();
12468 wxLog::DontCreateOnDemand();
12469 wxPyEndAllowThreads(__tstate);
12470 if (PyErr_Occurred()) SWIG_fail;
12471 }
12472 resultobj = SWIG_Py_Void();
12473 return resultobj;
12474 fail:
12475 return NULL;
12476 }
12477
12478
12479 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12480 PyObject *resultobj = 0;
12481 bool arg1 = (bool) true ;
12482 bool val1 ;
12483 int ecode1 = 0 ;
12484 PyObject * obj0 = 0 ;
12485 char * kwnames[] = {
12486 (char *) "bRepetCounting", NULL
12487 };
12488
12489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12490 if (obj0) {
12491 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12492 if (!SWIG_IsOK(ecode1)) {
12493 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12494 }
12495 arg1 = static_cast< bool >(val1);
12496 }
12497 {
12498 PyThreadState* __tstate = wxPyBeginAllowThreads();
12499 wxLog::SetRepetitionCounting(arg1);
12500 wxPyEndAllowThreads(__tstate);
12501 if (PyErr_Occurred()) SWIG_fail;
12502 }
12503 resultobj = SWIG_Py_Void();
12504 return resultobj;
12505 fail:
12506 return NULL;
12507 }
12508
12509
12510 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12511 PyObject *resultobj = 0;
12512 bool result;
12513
12514 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12515 {
12516 PyThreadState* __tstate = wxPyBeginAllowThreads();
12517 result = (bool)wxLog::GetRepetitionCounting();
12518 wxPyEndAllowThreads(__tstate);
12519 if (PyErr_Occurred()) SWIG_fail;
12520 }
12521 {
12522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12523 }
12524 return resultobj;
12525 fail:
12526 return NULL;
12527 }
12528
12529
12530 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12531 PyObject *resultobj = 0;
12532 wxTraceMask arg1 ;
12533 unsigned long val1 ;
12534 int ecode1 = 0 ;
12535 PyObject * obj0 = 0 ;
12536 char * kwnames[] = {
12537 (char *) "ulMask", NULL
12538 };
12539
12540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12541 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12542 if (!SWIG_IsOK(ecode1)) {
12543 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12544 }
12545 arg1 = static_cast< wxTraceMask >(val1);
12546 {
12547 PyThreadState* __tstate = wxPyBeginAllowThreads();
12548 wxLog::SetTraceMask(arg1);
12549 wxPyEndAllowThreads(__tstate);
12550 if (PyErr_Occurred()) SWIG_fail;
12551 }
12552 resultobj = SWIG_Py_Void();
12553 return resultobj;
12554 fail:
12555 return NULL;
12556 }
12557
12558
12559 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12560 PyObject *resultobj = 0;
12561 wxString *arg1 = 0 ;
12562 bool temp1 = false ;
12563 PyObject * obj0 = 0 ;
12564 char * kwnames[] = {
12565 (char *) "str", NULL
12566 };
12567
12568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12569 {
12570 arg1 = wxString_in_helper(obj0);
12571 if (arg1 == NULL) SWIG_fail;
12572 temp1 = true;
12573 }
12574 {
12575 PyThreadState* __tstate = wxPyBeginAllowThreads();
12576 wxLog::AddTraceMask((wxString const &)*arg1);
12577 wxPyEndAllowThreads(__tstate);
12578 if (PyErr_Occurred()) SWIG_fail;
12579 }
12580 resultobj = SWIG_Py_Void();
12581 {
12582 if (temp1)
12583 delete arg1;
12584 }
12585 return resultobj;
12586 fail:
12587 {
12588 if (temp1)
12589 delete arg1;
12590 }
12591 return NULL;
12592 }
12593
12594
12595 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12596 PyObject *resultobj = 0;
12597 wxString *arg1 = 0 ;
12598 bool temp1 = false ;
12599 PyObject * obj0 = 0 ;
12600 char * kwnames[] = {
12601 (char *) "str", NULL
12602 };
12603
12604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12605 {
12606 arg1 = wxString_in_helper(obj0);
12607 if (arg1 == NULL) SWIG_fail;
12608 temp1 = true;
12609 }
12610 {
12611 PyThreadState* __tstate = wxPyBeginAllowThreads();
12612 wxLog::RemoveTraceMask((wxString const &)*arg1);
12613 wxPyEndAllowThreads(__tstate);
12614 if (PyErr_Occurred()) SWIG_fail;
12615 }
12616 resultobj = SWIG_Py_Void();
12617 {
12618 if (temp1)
12619 delete arg1;
12620 }
12621 return resultobj;
12622 fail:
12623 {
12624 if (temp1)
12625 delete arg1;
12626 }
12627 return NULL;
12628 }
12629
12630
12631 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12632 PyObject *resultobj = 0;
12633
12634 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12635 {
12636 PyThreadState* __tstate = wxPyBeginAllowThreads();
12637 wxLog::ClearTraceMasks();
12638 wxPyEndAllowThreads(__tstate);
12639 if (PyErr_Occurred()) SWIG_fail;
12640 }
12641 resultobj = SWIG_Py_Void();
12642 return resultobj;
12643 fail:
12644 return NULL;
12645 }
12646
12647
12648 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12649 PyObject *resultobj = 0;
12650 wxArrayString *result = 0 ;
12651
12652 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12653 {
12654 PyThreadState* __tstate = wxPyBeginAllowThreads();
12655 {
12656 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12657 result = (wxArrayString *) &_result_ref;
12658 }
12659 wxPyEndAllowThreads(__tstate);
12660 if (PyErr_Occurred()) SWIG_fail;
12661 }
12662 {
12663 resultobj = wxArrayString2PyList_helper(*result);
12664 }
12665 return resultobj;
12666 fail:
12667 return NULL;
12668 }
12669
12670
12671 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12672 PyObject *resultobj = 0;
12673 wxChar *arg1 = (wxChar *) 0 ;
12674 void *argp1 = 0 ;
12675 int res1 = 0 ;
12676 PyObject * obj0 = 0 ;
12677 char * kwnames[] = {
12678 (char *) "ts", NULL
12679 };
12680
12681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12683 if (!SWIG_IsOK(res1)) {
12684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12685 }
12686 arg1 = reinterpret_cast< wxChar * >(argp1);
12687 {
12688 PyThreadState* __tstate = wxPyBeginAllowThreads();
12689 wxLog::SetTimestamp((wxChar const *)arg1);
12690 wxPyEndAllowThreads(__tstate);
12691 if (PyErr_Occurred()) SWIG_fail;
12692 }
12693 resultobj = SWIG_Py_Void();
12694 return resultobj;
12695 fail:
12696 return NULL;
12697 }
12698
12699
12700 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12701 PyObject *resultobj = 0;
12702 bool result;
12703
12704 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12705 {
12706 PyThreadState* __tstate = wxPyBeginAllowThreads();
12707 result = (bool)wxLog::GetVerbose();
12708 wxPyEndAllowThreads(__tstate);
12709 if (PyErr_Occurred()) SWIG_fail;
12710 }
12711 {
12712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12713 }
12714 return resultobj;
12715 fail:
12716 return NULL;
12717 }
12718
12719
12720 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12721 PyObject *resultobj = 0;
12722 wxTraceMask result;
12723
12724 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12725 {
12726 PyThreadState* __tstate = wxPyBeginAllowThreads();
12727 result = (wxTraceMask)wxLog::GetTraceMask();
12728 wxPyEndAllowThreads(__tstate);
12729 if (PyErr_Occurred()) SWIG_fail;
12730 }
12731 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12732 return resultobj;
12733 fail:
12734 return NULL;
12735 }
12736
12737
12738 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12739 PyObject *resultobj = 0;
12740 wxChar *arg1 = (wxChar *) 0 ;
12741 bool result;
12742 void *argp1 = 0 ;
12743 int res1 = 0 ;
12744 PyObject * obj0 = 0 ;
12745 char * kwnames[] = {
12746 (char *) "mask", NULL
12747 };
12748
12749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12751 if (!SWIG_IsOK(res1)) {
12752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12753 }
12754 arg1 = reinterpret_cast< wxChar * >(argp1);
12755 {
12756 PyThreadState* __tstate = wxPyBeginAllowThreads();
12757 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12758 wxPyEndAllowThreads(__tstate);
12759 if (PyErr_Occurred()) SWIG_fail;
12760 }
12761 {
12762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12763 }
12764 return resultobj;
12765 fail:
12766 return NULL;
12767 }
12768
12769
12770 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12771 PyObject *resultobj = 0;
12772 wxLogLevel result;
12773
12774 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12775 {
12776 PyThreadState* __tstate = wxPyBeginAllowThreads();
12777 result = (wxLogLevel)wxLog::GetLogLevel();
12778 wxPyEndAllowThreads(__tstate);
12779 if (PyErr_Occurred()) SWIG_fail;
12780 }
12781 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12782 return resultobj;
12783 fail:
12784 return NULL;
12785 }
12786
12787
12788 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12789 PyObject *resultobj = 0;
12790 wxChar *result = 0 ;
12791
12792 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12793 {
12794 PyThreadState* __tstate = wxPyBeginAllowThreads();
12795 result = (wxChar *)wxLog::GetTimestamp();
12796 wxPyEndAllowThreads(__tstate);
12797 if (PyErr_Occurred()) SWIG_fail;
12798 }
12799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12800 return resultobj;
12801 fail:
12802 return NULL;
12803 }
12804
12805
12806 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12807 PyObject *resultobj = 0;
12808 wxString result;
12809
12810 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12811 {
12812 PyThreadState* __tstate = wxPyBeginAllowThreads();
12813 result = wxLog_TimeStamp();
12814 wxPyEndAllowThreads(__tstate);
12815 if (PyErr_Occurred()) SWIG_fail;
12816 }
12817 {
12818 #if wxUSE_UNICODE
12819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12820 #else
12821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12822 #endif
12823 }
12824 return resultobj;
12825 fail:
12826 return NULL;
12827 }
12828
12829
12830 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12831 PyObject *resultobj = 0;
12832 wxLog *arg1 = (wxLog *) 0 ;
12833 void *argp1 = 0 ;
12834 int res1 = 0 ;
12835 PyObject *swig_obj[1] ;
12836
12837 if (!args) SWIG_fail;
12838 swig_obj[0] = args;
12839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12840 if (!SWIG_IsOK(res1)) {
12841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12842 }
12843 arg1 = reinterpret_cast< wxLog * >(argp1);
12844 {
12845 PyThreadState* __tstate = wxPyBeginAllowThreads();
12846 wxLog_Destroy(arg1);
12847 wxPyEndAllowThreads(__tstate);
12848 if (PyErr_Occurred()) SWIG_fail;
12849 }
12850 resultobj = SWIG_Py_Void();
12851 return resultobj;
12852 fail:
12853 return NULL;
12854 }
12855
12856
12857 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12858 PyObject *obj;
12859 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12860 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12861 return SWIG_Py_Void();
12862 }
12863
12864 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12865 return SWIG_Python_InitShadowInstance(args);
12866 }
12867
12868 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12869 PyObject *resultobj = 0;
12870 wxLogStderr *result = 0 ;
12871
12872 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12873 {
12874 PyThreadState* __tstate = wxPyBeginAllowThreads();
12875 result = (wxLogStderr *)new wxLogStderr();
12876 wxPyEndAllowThreads(__tstate);
12877 if (PyErr_Occurred()) SWIG_fail;
12878 }
12879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12880 return resultobj;
12881 fail:
12882 return NULL;
12883 }
12884
12885
12886 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12887 PyObject *obj;
12888 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12889 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12890 return SWIG_Py_Void();
12891 }
12892
12893 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12894 return SWIG_Python_InitShadowInstance(args);
12895 }
12896
12897 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12898 PyObject *resultobj = 0;
12899 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12900 wxLogTextCtrl *result = 0 ;
12901 void *argp1 = 0 ;
12902 int res1 = 0 ;
12903 PyObject * obj0 = 0 ;
12904 char * kwnames[] = {
12905 (char *) "pTextCtrl", NULL
12906 };
12907
12908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12910 if (!SWIG_IsOK(res1)) {
12911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12912 }
12913 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12914 {
12915 PyThreadState* __tstate = wxPyBeginAllowThreads();
12916 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12917 wxPyEndAllowThreads(__tstate);
12918 if (PyErr_Occurred()) SWIG_fail;
12919 }
12920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12921 return resultobj;
12922 fail:
12923 return NULL;
12924 }
12925
12926
12927 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12928 PyObject *obj;
12929 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12930 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12931 return SWIG_Py_Void();
12932 }
12933
12934 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12935 return SWIG_Python_InitShadowInstance(args);
12936 }
12937
12938 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12939 PyObject *resultobj = 0;
12940 wxLogGui *result = 0 ;
12941
12942 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12943 {
12944 PyThreadState* __tstate = wxPyBeginAllowThreads();
12945 result = (wxLogGui *)new wxLogGui();
12946 wxPyEndAllowThreads(__tstate);
12947 if (PyErr_Occurred()) SWIG_fail;
12948 }
12949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12950 return resultobj;
12951 fail:
12952 return NULL;
12953 }
12954
12955
12956 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12957 PyObject *obj;
12958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12959 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12960 return SWIG_Py_Void();
12961 }
12962
12963 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12964 return SWIG_Python_InitShadowInstance(args);
12965 }
12966
12967 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12968 PyObject *resultobj = 0;
12969 wxFrame *arg1 = (wxFrame *) 0 ;
12970 wxString *arg2 = 0 ;
12971 bool arg3 = (bool) true ;
12972 bool arg4 = (bool) true ;
12973 wxLogWindow *result = 0 ;
12974 void *argp1 = 0 ;
12975 int res1 = 0 ;
12976 bool temp2 = false ;
12977 bool val3 ;
12978 int ecode3 = 0 ;
12979 bool val4 ;
12980 int ecode4 = 0 ;
12981 PyObject * obj0 = 0 ;
12982 PyObject * obj1 = 0 ;
12983 PyObject * obj2 = 0 ;
12984 PyObject * obj3 = 0 ;
12985 char * kwnames[] = {
12986 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
12987 };
12988
12989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12991 if (!SWIG_IsOK(res1)) {
12992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
12993 }
12994 arg1 = reinterpret_cast< wxFrame * >(argp1);
12995 {
12996 arg2 = wxString_in_helper(obj1);
12997 if (arg2 == NULL) SWIG_fail;
12998 temp2 = true;
12999 }
13000 if (obj2) {
13001 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13002 if (!SWIG_IsOK(ecode3)) {
13003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13004 }
13005 arg3 = static_cast< bool >(val3);
13006 }
13007 if (obj3) {
13008 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13009 if (!SWIG_IsOK(ecode4)) {
13010 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13011 }
13012 arg4 = static_cast< bool >(val4);
13013 }
13014 {
13015 PyThreadState* __tstate = wxPyBeginAllowThreads();
13016 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13017 wxPyEndAllowThreads(__tstate);
13018 if (PyErr_Occurred()) SWIG_fail;
13019 }
13020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13021 {
13022 if (temp2)
13023 delete arg2;
13024 }
13025 return resultobj;
13026 fail:
13027 {
13028 if (temp2)
13029 delete arg2;
13030 }
13031 return NULL;
13032 }
13033
13034
13035 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13036 PyObject *resultobj = 0;
13037 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13038 bool arg2 = (bool) true ;
13039 void *argp1 = 0 ;
13040 int res1 = 0 ;
13041 bool val2 ;
13042 int ecode2 = 0 ;
13043 PyObject * obj0 = 0 ;
13044 PyObject * obj1 = 0 ;
13045 char * kwnames[] = {
13046 (char *) "self",(char *) "bShow", NULL
13047 };
13048
13049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13051 if (!SWIG_IsOK(res1)) {
13052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13053 }
13054 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13055 if (obj1) {
13056 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13057 if (!SWIG_IsOK(ecode2)) {
13058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13059 }
13060 arg2 = static_cast< bool >(val2);
13061 }
13062 {
13063 PyThreadState* __tstate = wxPyBeginAllowThreads();
13064 (arg1)->Show(arg2);
13065 wxPyEndAllowThreads(__tstate);
13066 if (PyErr_Occurred()) SWIG_fail;
13067 }
13068 resultobj = SWIG_Py_Void();
13069 return resultobj;
13070 fail:
13071 return NULL;
13072 }
13073
13074
13075 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13076 PyObject *resultobj = 0;
13077 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13078 wxFrame *result = 0 ;
13079 void *argp1 = 0 ;
13080 int res1 = 0 ;
13081 PyObject *swig_obj[1] ;
13082
13083 if (!args) SWIG_fail;
13084 swig_obj[0] = args;
13085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13086 if (!SWIG_IsOK(res1)) {
13087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13088 }
13089 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13090 {
13091 PyThreadState* __tstate = wxPyBeginAllowThreads();
13092 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13093 wxPyEndAllowThreads(__tstate);
13094 if (PyErr_Occurred()) SWIG_fail;
13095 }
13096 {
13097 resultobj = wxPyMake_wxObject(result, (bool)0);
13098 }
13099 return resultobj;
13100 fail:
13101 return NULL;
13102 }
13103
13104
13105 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13106 PyObject *resultobj = 0;
13107 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13108 wxLog *result = 0 ;
13109 void *argp1 = 0 ;
13110 int res1 = 0 ;
13111 PyObject *swig_obj[1] ;
13112
13113 if (!args) SWIG_fail;
13114 swig_obj[0] = args;
13115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13116 if (!SWIG_IsOK(res1)) {
13117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13118 }
13119 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13120 {
13121 PyThreadState* __tstate = wxPyBeginAllowThreads();
13122 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13123 wxPyEndAllowThreads(__tstate);
13124 if (PyErr_Occurred()) SWIG_fail;
13125 }
13126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13127 return resultobj;
13128 fail:
13129 return NULL;
13130 }
13131
13132
13133 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13134 PyObject *resultobj = 0;
13135 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13136 bool result;
13137 void *argp1 = 0 ;
13138 int res1 = 0 ;
13139 PyObject *swig_obj[1] ;
13140
13141 if (!args) SWIG_fail;
13142 swig_obj[0] = args;
13143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13144 if (!SWIG_IsOK(res1)) {
13145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13146 }
13147 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13148 {
13149 PyThreadState* __tstate = wxPyBeginAllowThreads();
13150 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13151 wxPyEndAllowThreads(__tstate);
13152 if (PyErr_Occurred()) SWIG_fail;
13153 }
13154 {
13155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13156 }
13157 return resultobj;
13158 fail:
13159 return NULL;
13160 }
13161
13162
13163 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13164 PyObject *resultobj = 0;
13165 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13166 bool arg2 ;
13167 void *argp1 = 0 ;
13168 int res1 = 0 ;
13169 bool val2 ;
13170 int ecode2 = 0 ;
13171 PyObject * obj0 = 0 ;
13172 PyObject * obj1 = 0 ;
13173 char * kwnames[] = {
13174 (char *) "self",(char *) "bDoPass", NULL
13175 };
13176
13177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13179 if (!SWIG_IsOK(res1)) {
13180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13181 }
13182 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13183 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13184 if (!SWIG_IsOK(ecode2)) {
13185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13186 }
13187 arg2 = static_cast< bool >(val2);
13188 {
13189 PyThreadState* __tstate = wxPyBeginAllowThreads();
13190 (arg1)->PassMessages(arg2);
13191 wxPyEndAllowThreads(__tstate);
13192 if (PyErr_Occurred()) SWIG_fail;
13193 }
13194 resultobj = SWIG_Py_Void();
13195 return resultobj;
13196 fail:
13197 return NULL;
13198 }
13199
13200
13201 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13202 PyObject *obj;
13203 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13204 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13205 return SWIG_Py_Void();
13206 }
13207
13208 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13209 return SWIG_Python_InitShadowInstance(args);
13210 }
13211
13212 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13213 PyObject *resultobj = 0;
13214 wxLog *arg1 = (wxLog *) 0 ;
13215 wxLogChain *result = 0 ;
13216 void *argp1 = 0 ;
13217 int res1 = 0 ;
13218 PyObject * obj0 = 0 ;
13219 char * kwnames[] = {
13220 (char *) "logger", NULL
13221 };
13222
13223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13225 if (!SWIG_IsOK(res1)) {
13226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13227 }
13228 arg1 = reinterpret_cast< wxLog * >(argp1);
13229 {
13230 PyThreadState* __tstate = wxPyBeginAllowThreads();
13231 result = (wxLogChain *)new wxLogChain(arg1);
13232 wxPyEndAllowThreads(__tstate);
13233 if (PyErr_Occurred()) SWIG_fail;
13234 }
13235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13236 return resultobj;
13237 fail:
13238 return NULL;
13239 }
13240
13241
13242 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13243 PyObject *resultobj = 0;
13244 wxLogChain *arg1 = (wxLogChain *) 0 ;
13245 wxLog *arg2 = (wxLog *) 0 ;
13246 void *argp1 = 0 ;
13247 int res1 = 0 ;
13248 void *argp2 = 0 ;
13249 int res2 = 0 ;
13250 PyObject * obj0 = 0 ;
13251 PyObject * obj1 = 0 ;
13252 char * kwnames[] = {
13253 (char *) "self",(char *) "logger", NULL
13254 };
13255
13256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13258 if (!SWIG_IsOK(res1)) {
13259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13260 }
13261 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13262 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13263 if (!SWIG_IsOK(res2)) {
13264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13265 }
13266 arg2 = reinterpret_cast< wxLog * >(argp2);
13267 {
13268 PyThreadState* __tstate = wxPyBeginAllowThreads();
13269 (arg1)->SetLog(arg2);
13270 wxPyEndAllowThreads(__tstate);
13271 if (PyErr_Occurred()) SWIG_fail;
13272 }
13273 resultobj = SWIG_Py_Void();
13274 return resultobj;
13275 fail:
13276 return NULL;
13277 }
13278
13279
13280 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13281 PyObject *resultobj = 0;
13282 wxLogChain *arg1 = (wxLogChain *) 0 ;
13283 bool arg2 ;
13284 void *argp1 = 0 ;
13285 int res1 = 0 ;
13286 bool val2 ;
13287 int ecode2 = 0 ;
13288 PyObject * obj0 = 0 ;
13289 PyObject * obj1 = 0 ;
13290 char * kwnames[] = {
13291 (char *) "self",(char *) "bDoPass", NULL
13292 };
13293
13294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13296 if (!SWIG_IsOK(res1)) {
13297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13298 }
13299 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13300 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13301 if (!SWIG_IsOK(ecode2)) {
13302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13303 }
13304 arg2 = static_cast< bool >(val2);
13305 {
13306 PyThreadState* __tstate = wxPyBeginAllowThreads();
13307 (arg1)->PassMessages(arg2);
13308 wxPyEndAllowThreads(__tstate);
13309 if (PyErr_Occurred()) SWIG_fail;
13310 }
13311 resultobj = SWIG_Py_Void();
13312 return resultobj;
13313 fail:
13314 return NULL;
13315 }
13316
13317
13318 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13319 PyObject *resultobj = 0;
13320 wxLogChain *arg1 = (wxLogChain *) 0 ;
13321 bool result;
13322 void *argp1 = 0 ;
13323 int res1 = 0 ;
13324 PyObject *swig_obj[1] ;
13325
13326 if (!args) SWIG_fail;
13327 swig_obj[0] = args;
13328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13329 if (!SWIG_IsOK(res1)) {
13330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13331 }
13332 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13333 {
13334 PyThreadState* __tstate = wxPyBeginAllowThreads();
13335 result = (bool)(arg1)->IsPassingMessages();
13336 wxPyEndAllowThreads(__tstate);
13337 if (PyErr_Occurred()) SWIG_fail;
13338 }
13339 {
13340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13341 }
13342 return resultobj;
13343 fail:
13344 return NULL;
13345 }
13346
13347
13348 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13349 PyObject *resultobj = 0;
13350 wxLogChain *arg1 = (wxLogChain *) 0 ;
13351 wxLog *result = 0 ;
13352 void *argp1 = 0 ;
13353 int res1 = 0 ;
13354 PyObject *swig_obj[1] ;
13355
13356 if (!args) SWIG_fail;
13357 swig_obj[0] = args;
13358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13359 if (!SWIG_IsOK(res1)) {
13360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13361 }
13362 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13363 {
13364 PyThreadState* __tstate = wxPyBeginAllowThreads();
13365 result = (wxLog *)(arg1)->GetOldLog();
13366 wxPyEndAllowThreads(__tstate);
13367 if (PyErr_Occurred()) SWIG_fail;
13368 }
13369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13370 return resultobj;
13371 fail:
13372 return NULL;
13373 }
13374
13375
13376 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13377 PyObject *obj;
13378 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13379 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13380 return SWIG_Py_Void();
13381 }
13382
13383 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13384 return SWIG_Python_InitShadowInstance(args);
13385 }
13386
13387 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13388 PyObject *resultobj = 0;
13389 wxLogBuffer *result = 0 ;
13390
13391 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13392 {
13393 PyThreadState* __tstate = wxPyBeginAllowThreads();
13394 result = (wxLogBuffer *)new wxLogBuffer();
13395 wxPyEndAllowThreads(__tstate);
13396 if (PyErr_Occurred()) SWIG_fail;
13397 }
13398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13399 return resultobj;
13400 fail:
13401 return NULL;
13402 }
13403
13404
13405 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13406 PyObject *resultobj = 0;
13407 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13408 wxString *result = 0 ;
13409 void *argp1 = 0 ;
13410 int res1 = 0 ;
13411 PyObject *swig_obj[1] ;
13412
13413 if (!args) SWIG_fail;
13414 swig_obj[0] = args;
13415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13416 if (!SWIG_IsOK(res1)) {
13417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13418 }
13419 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13420 {
13421 PyThreadState* __tstate = wxPyBeginAllowThreads();
13422 {
13423 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13424 result = (wxString *) &_result_ref;
13425 }
13426 wxPyEndAllowThreads(__tstate);
13427 if (PyErr_Occurred()) SWIG_fail;
13428 }
13429 {
13430 #if wxUSE_UNICODE
13431 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13432 #else
13433 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13434 #endif
13435 }
13436 return resultobj;
13437 fail:
13438 return NULL;
13439 }
13440
13441
13442 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13443 PyObject *obj;
13444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13445 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13446 return SWIG_Py_Void();
13447 }
13448
13449 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13450 return SWIG_Python_InitShadowInstance(args);
13451 }
13452
13453 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13454 PyObject *resultobj = 0;
13455 unsigned long result;
13456
13457 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13458 {
13459 PyThreadState* __tstate = wxPyBeginAllowThreads();
13460 result = (unsigned long)wxSysErrorCode();
13461 wxPyEndAllowThreads(__tstate);
13462 if (PyErr_Occurred()) SWIG_fail;
13463 }
13464 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13465 return resultobj;
13466 fail:
13467 return NULL;
13468 }
13469
13470
13471 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13472 PyObject *resultobj = 0;
13473 unsigned long arg1 = (unsigned long) 0 ;
13474 wxString result;
13475 unsigned long val1 ;
13476 int ecode1 = 0 ;
13477 PyObject * obj0 = 0 ;
13478 char * kwnames[] = {
13479 (char *) "nErrCode", NULL
13480 };
13481
13482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13483 if (obj0) {
13484 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13485 if (!SWIG_IsOK(ecode1)) {
13486 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13487 }
13488 arg1 = static_cast< unsigned long >(val1);
13489 }
13490 {
13491 PyThreadState* __tstate = wxPyBeginAllowThreads();
13492 result = wxSysErrorMsg(arg1);
13493 wxPyEndAllowThreads(__tstate);
13494 if (PyErr_Occurred()) SWIG_fail;
13495 }
13496 {
13497 #if wxUSE_UNICODE
13498 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13499 #else
13500 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13501 #endif
13502 }
13503 return resultobj;
13504 fail:
13505 return NULL;
13506 }
13507
13508
13509 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13510 PyObject *resultobj = 0;
13511 wxString *arg1 = 0 ;
13512 bool temp1 = false ;
13513 PyObject * obj0 = 0 ;
13514 char * kwnames[] = {
13515 (char *) "msg", NULL
13516 };
13517
13518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13519 {
13520 arg1 = wxString_in_helper(obj0);
13521 if (arg1 == NULL) SWIG_fail;
13522 temp1 = true;
13523 }
13524 {
13525 PyThreadState* __tstate = wxPyBeginAllowThreads();
13526 wxPyLogFatalError((wxString const &)*arg1);
13527 wxPyEndAllowThreads(__tstate);
13528 if (PyErr_Occurred()) SWIG_fail;
13529 }
13530 resultobj = SWIG_Py_Void();
13531 {
13532 if (temp1)
13533 delete arg1;
13534 }
13535 return resultobj;
13536 fail:
13537 {
13538 if (temp1)
13539 delete arg1;
13540 }
13541 return NULL;
13542 }
13543
13544
13545 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13546 PyObject *resultobj = 0;
13547 wxString *arg1 = 0 ;
13548 bool temp1 = false ;
13549 PyObject * obj0 = 0 ;
13550 char * kwnames[] = {
13551 (char *) "msg", NULL
13552 };
13553
13554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13555 {
13556 arg1 = wxString_in_helper(obj0);
13557 if (arg1 == NULL) SWIG_fail;
13558 temp1 = true;
13559 }
13560 {
13561 PyThreadState* __tstate = wxPyBeginAllowThreads();
13562 wxPyLogError((wxString const &)*arg1);
13563 wxPyEndAllowThreads(__tstate);
13564 if (PyErr_Occurred()) SWIG_fail;
13565 }
13566 resultobj = SWIG_Py_Void();
13567 {
13568 if (temp1)
13569 delete arg1;
13570 }
13571 return resultobj;
13572 fail:
13573 {
13574 if (temp1)
13575 delete arg1;
13576 }
13577 return NULL;
13578 }
13579
13580
13581 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13582 PyObject *resultobj = 0;
13583 wxString *arg1 = 0 ;
13584 bool temp1 = false ;
13585 PyObject * obj0 = 0 ;
13586 char * kwnames[] = {
13587 (char *) "msg", NULL
13588 };
13589
13590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13591 {
13592 arg1 = wxString_in_helper(obj0);
13593 if (arg1 == NULL) SWIG_fail;
13594 temp1 = true;
13595 }
13596 {
13597 PyThreadState* __tstate = wxPyBeginAllowThreads();
13598 wxPyLogWarning((wxString const &)*arg1);
13599 wxPyEndAllowThreads(__tstate);
13600 if (PyErr_Occurred()) SWIG_fail;
13601 }
13602 resultobj = SWIG_Py_Void();
13603 {
13604 if (temp1)
13605 delete arg1;
13606 }
13607 return resultobj;
13608 fail:
13609 {
13610 if (temp1)
13611 delete arg1;
13612 }
13613 return NULL;
13614 }
13615
13616
13617 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13618 PyObject *resultobj = 0;
13619 wxString *arg1 = 0 ;
13620 bool temp1 = false ;
13621 PyObject * obj0 = 0 ;
13622 char * kwnames[] = {
13623 (char *) "msg", NULL
13624 };
13625
13626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13627 {
13628 arg1 = wxString_in_helper(obj0);
13629 if (arg1 == NULL) SWIG_fail;
13630 temp1 = true;
13631 }
13632 {
13633 PyThreadState* __tstate = wxPyBeginAllowThreads();
13634 wxPyLogMessage((wxString const &)*arg1);
13635 wxPyEndAllowThreads(__tstate);
13636 if (PyErr_Occurred()) SWIG_fail;
13637 }
13638 resultobj = SWIG_Py_Void();
13639 {
13640 if (temp1)
13641 delete arg1;
13642 }
13643 return resultobj;
13644 fail:
13645 {
13646 if (temp1)
13647 delete arg1;
13648 }
13649 return NULL;
13650 }
13651
13652
13653 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13654 PyObject *resultobj = 0;
13655 wxString *arg1 = 0 ;
13656 bool temp1 = false ;
13657 PyObject * obj0 = 0 ;
13658 char * kwnames[] = {
13659 (char *) "msg", NULL
13660 };
13661
13662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13663 {
13664 arg1 = wxString_in_helper(obj0);
13665 if (arg1 == NULL) SWIG_fail;
13666 temp1 = true;
13667 }
13668 {
13669 PyThreadState* __tstate = wxPyBeginAllowThreads();
13670 wxPyLogInfo((wxString const &)*arg1);
13671 wxPyEndAllowThreads(__tstate);
13672 if (PyErr_Occurred()) SWIG_fail;
13673 }
13674 resultobj = SWIG_Py_Void();
13675 {
13676 if (temp1)
13677 delete arg1;
13678 }
13679 return resultobj;
13680 fail:
13681 {
13682 if (temp1)
13683 delete arg1;
13684 }
13685 return NULL;
13686 }
13687
13688
13689 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13690 PyObject *resultobj = 0;
13691 wxString *arg1 = 0 ;
13692 bool temp1 = false ;
13693 PyObject * obj0 = 0 ;
13694 char * kwnames[] = {
13695 (char *) "msg", NULL
13696 };
13697
13698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13699 {
13700 arg1 = wxString_in_helper(obj0);
13701 if (arg1 == NULL) SWIG_fail;
13702 temp1 = true;
13703 }
13704 {
13705 PyThreadState* __tstate = wxPyBeginAllowThreads();
13706 wxPyLogDebug((wxString const &)*arg1);
13707 wxPyEndAllowThreads(__tstate);
13708 if (PyErr_Occurred()) SWIG_fail;
13709 }
13710 resultobj = SWIG_Py_Void();
13711 {
13712 if (temp1)
13713 delete arg1;
13714 }
13715 return resultobj;
13716 fail:
13717 {
13718 if (temp1)
13719 delete arg1;
13720 }
13721 return NULL;
13722 }
13723
13724
13725 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13726 PyObject *resultobj = 0;
13727 wxString *arg1 = 0 ;
13728 bool temp1 = false ;
13729 PyObject * obj0 = 0 ;
13730 char * kwnames[] = {
13731 (char *) "msg", NULL
13732 };
13733
13734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13735 {
13736 arg1 = wxString_in_helper(obj0);
13737 if (arg1 == NULL) SWIG_fail;
13738 temp1 = true;
13739 }
13740 {
13741 PyThreadState* __tstate = wxPyBeginAllowThreads();
13742 wxPyLogVerbose((wxString const &)*arg1);
13743 wxPyEndAllowThreads(__tstate);
13744 if (PyErr_Occurred()) SWIG_fail;
13745 }
13746 resultobj = SWIG_Py_Void();
13747 {
13748 if (temp1)
13749 delete arg1;
13750 }
13751 return resultobj;
13752 fail:
13753 {
13754 if (temp1)
13755 delete arg1;
13756 }
13757 return NULL;
13758 }
13759
13760
13761 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13762 PyObject *resultobj = 0;
13763 wxString *arg1 = 0 ;
13764 bool temp1 = false ;
13765 PyObject * obj0 = 0 ;
13766 char * kwnames[] = {
13767 (char *) "msg", NULL
13768 };
13769
13770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13771 {
13772 arg1 = wxString_in_helper(obj0);
13773 if (arg1 == NULL) SWIG_fail;
13774 temp1 = true;
13775 }
13776 {
13777 PyThreadState* __tstate = wxPyBeginAllowThreads();
13778 wxPyLogStatus((wxString const &)*arg1);
13779 wxPyEndAllowThreads(__tstate);
13780 if (PyErr_Occurred()) SWIG_fail;
13781 }
13782 resultobj = SWIG_Py_Void();
13783 {
13784 if (temp1)
13785 delete arg1;
13786 }
13787 return resultobj;
13788 fail:
13789 {
13790 if (temp1)
13791 delete arg1;
13792 }
13793 return NULL;
13794 }
13795
13796
13797 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13798 PyObject *resultobj = 0;
13799 wxFrame *arg1 = (wxFrame *) 0 ;
13800 wxString *arg2 = 0 ;
13801 void *argp1 = 0 ;
13802 int res1 = 0 ;
13803 bool temp2 = false ;
13804 PyObject * obj0 = 0 ;
13805 PyObject * obj1 = 0 ;
13806 char * kwnames[] = {
13807 (char *) "pFrame",(char *) "msg", NULL
13808 };
13809
13810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13812 if (!SWIG_IsOK(res1)) {
13813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13814 }
13815 arg1 = reinterpret_cast< wxFrame * >(argp1);
13816 {
13817 arg2 = wxString_in_helper(obj1);
13818 if (arg2 == NULL) SWIG_fail;
13819 temp2 = true;
13820 }
13821 {
13822 PyThreadState* __tstate = wxPyBeginAllowThreads();
13823 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13824 wxPyEndAllowThreads(__tstate);
13825 if (PyErr_Occurred()) SWIG_fail;
13826 }
13827 resultobj = SWIG_Py_Void();
13828 {
13829 if (temp2)
13830 delete arg2;
13831 }
13832 return resultobj;
13833 fail:
13834 {
13835 if (temp2)
13836 delete arg2;
13837 }
13838 return NULL;
13839 }
13840
13841
13842 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13843 PyObject *resultobj = 0;
13844 wxString *arg1 = 0 ;
13845 bool temp1 = false ;
13846 PyObject * obj0 = 0 ;
13847 char * kwnames[] = {
13848 (char *) "msg", NULL
13849 };
13850
13851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13852 {
13853 arg1 = wxString_in_helper(obj0);
13854 if (arg1 == NULL) SWIG_fail;
13855 temp1 = true;
13856 }
13857 {
13858 PyThreadState* __tstate = wxPyBeginAllowThreads();
13859 wxPyLogSysError((wxString const &)*arg1);
13860 wxPyEndAllowThreads(__tstate);
13861 if (PyErr_Occurred()) SWIG_fail;
13862 }
13863 resultobj = SWIG_Py_Void();
13864 {
13865 if (temp1)
13866 delete arg1;
13867 }
13868 return resultobj;
13869 fail:
13870 {
13871 if (temp1)
13872 delete arg1;
13873 }
13874 return NULL;
13875 }
13876
13877
13878 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13879 PyObject *resultobj = 0;
13880 unsigned long arg1 ;
13881 wxString *arg2 = 0 ;
13882 unsigned long val1 ;
13883 int ecode1 = 0 ;
13884 bool temp2 = false ;
13885 PyObject * obj0 = 0 ;
13886 PyObject * obj1 = 0 ;
13887 char * kwnames[] = {
13888 (char *) "level",(char *) "msg", NULL
13889 };
13890
13891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13892 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13893 if (!SWIG_IsOK(ecode1)) {
13894 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13895 }
13896 arg1 = static_cast< unsigned long >(val1);
13897 {
13898 arg2 = wxString_in_helper(obj1);
13899 if (arg2 == NULL) SWIG_fail;
13900 temp2 = true;
13901 }
13902 {
13903 PyThreadState* __tstate = wxPyBeginAllowThreads();
13904 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13905 wxPyEndAllowThreads(__tstate);
13906 if (PyErr_Occurred()) SWIG_fail;
13907 }
13908 resultobj = SWIG_Py_Void();
13909 {
13910 if (temp2)
13911 delete arg2;
13912 }
13913 return resultobj;
13914 fail:
13915 {
13916 if (temp2)
13917 delete arg2;
13918 }
13919 return NULL;
13920 }
13921
13922
13923 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13924 PyObject *resultobj = 0;
13925 unsigned long arg1 ;
13926 wxString *arg2 = 0 ;
13927 unsigned long val1 ;
13928 int ecode1 = 0 ;
13929 bool temp2 = false ;
13930
13931 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13932 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13933 if (!SWIG_IsOK(ecode1)) {
13934 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13935 }
13936 arg1 = static_cast< unsigned long >(val1);
13937 {
13938 arg2 = wxString_in_helper(swig_obj[1]);
13939 if (arg2 == NULL) SWIG_fail;
13940 temp2 = true;
13941 }
13942 {
13943 PyThreadState* __tstate = wxPyBeginAllowThreads();
13944 wxPyLogTrace(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_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13964 PyObject *resultobj = 0;
13965 wxString *arg1 = 0 ;
13966 wxString *arg2 = 0 ;
13967 bool temp1 = false ;
13968 bool temp2 = false ;
13969
13970 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13971 {
13972 arg1 = wxString_in_helper(swig_obj[0]);
13973 if (arg1 == NULL) SWIG_fail;
13974 temp1 = true;
13975 }
13976 {
13977 arg2 = wxString_in_helper(swig_obj[1]);
13978 if (arg2 == NULL) SWIG_fail;
13979 temp2 = true;
13980 }
13981 {
13982 PyThreadState* __tstate = wxPyBeginAllowThreads();
13983 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
13984 wxPyEndAllowThreads(__tstate);
13985 if (PyErr_Occurred()) SWIG_fail;
13986 }
13987 resultobj = SWIG_Py_Void();
13988 {
13989 if (temp1)
13990 delete arg1;
13991 }
13992 {
13993 if (temp2)
13994 delete arg2;
13995 }
13996 return resultobj;
13997 fail:
13998 {
13999 if (temp1)
14000 delete arg1;
14001 }
14002 {
14003 if (temp2)
14004 delete arg2;
14005 }
14006 return NULL;
14007 }
14008
14009
14010 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14011 int argc;
14012 PyObject *argv[3];
14013
14014 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14015 --argc;
14016 if (argc == 2) {
14017 int _v = 0;
14018 {
14019 {
14020 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14021 }
14022 }
14023 if (!_v) goto check_1;
14024 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14025 }
14026 check_1:
14027
14028 if (argc == 2) {
14029 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14030 }
14031
14032 fail:
14033 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14034 return NULL;
14035 }
14036
14037
14038 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14039 PyObject *resultobj = 0;
14040 wxString *arg1 = 0 ;
14041 wxString *arg2 = 0 ;
14042 bool temp1 = false ;
14043 bool temp2 = false ;
14044 PyObject * obj0 = 0 ;
14045 PyObject * obj1 = 0 ;
14046 char * kwnames[] = {
14047 (char *) "title",(char *) "text", NULL
14048 };
14049
14050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14051 {
14052 arg1 = wxString_in_helper(obj0);
14053 if (arg1 == NULL) SWIG_fail;
14054 temp1 = true;
14055 }
14056 {
14057 arg2 = wxString_in_helper(obj1);
14058 if (arg2 == NULL) SWIG_fail;
14059 temp2 = true;
14060 }
14061 {
14062 PyThreadState* __tstate = wxPyBeginAllowThreads();
14063 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14064 wxPyEndAllowThreads(__tstate);
14065 if (PyErr_Occurred()) SWIG_fail;
14066 }
14067 resultobj = SWIG_Py_Void();
14068 {
14069 if (temp1)
14070 delete arg1;
14071 }
14072 {
14073 if (temp2)
14074 delete arg2;
14075 }
14076 return resultobj;
14077 fail:
14078 {
14079 if (temp1)
14080 delete arg1;
14081 }
14082 {
14083 if (temp2)
14084 delete arg2;
14085 }
14086 return NULL;
14087 }
14088
14089
14090 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14091 PyObject *resultobj = 0;
14092 wxLogNull *result = 0 ;
14093
14094 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14095 {
14096 PyThreadState* __tstate = wxPyBeginAllowThreads();
14097 result = (wxLogNull *)new wxLogNull();
14098 wxPyEndAllowThreads(__tstate);
14099 if (PyErr_Occurred()) SWIG_fail;
14100 }
14101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14102 return resultobj;
14103 fail:
14104 return NULL;
14105 }
14106
14107
14108 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14109 PyObject *resultobj = 0;
14110 wxLogNull *arg1 = (wxLogNull *) 0 ;
14111 void *argp1 = 0 ;
14112 int res1 = 0 ;
14113 PyObject *swig_obj[1] ;
14114
14115 if (!args) SWIG_fail;
14116 swig_obj[0] = args;
14117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14118 if (!SWIG_IsOK(res1)) {
14119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14120 }
14121 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14122 {
14123 PyThreadState* __tstate = wxPyBeginAllowThreads();
14124 delete arg1;
14125
14126 wxPyEndAllowThreads(__tstate);
14127 if (PyErr_Occurred()) SWIG_fail;
14128 }
14129 resultobj = SWIG_Py_Void();
14130 return resultobj;
14131 fail:
14132 return NULL;
14133 }
14134
14135
14136 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14137 PyObject *obj;
14138 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14139 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14140 return SWIG_Py_Void();
14141 }
14142
14143 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14144 return SWIG_Python_InitShadowInstance(args);
14145 }
14146
14147 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14148 PyObject *resultobj = 0;
14149 wxPyLog *result = 0 ;
14150
14151 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14152 {
14153 PyThreadState* __tstate = wxPyBeginAllowThreads();
14154 result = (wxPyLog *)new wxPyLog();
14155 wxPyEndAllowThreads(__tstate);
14156 if (PyErr_Occurred()) SWIG_fail;
14157 }
14158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14159 return resultobj;
14160 fail:
14161 return NULL;
14162 }
14163
14164
14165 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14166 PyObject *resultobj = 0;
14167 wxPyLog *arg1 = (wxPyLog *) 0 ;
14168 PyObject *arg2 = (PyObject *) 0 ;
14169 PyObject *arg3 = (PyObject *) 0 ;
14170 void *argp1 = 0 ;
14171 int res1 = 0 ;
14172 PyObject * obj0 = 0 ;
14173 PyObject * obj1 = 0 ;
14174 PyObject * obj2 = 0 ;
14175 char * kwnames[] = {
14176 (char *) "self",(char *) "self",(char *) "_class", NULL
14177 };
14178
14179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14181 if (!SWIG_IsOK(res1)) {
14182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14183 }
14184 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14185 arg2 = obj1;
14186 arg3 = obj2;
14187 {
14188 PyThreadState* __tstate = wxPyBeginAllowThreads();
14189 (arg1)->_setCallbackInfo(arg2,arg3);
14190 wxPyEndAllowThreads(__tstate);
14191 if (PyErr_Occurred()) SWIG_fail;
14192 }
14193 resultobj = SWIG_Py_Void();
14194 return resultobj;
14195 fail:
14196 return NULL;
14197 }
14198
14199
14200 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14201 PyObject *obj;
14202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14203 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14204 return SWIG_Py_Void();
14205 }
14206
14207 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14208 return SWIG_Python_InitShadowInstance(args);
14209 }
14210
14211 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14212 PyObject *resultobj = 0;
14213 int arg1 ;
14214 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14215 int arg3 = (int) wxKILL_NOCHILDREN ;
14216 wxKillError result;
14217 int val1 ;
14218 int ecode1 = 0 ;
14219 int val2 ;
14220 int ecode2 = 0 ;
14221 int val3 ;
14222 int ecode3 = 0 ;
14223 PyObject * obj0 = 0 ;
14224 PyObject * obj1 = 0 ;
14225 PyObject * obj2 = 0 ;
14226 char * kwnames[] = {
14227 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14228 };
14229
14230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14231 ecode1 = SWIG_AsVal_int(obj0, &val1);
14232 if (!SWIG_IsOK(ecode1)) {
14233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14234 }
14235 arg1 = static_cast< int >(val1);
14236 if (obj1) {
14237 ecode2 = SWIG_AsVal_int(obj1, &val2);
14238 if (!SWIG_IsOK(ecode2)) {
14239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14240 }
14241 arg2 = static_cast< wxSignal >(val2);
14242 }
14243 if (obj2) {
14244 ecode3 = SWIG_AsVal_int(obj2, &val3);
14245 if (!SWIG_IsOK(ecode3)) {
14246 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14247 }
14248 arg3 = static_cast< int >(val3);
14249 }
14250 {
14251 PyThreadState* __tstate = wxPyBeginAllowThreads();
14252 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14253 wxPyEndAllowThreads(__tstate);
14254 if (PyErr_Occurred()) SWIG_fail;
14255 }
14256 resultobj = SWIG_From_int(static_cast< int >(result));
14257 return resultobj;
14258 fail:
14259 return NULL;
14260 }
14261
14262
14263 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14264 PyObject *resultobj = 0;
14265 int arg1 ;
14266 bool result;
14267 int val1 ;
14268 int ecode1 = 0 ;
14269 PyObject * obj0 = 0 ;
14270 char * kwnames[] = {
14271 (char *) "pid", NULL
14272 };
14273
14274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14275 ecode1 = SWIG_AsVal_int(obj0, &val1);
14276 if (!SWIG_IsOK(ecode1)) {
14277 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14278 }
14279 arg1 = static_cast< int >(val1);
14280 {
14281 PyThreadState* __tstate = wxPyBeginAllowThreads();
14282 result = (bool)wxPyProcess::Exists(arg1);
14283 wxPyEndAllowThreads(__tstate);
14284 if (PyErr_Occurred()) SWIG_fail;
14285 }
14286 {
14287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14288 }
14289 return resultobj;
14290 fail:
14291 return NULL;
14292 }
14293
14294
14295 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14296 PyObject *resultobj = 0;
14297 wxString *arg1 = 0 ;
14298 int arg2 = (int) wxEXEC_ASYNC ;
14299 wxPyProcess *result = 0 ;
14300 bool temp1 = false ;
14301 int val2 ;
14302 int ecode2 = 0 ;
14303 PyObject * obj0 = 0 ;
14304 PyObject * obj1 = 0 ;
14305 char * kwnames[] = {
14306 (char *) "cmd",(char *) "flags", NULL
14307 };
14308
14309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14310 {
14311 arg1 = wxString_in_helper(obj0);
14312 if (arg1 == NULL) SWIG_fail;
14313 temp1 = true;
14314 }
14315 if (obj1) {
14316 ecode2 = SWIG_AsVal_int(obj1, &val2);
14317 if (!SWIG_IsOK(ecode2)) {
14318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14319 }
14320 arg2 = static_cast< int >(val2);
14321 }
14322 {
14323 PyThreadState* __tstate = wxPyBeginAllowThreads();
14324 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14325 wxPyEndAllowThreads(__tstate);
14326 if (PyErr_Occurred()) SWIG_fail;
14327 }
14328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14329 {
14330 if (temp1)
14331 delete arg1;
14332 }
14333 return resultobj;
14334 fail:
14335 {
14336 if (temp1)
14337 delete arg1;
14338 }
14339 return NULL;
14340 }
14341
14342
14343 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14344 PyObject *resultobj = 0;
14345 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14346 int arg2 = (int) -1 ;
14347 wxPyProcess *result = 0 ;
14348 void *argp1 = 0 ;
14349 int res1 = 0 ;
14350 int val2 ;
14351 int ecode2 = 0 ;
14352 PyObject * obj0 = 0 ;
14353 PyObject * obj1 = 0 ;
14354 char * kwnames[] = {
14355 (char *) "parent",(char *) "id", NULL
14356 };
14357
14358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14359 if (obj0) {
14360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14361 if (!SWIG_IsOK(res1)) {
14362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14363 }
14364 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14365 }
14366 if (obj1) {
14367 ecode2 = SWIG_AsVal_int(obj1, &val2);
14368 if (!SWIG_IsOK(ecode2)) {
14369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14370 }
14371 arg2 = static_cast< int >(val2);
14372 }
14373 {
14374 PyThreadState* __tstate = wxPyBeginAllowThreads();
14375 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14376 wxPyEndAllowThreads(__tstate);
14377 if (PyErr_Occurred()) SWIG_fail;
14378 }
14379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14380 return resultobj;
14381 fail:
14382 return NULL;
14383 }
14384
14385
14386 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14387 PyObject *resultobj = 0;
14388 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14389 PyObject *arg2 = (PyObject *) 0 ;
14390 PyObject *arg3 = (PyObject *) 0 ;
14391 void *argp1 = 0 ;
14392 int res1 = 0 ;
14393 PyObject * obj0 = 0 ;
14394 PyObject * obj1 = 0 ;
14395 PyObject * obj2 = 0 ;
14396 char * kwnames[] = {
14397 (char *) "self",(char *) "self",(char *) "_class", NULL
14398 };
14399
14400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14402 if (!SWIG_IsOK(res1)) {
14403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14404 }
14405 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14406 arg2 = obj1;
14407 arg3 = obj2;
14408 {
14409 PyThreadState* __tstate = wxPyBeginAllowThreads();
14410 (arg1)->_setCallbackInfo(arg2,arg3);
14411 wxPyEndAllowThreads(__tstate);
14412 if (PyErr_Occurred()) SWIG_fail;
14413 }
14414 resultobj = SWIG_Py_Void();
14415 return resultobj;
14416 fail:
14417 return NULL;
14418 }
14419
14420
14421 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14422 PyObject *resultobj = 0;
14423 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14424 int arg2 ;
14425 int arg3 ;
14426 void *argp1 = 0 ;
14427 int res1 = 0 ;
14428 int val2 ;
14429 int ecode2 = 0 ;
14430 int val3 ;
14431 int ecode3 = 0 ;
14432 PyObject * obj0 = 0 ;
14433 PyObject * obj1 = 0 ;
14434 PyObject * obj2 = 0 ;
14435 char * kwnames[] = {
14436 (char *) "self",(char *) "pid",(char *) "status", NULL
14437 };
14438
14439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14441 if (!SWIG_IsOK(res1)) {
14442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14443 }
14444 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14445 ecode2 = SWIG_AsVal_int(obj1, &val2);
14446 if (!SWIG_IsOK(ecode2)) {
14447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14448 }
14449 arg2 = static_cast< int >(val2);
14450 ecode3 = SWIG_AsVal_int(obj2, &val3);
14451 if (!SWIG_IsOK(ecode3)) {
14452 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14453 }
14454 arg3 = static_cast< int >(val3);
14455 {
14456 PyThreadState* __tstate = wxPyBeginAllowThreads();
14457 (arg1)->OnTerminate(arg2,arg3);
14458 wxPyEndAllowThreads(__tstate);
14459 if (PyErr_Occurred()) SWIG_fail;
14460 }
14461 resultobj = SWIG_Py_Void();
14462 return resultobj;
14463 fail:
14464 return NULL;
14465 }
14466
14467
14468 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14469 PyObject *resultobj = 0;
14470 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14471 void *argp1 = 0 ;
14472 int res1 = 0 ;
14473 PyObject *swig_obj[1] ;
14474
14475 if (!args) SWIG_fail;
14476 swig_obj[0] = args;
14477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14478 if (!SWIG_IsOK(res1)) {
14479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14480 }
14481 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14482 {
14483 PyThreadState* __tstate = wxPyBeginAllowThreads();
14484 (arg1)->Redirect();
14485 wxPyEndAllowThreads(__tstate);
14486 if (PyErr_Occurred()) SWIG_fail;
14487 }
14488 resultobj = SWIG_Py_Void();
14489 return resultobj;
14490 fail:
14491 return NULL;
14492 }
14493
14494
14495 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14496 PyObject *resultobj = 0;
14497 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14498 bool result;
14499 void *argp1 = 0 ;
14500 int res1 = 0 ;
14501 PyObject *swig_obj[1] ;
14502
14503 if (!args) SWIG_fail;
14504 swig_obj[0] = args;
14505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14506 if (!SWIG_IsOK(res1)) {
14507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14508 }
14509 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14510 {
14511 PyThreadState* __tstate = wxPyBeginAllowThreads();
14512 result = (bool)(arg1)->IsRedirected();
14513 wxPyEndAllowThreads(__tstate);
14514 if (PyErr_Occurred()) SWIG_fail;
14515 }
14516 {
14517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14518 }
14519 return resultobj;
14520 fail:
14521 return NULL;
14522 }
14523
14524
14525 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14526 PyObject *resultobj = 0;
14527 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14528 void *argp1 = 0 ;
14529 int res1 = 0 ;
14530 PyObject *swig_obj[1] ;
14531
14532 if (!args) SWIG_fail;
14533 swig_obj[0] = args;
14534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14535 if (!SWIG_IsOK(res1)) {
14536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14537 }
14538 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14539 {
14540 PyThreadState* __tstate = wxPyBeginAllowThreads();
14541 (arg1)->Detach();
14542 wxPyEndAllowThreads(__tstate);
14543 if (PyErr_Occurred()) SWIG_fail;
14544 }
14545 resultobj = SWIG_Py_Void();
14546 return resultobj;
14547 fail:
14548 return NULL;
14549 }
14550
14551
14552 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14553 PyObject *resultobj = 0;
14554 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14555 wxInputStream *result = 0 ;
14556 void *argp1 = 0 ;
14557 int res1 = 0 ;
14558 PyObject *swig_obj[1] ;
14559
14560 if (!args) SWIG_fail;
14561 swig_obj[0] = args;
14562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14563 if (!SWIG_IsOK(res1)) {
14564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14565 }
14566 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14567 {
14568 PyThreadState* __tstate = wxPyBeginAllowThreads();
14569 result = (wxInputStream *)(arg1)->GetInputStream();
14570 wxPyEndAllowThreads(__tstate);
14571 if (PyErr_Occurred()) SWIG_fail;
14572 }
14573 {
14574 wxPyInputStream * _ptr = NULL;
14575
14576 if (result) {
14577 _ptr = new wxPyInputStream(result);
14578 }
14579 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14580 }
14581 return resultobj;
14582 fail:
14583 return NULL;
14584 }
14585
14586
14587 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14588 PyObject *resultobj = 0;
14589 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14590 wxInputStream *result = 0 ;
14591 void *argp1 = 0 ;
14592 int res1 = 0 ;
14593 PyObject *swig_obj[1] ;
14594
14595 if (!args) SWIG_fail;
14596 swig_obj[0] = args;
14597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14598 if (!SWIG_IsOK(res1)) {
14599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14600 }
14601 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14602 {
14603 PyThreadState* __tstate = wxPyBeginAllowThreads();
14604 result = (wxInputStream *)(arg1)->GetErrorStream();
14605 wxPyEndAllowThreads(__tstate);
14606 if (PyErr_Occurred()) SWIG_fail;
14607 }
14608 {
14609 wxPyInputStream * _ptr = NULL;
14610
14611 if (result) {
14612 _ptr = new wxPyInputStream(result);
14613 }
14614 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14615 }
14616 return resultobj;
14617 fail:
14618 return NULL;
14619 }
14620
14621
14622 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14623 PyObject *resultobj = 0;
14624 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14625 wxOutputStream *result = 0 ;
14626 void *argp1 = 0 ;
14627 int res1 = 0 ;
14628 PyObject *swig_obj[1] ;
14629
14630 if (!args) SWIG_fail;
14631 swig_obj[0] = args;
14632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14633 if (!SWIG_IsOK(res1)) {
14634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14635 }
14636 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14637 {
14638 PyThreadState* __tstate = wxPyBeginAllowThreads();
14639 result = (wxOutputStream *)(arg1)->GetOutputStream();
14640 wxPyEndAllowThreads(__tstate);
14641 if (PyErr_Occurred()) SWIG_fail;
14642 }
14643 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14644 return resultobj;
14645 fail:
14646 return NULL;
14647 }
14648
14649
14650 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14651 PyObject *resultobj = 0;
14652 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14653 void *argp1 = 0 ;
14654 int res1 = 0 ;
14655 PyObject *swig_obj[1] ;
14656
14657 if (!args) SWIG_fail;
14658 swig_obj[0] = args;
14659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14660 if (!SWIG_IsOK(res1)) {
14661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14662 }
14663 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14664 {
14665 PyThreadState* __tstate = wxPyBeginAllowThreads();
14666 (arg1)->CloseOutput();
14667 wxPyEndAllowThreads(__tstate);
14668 if (PyErr_Occurred()) SWIG_fail;
14669 }
14670 resultobj = SWIG_Py_Void();
14671 return resultobj;
14672 fail:
14673 return NULL;
14674 }
14675
14676
14677 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14678 PyObject *resultobj = 0;
14679 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14680 bool result;
14681 void *argp1 = 0 ;
14682 int res1 = 0 ;
14683 PyObject *swig_obj[1] ;
14684
14685 if (!args) SWIG_fail;
14686 swig_obj[0] = args;
14687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14688 if (!SWIG_IsOK(res1)) {
14689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14690 }
14691 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14692 {
14693 PyThreadState* __tstate = wxPyBeginAllowThreads();
14694 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14695 wxPyEndAllowThreads(__tstate);
14696 if (PyErr_Occurred()) SWIG_fail;
14697 }
14698 {
14699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14700 }
14701 return resultobj;
14702 fail:
14703 return NULL;
14704 }
14705
14706
14707 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14708 PyObject *resultobj = 0;
14709 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14710 bool result;
14711 void *argp1 = 0 ;
14712 int res1 = 0 ;
14713 PyObject *swig_obj[1] ;
14714
14715 if (!args) SWIG_fail;
14716 swig_obj[0] = args;
14717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14718 if (!SWIG_IsOK(res1)) {
14719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14720 }
14721 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14722 {
14723 PyThreadState* __tstate = wxPyBeginAllowThreads();
14724 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14725 wxPyEndAllowThreads(__tstate);
14726 if (PyErr_Occurred()) SWIG_fail;
14727 }
14728 {
14729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14730 }
14731 return resultobj;
14732 fail:
14733 return NULL;
14734 }
14735
14736
14737 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14738 PyObject *resultobj = 0;
14739 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14740 bool result;
14741 void *argp1 = 0 ;
14742 int res1 = 0 ;
14743 PyObject *swig_obj[1] ;
14744
14745 if (!args) SWIG_fail;
14746 swig_obj[0] = args;
14747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14748 if (!SWIG_IsOK(res1)) {
14749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14750 }
14751 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14752 {
14753 PyThreadState* __tstate = wxPyBeginAllowThreads();
14754 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14755 wxPyEndAllowThreads(__tstate);
14756 if (PyErr_Occurred()) SWIG_fail;
14757 }
14758 {
14759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14760 }
14761 return resultobj;
14762 fail:
14763 return NULL;
14764 }
14765
14766
14767 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14768 PyObject *obj;
14769 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14770 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14771 return SWIG_Py_Void();
14772 }
14773
14774 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14775 return SWIG_Python_InitShadowInstance(args);
14776 }
14777
14778 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14779 PyObject *resultobj = 0;
14780 int arg1 = (int) 0 ;
14781 int arg2 = (int) 0 ;
14782 int arg3 = (int) 0 ;
14783 wxProcessEvent *result = 0 ;
14784 int val1 ;
14785 int ecode1 = 0 ;
14786 int val2 ;
14787 int ecode2 = 0 ;
14788 int val3 ;
14789 int ecode3 = 0 ;
14790 PyObject * obj0 = 0 ;
14791 PyObject * obj1 = 0 ;
14792 PyObject * obj2 = 0 ;
14793 char * kwnames[] = {
14794 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14795 };
14796
14797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14798 if (obj0) {
14799 ecode1 = SWIG_AsVal_int(obj0, &val1);
14800 if (!SWIG_IsOK(ecode1)) {
14801 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14802 }
14803 arg1 = static_cast< int >(val1);
14804 }
14805 if (obj1) {
14806 ecode2 = SWIG_AsVal_int(obj1, &val2);
14807 if (!SWIG_IsOK(ecode2)) {
14808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14809 }
14810 arg2 = static_cast< int >(val2);
14811 }
14812 if (obj2) {
14813 ecode3 = SWIG_AsVal_int(obj2, &val3);
14814 if (!SWIG_IsOK(ecode3)) {
14815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14816 }
14817 arg3 = static_cast< int >(val3);
14818 }
14819 {
14820 PyThreadState* __tstate = wxPyBeginAllowThreads();
14821 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14822 wxPyEndAllowThreads(__tstate);
14823 if (PyErr_Occurred()) SWIG_fail;
14824 }
14825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14826 return resultobj;
14827 fail:
14828 return NULL;
14829 }
14830
14831
14832 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14833 PyObject *resultobj = 0;
14834 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14835 int result;
14836 void *argp1 = 0 ;
14837 int res1 = 0 ;
14838 PyObject *swig_obj[1] ;
14839
14840 if (!args) SWIG_fail;
14841 swig_obj[0] = args;
14842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14843 if (!SWIG_IsOK(res1)) {
14844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14845 }
14846 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14847 {
14848 PyThreadState* __tstate = wxPyBeginAllowThreads();
14849 result = (int)(arg1)->GetPid();
14850 wxPyEndAllowThreads(__tstate);
14851 if (PyErr_Occurred()) SWIG_fail;
14852 }
14853 resultobj = SWIG_From_int(static_cast< int >(result));
14854 return resultobj;
14855 fail:
14856 return NULL;
14857 }
14858
14859
14860 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14861 PyObject *resultobj = 0;
14862 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14863 int result;
14864 void *argp1 = 0 ;
14865 int res1 = 0 ;
14866 PyObject *swig_obj[1] ;
14867
14868 if (!args) SWIG_fail;
14869 swig_obj[0] = args;
14870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14871 if (!SWIG_IsOK(res1)) {
14872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14873 }
14874 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14875 {
14876 PyThreadState* __tstate = wxPyBeginAllowThreads();
14877 result = (int)(arg1)->GetExitCode();
14878 wxPyEndAllowThreads(__tstate);
14879 if (PyErr_Occurred()) SWIG_fail;
14880 }
14881 resultobj = SWIG_From_int(static_cast< int >(result));
14882 return resultobj;
14883 fail:
14884 return NULL;
14885 }
14886
14887
14888 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14889 PyObject *resultobj = 0;
14890 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14891 int arg2 ;
14892 void *argp1 = 0 ;
14893 int res1 = 0 ;
14894 int val2 ;
14895 int ecode2 = 0 ;
14896 PyObject *swig_obj[2] ;
14897
14898 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14900 if (!SWIG_IsOK(res1)) {
14901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14902 }
14903 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14904 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14905 if (!SWIG_IsOK(ecode2)) {
14906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14907 }
14908 arg2 = static_cast< int >(val2);
14909 if (arg1) (arg1)->m_pid = arg2;
14910
14911 resultobj = SWIG_Py_Void();
14912 return resultobj;
14913 fail:
14914 return NULL;
14915 }
14916
14917
14918 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14919 PyObject *resultobj = 0;
14920 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14921 int result;
14922 void *argp1 = 0 ;
14923 int res1 = 0 ;
14924 PyObject *swig_obj[1] ;
14925
14926 if (!args) SWIG_fail;
14927 swig_obj[0] = args;
14928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14929 if (!SWIG_IsOK(res1)) {
14930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14931 }
14932 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14933 result = (int) ((arg1)->m_pid);
14934 resultobj = SWIG_From_int(static_cast< int >(result));
14935 return resultobj;
14936 fail:
14937 return NULL;
14938 }
14939
14940
14941 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14942 PyObject *resultobj = 0;
14943 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14944 int arg2 ;
14945 void *argp1 = 0 ;
14946 int res1 = 0 ;
14947 int val2 ;
14948 int ecode2 = 0 ;
14949 PyObject *swig_obj[2] ;
14950
14951 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
14952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14953 if (!SWIG_IsOK(res1)) {
14954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14955 }
14956 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14957 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14958 if (!SWIG_IsOK(ecode2)) {
14959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
14960 }
14961 arg2 = static_cast< int >(val2);
14962 if (arg1) (arg1)->m_exitcode = arg2;
14963
14964 resultobj = SWIG_Py_Void();
14965 return resultobj;
14966 fail:
14967 return NULL;
14968 }
14969
14970
14971 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14972 PyObject *resultobj = 0;
14973 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14974 int result;
14975 void *argp1 = 0 ;
14976 int res1 = 0 ;
14977 PyObject *swig_obj[1] ;
14978
14979 if (!args) SWIG_fail;
14980 swig_obj[0] = args;
14981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14982 if (!SWIG_IsOK(res1)) {
14983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14984 }
14985 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14986 result = (int) ((arg1)->m_exitcode);
14987 resultobj = SWIG_From_int(static_cast< int >(result));
14988 return resultobj;
14989 fail:
14990 return NULL;
14991 }
14992
14993
14994 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14995 PyObject *obj;
14996 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14997 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
14998 return SWIG_Py_Void();
14999 }
15000
15001 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15002 return SWIG_Python_InitShadowInstance(args);
15003 }
15004
15005 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15006 PyObject *resultobj = 0;
15007 wxString *arg1 = 0 ;
15008 int arg2 = (int) wxEXEC_ASYNC ;
15009 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15010 long result;
15011 bool temp1 = false ;
15012 int val2 ;
15013 int ecode2 = 0 ;
15014 void *argp3 = 0 ;
15015 int res3 = 0 ;
15016 PyObject * obj0 = 0 ;
15017 PyObject * obj1 = 0 ;
15018 PyObject * obj2 = 0 ;
15019 char * kwnames[] = {
15020 (char *) "command",(char *) "flags",(char *) "process", NULL
15021 };
15022
15023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15024 {
15025 arg1 = wxString_in_helper(obj0);
15026 if (arg1 == NULL) SWIG_fail;
15027 temp1 = true;
15028 }
15029 if (obj1) {
15030 ecode2 = SWIG_AsVal_int(obj1, &val2);
15031 if (!SWIG_IsOK(ecode2)) {
15032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15033 }
15034 arg2 = static_cast< int >(val2);
15035 }
15036 if (obj2) {
15037 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15038 if (!SWIG_IsOK(res3)) {
15039 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15040 }
15041 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15042 }
15043 {
15044 if (!wxPyCheckForApp()) SWIG_fail;
15045 PyThreadState* __tstate = wxPyBeginAllowThreads();
15046 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15047 wxPyEndAllowThreads(__tstate);
15048 if (PyErr_Occurred()) SWIG_fail;
15049 }
15050 resultobj = SWIG_From_long(static_cast< long >(result));
15051 {
15052 if (temp1)
15053 delete arg1;
15054 }
15055 return resultobj;
15056 fail:
15057 {
15058 if (temp1)
15059 delete arg1;
15060 }
15061 return NULL;
15062 }
15063
15064
15065 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15066 PyObject *resultobj = 0;
15067 long arg1 ;
15068 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15069 wxKillError *arg3 = (wxKillError *) 0 ;
15070 int arg4 = (int) wxKILL_NOCHILDREN ;
15071 int result;
15072 long val1 ;
15073 int ecode1 = 0 ;
15074 int val2 ;
15075 int ecode2 = 0 ;
15076 wxKillError temp3 ;
15077 int val4 ;
15078 int ecode4 = 0 ;
15079 PyObject * obj0 = 0 ;
15080 PyObject * obj1 = 0 ;
15081 PyObject * obj2 = 0 ;
15082 char * kwnames[] = {
15083 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15084 };
15085
15086 {
15087 arg3 = &temp3;
15088 }
15089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15090 ecode1 = SWIG_AsVal_long(obj0, &val1);
15091 if (!SWIG_IsOK(ecode1)) {
15092 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15093 }
15094 arg1 = static_cast< long >(val1);
15095 if (obj1) {
15096 ecode2 = SWIG_AsVal_int(obj1, &val2);
15097 if (!SWIG_IsOK(ecode2)) {
15098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15099 }
15100 arg2 = static_cast< wxSignal >(val2);
15101 }
15102 if (obj2) {
15103 ecode4 = SWIG_AsVal_int(obj2, &val4);
15104 if (!SWIG_IsOK(ecode4)) {
15105 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15106 }
15107 arg4 = static_cast< int >(val4);
15108 }
15109 {
15110 PyThreadState* __tstate = wxPyBeginAllowThreads();
15111 result = (int)wxKill(arg1,arg2,arg3,arg4);
15112 wxPyEndAllowThreads(__tstate);
15113 if (PyErr_Occurred()) SWIG_fail;
15114 }
15115 resultobj = SWIG_From_int(static_cast< int >(result));
15116 {
15117 PyObject* o;
15118 o = PyInt_FromLong((long) (*arg3));
15119
15120
15121
15122 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15123
15124 }
15125 return resultobj;
15126 fail:
15127 return NULL;
15128 }
15129
15130
15131 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15132 PyObject *resultobj = 0;
15133 int arg1 = (int) wxJOYSTICK1 ;
15134 wxJoystick *result = 0 ;
15135 int val1 ;
15136 int ecode1 = 0 ;
15137 PyObject * obj0 = 0 ;
15138 char * kwnames[] = {
15139 (char *) "joystick", NULL
15140 };
15141
15142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15143 if (obj0) {
15144 ecode1 = SWIG_AsVal_int(obj0, &val1);
15145 if (!SWIG_IsOK(ecode1)) {
15146 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15147 }
15148 arg1 = static_cast< int >(val1);
15149 }
15150 {
15151 if (!wxPyCheckForApp()) SWIG_fail;
15152 PyThreadState* __tstate = wxPyBeginAllowThreads();
15153 result = (wxJoystick *)new wxJoystick(arg1);
15154 wxPyEndAllowThreads(__tstate);
15155 if (PyErr_Occurred()) SWIG_fail;
15156 }
15157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15158 return resultobj;
15159 fail:
15160 return NULL;
15161 }
15162
15163
15164 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15165 PyObject *resultobj = 0;
15166 wxJoystick *arg1 = (wxJoystick *) 0 ;
15167 void *argp1 = 0 ;
15168 int res1 = 0 ;
15169 PyObject *swig_obj[1] ;
15170
15171 if (!args) SWIG_fail;
15172 swig_obj[0] = args;
15173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15174 if (!SWIG_IsOK(res1)) {
15175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15176 }
15177 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15178 {
15179 PyThreadState* __tstate = wxPyBeginAllowThreads();
15180 delete arg1;
15181
15182 wxPyEndAllowThreads(__tstate);
15183 if (PyErr_Occurred()) SWIG_fail;
15184 }
15185 resultobj = SWIG_Py_Void();
15186 return resultobj;
15187 fail:
15188 return NULL;
15189 }
15190
15191
15192 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15193 PyObject *resultobj = 0;
15194 wxJoystick *arg1 = (wxJoystick *) 0 ;
15195 wxPoint result;
15196 void *argp1 = 0 ;
15197 int res1 = 0 ;
15198 PyObject *swig_obj[1] ;
15199
15200 if (!args) SWIG_fail;
15201 swig_obj[0] = args;
15202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15203 if (!SWIG_IsOK(res1)) {
15204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15205 }
15206 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15207 {
15208 PyThreadState* __tstate = wxPyBeginAllowThreads();
15209 result = (arg1)->GetPosition();
15210 wxPyEndAllowThreads(__tstate);
15211 if (PyErr_Occurred()) SWIG_fail;
15212 }
15213 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15214 return resultobj;
15215 fail:
15216 return NULL;
15217 }
15218
15219
15220 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15221 PyObject *resultobj = 0;
15222 wxJoystick *arg1 = (wxJoystick *) 0 ;
15223 int result;
15224 void *argp1 = 0 ;
15225 int res1 = 0 ;
15226 PyObject *swig_obj[1] ;
15227
15228 if (!args) SWIG_fail;
15229 swig_obj[0] = args;
15230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15231 if (!SWIG_IsOK(res1)) {
15232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15233 }
15234 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15235 {
15236 PyThreadState* __tstate = wxPyBeginAllowThreads();
15237 result = (int)(arg1)->GetZPosition();
15238 wxPyEndAllowThreads(__tstate);
15239 if (PyErr_Occurred()) SWIG_fail;
15240 }
15241 resultobj = SWIG_From_int(static_cast< int >(result));
15242 return resultobj;
15243 fail:
15244 return NULL;
15245 }
15246
15247
15248 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15249 PyObject *resultobj = 0;
15250 wxJoystick *arg1 = (wxJoystick *) 0 ;
15251 int result;
15252 void *argp1 = 0 ;
15253 int res1 = 0 ;
15254 PyObject *swig_obj[1] ;
15255
15256 if (!args) SWIG_fail;
15257 swig_obj[0] = args;
15258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15259 if (!SWIG_IsOK(res1)) {
15260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15261 }
15262 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15263 {
15264 PyThreadState* __tstate = wxPyBeginAllowThreads();
15265 result = (int)(arg1)->GetButtonState();
15266 wxPyEndAllowThreads(__tstate);
15267 if (PyErr_Occurred()) SWIG_fail;
15268 }
15269 resultobj = SWIG_From_int(static_cast< int >(result));
15270 return resultobj;
15271 fail:
15272 return NULL;
15273 }
15274
15275
15276 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15277 PyObject *resultobj = 0;
15278 wxJoystick *arg1 = (wxJoystick *) 0 ;
15279 int result;
15280 void *argp1 = 0 ;
15281 int res1 = 0 ;
15282 PyObject *swig_obj[1] ;
15283
15284 if (!args) SWIG_fail;
15285 swig_obj[0] = args;
15286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15287 if (!SWIG_IsOK(res1)) {
15288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15289 }
15290 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15291 {
15292 PyThreadState* __tstate = wxPyBeginAllowThreads();
15293 result = (int)(arg1)->GetPOVPosition();
15294 wxPyEndAllowThreads(__tstate);
15295 if (PyErr_Occurred()) SWIG_fail;
15296 }
15297 resultobj = SWIG_From_int(static_cast< int >(result));
15298 return resultobj;
15299 fail:
15300 return NULL;
15301 }
15302
15303
15304 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15305 PyObject *resultobj = 0;
15306 wxJoystick *arg1 = (wxJoystick *) 0 ;
15307 int result;
15308 void *argp1 = 0 ;
15309 int res1 = 0 ;
15310 PyObject *swig_obj[1] ;
15311
15312 if (!args) SWIG_fail;
15313 swig_obj[0] = args;
15314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15315 if (!SWIG_IsOK(res1)) {
15316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15317 }
15318 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15319 {
15320 PyThreadState* __tstate = wxPyBeginAllowThreads();
15321 result = (int)(arg1)->GetPOVCTSPosition();
15322 wxPyEndAllowThreads(__tstate);
15323 if (PyErr_Occurred()) SWIG_fail;
15324 }
15325 resultobj = SWIG_From_int(static_cast< int >(result));
15326 return resultobj;
15327 fail:
15328 return NULL;
15329 }
15330
15331
15332 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15333 PyObject *resultobj = 0;
15334 wxJoystick *arg1 = (wxJoystick *) 0 ;
15335 int result;
15336 void *argp1 = 0 ;
15337 int res1 = 0 ;
15338 PyObject *swig_obj[1] ;
15339
15340 if (!args) SWIG_fail;
15341 swig_obj[0] = args;
15342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15343 if (!SWIG_IsOK(res1)) {
15344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15345 }
15346 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15347 {
15348 PyThreadState* __tstate = wxPyBeginAllowThreads();
15349 result = (int)(arg1)->GetRudderPosition();
15350 wxPyEndAllowThreads(__tstate);
15351 if (PyErr_Occurred()) SWIG_fail;
15352 }
15353 resultobj = SWIG_From_int(static_cast< int >(result));
15354 return resultobj;
15355 fail:
15356 return NULL;
15357 }
15358
15359
15360 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15361 PyObject *resultobj = 0;
15362 wxJoystick *arg1 = (wxJoystick *) 0 ;
15363 int result;
15364 void *argp1 = 0 ;
15365 int res1 = 0 ;
15366 PyObject *swig_obj[1] ;
15367
15368 if (!args) SWIG_fail;
15369 swig_obj[0] = args;
15370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15371 if (!SWIG_IsOK(res1)) {
15372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15373 }
15374 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15375 {
15376 PyThreadState* __tstate = wxPyBeginAllowThreads();
15377 result = (int)(arg1)->GetUPosition();
15378 wxPyEndAllowThreads(__tstate);
15379 if (PyErr_Occurred()) SWIG_fail;
15380 }
15381 resultobj = SWIG_From_int(static_cast< int >(result));
15382 return resultobj;
15383 fail:
15384 return NULL;
15385 }
15386
15387
15388 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15389 PyObject *resultobj = 0;
15390 wxJoystick *arg1 = (wxJoystick *) 0 ;
15391 int result;
15392 void *argp1 = 0 ;
15393 int res1 = 0 ;
15394 PyObject *swig_obj[1] ;
15395
15396 if (!args) SWIG_fail;
15397 swig_obj[0] = args;
15398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15399 if (!SWIG_IsOK(res1)) {
15400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15401 }
15402 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15403 {
15404 PyThreadState* __tstate = wxPyBeginAllowThreads();
15405 result = (int)(arg1)->GetVPosition();
15406 wxPyEndAllowThreads(__tstate);
15407 if (PyErr_Occurred()) SWIG_fail;
15408 }
15409 resultobj = SWIG_From_int(static_cast< int >(result));
15410 return resultobj;
15411 fail:
15412 return NULL;
15413 }
15414
15415
15416 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15417 PyObject *resultobj = 0;
15418 wxJoystick *arg1 = (wxJoystick *) 0 ;
15419 int result;
15420 void *argp1 = 0 ;
15421 int res1 = 0 ;
15422 PyObject *swig_obj[1] ;
15423
15424 if (!args) SWIG_fail;
15425 swig_obj[0] = args;
15426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15427 if (!SWIG_IsOK(res1)) {
15428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15429 }
15430 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15431 {
15432 PyThreadState* __tstate = wxPyBeginAllowThreads();
15433 result = (int)(arg1)->GetMovementThreshold();
15434 wxPyEndAllowThreads(__tstate);
15435 if (PyErr_Occurred()) SWIG_fail;
15436 }
15437 resultobj = SWIG_From_int(static_cast< int >(result));
15438 return resultobj;
15439 fail:
15440 return NULL;
15441 }
15442
15443
15444 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15445 PyObject *resultobj = 0;
15446 wxJoystick *arg1 = (wxJoystick *) 0 ;
15447 int arg2 ;
15448 void *argp1 = 0 ;
15449 int res1 = 0 ;
15450 int val2 ;
15451 int ecode2 = 0 ;
15452 PyObject * obj0 = 0 ;
15453 PyObject * obj1 = 0 ;
15454 char * kwnames[] = {
15455 (char *) "self",(char *) "threshold", NULL
15456 };
15457
15458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15460 if (!SWIG_IsOK(res1)) {
15461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15462 }
15463 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15464 ecode2 = SWIG_AsVal_int(obj1, &val2);
15465 if (!SWIG_IsOK(ecode2)) {
15466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15467 }
15468 arg2 = static_cast< int >(val2);
15469 {
15470 PyThreadState* __tstate = wxPyBeginAllowThreads();
15471 (arg1)->SetMovementThreshold(arg2);
15472 wxPyEndAllowThreads(__tstate);
15473 if (PyErr_Occurred()) SWIG_fail;
15474 }
15475 resultobj = SWIG_Py_Void();
15476 return resultobj;
15477 fail:
15478 return NULL;
15479 }
15480
15481
15482 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15483 PyObject *resultobj = 0;
15484 wxJoystick *arg1 = (wxJoystick *) 0 ;
15485 bool result;
15486 void *argp1 = 0 ;
15487 int res1 = 0 ;
15488 PyObject *swig_obj[1] ;
15489
15490 if (!args) SWIG_fail;
15491 swig_obj[0] = args;
15492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15493 if (!SWIG_IsOK(res1)) {
15494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15495 }
15496 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15497 {
15498 PyThreadState* __tstate = wxPyBeginAllowThreads();
15499 result = (bool)(arg1)->IsOk();
15500 wxPyEndAllowThreads(__tstate);
15501 if (PyErr_Occurred()) SWIG_fail;
15502 }
15503 {
15504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15505 }
15506 return resultobj;
15507 fail:
15508 return NULL;
15509 }
15510
15511
15512 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(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_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15525 }
15526 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15527 {
15528 PyThreadState* __tstate = wxPyBeginAllowThreads();
15529 result = (int)(arg1)->GetNumberJoysticks();
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_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15541 PyObject *resultobj = 0;
15542 wxJoystick *arg1 = (wxJoystick *) 0 ;
15543 int result;
15544 void *argp1 = 0 ;
15545 int res1 = 0 ;
15546 PyObject *swig_obj[1] ;
15547
15548 if (!args) SWIG_fail;
15549 swig_obj[0] = args;
15550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15551 if (!SWIG_IsOK(res1)) {
15552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15553 }
15554 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15555 {
15556 PyThreadState* __tstate = wxPyBeginAllowThreads();
15557 result = (int)(arg1)->GetManufacturerId();
15558 wxPyEndAllowThreads(__tstate);
15559 if (PyErr_Occurred()) SWIG_fail;
15560 }
15561 resultobj = SWIG_From_int(static_cast< int >(result));
15562 return resultobj;
15563 fail:
15564 return NULL;
15565 }
15566
15567
15568 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15569 PyObject *resultobj = 0;
15570 wxJoystick *arg1 = (wxJoystick *) 0 ;
15571 int result;
15572 void *argp1 = 0 ;
15573 int res1 = 0 ;
15574 PyObject *swig_obj[1] ;
15575
15576 if (!args) SWIG_fail;
15577 swig_obj[0] = args;
15578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15579 if (!SWIG_IsOK(res1)) {
15580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15581 }
15582 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15583 {
15584 PyThreadState* __tstate = wxPyBeginAllowThreads();
15585 result = (int)(arg1)->GetProductId();
15586 wxPyEndAllowThreads(__tstate);
15587 if (PyErr_Occurred()) SWIG_fail;
15588 }
15589 resultobj = SWIG_From_int(static_cast< int >(result));
15590 return resultobj;
15591 fail:
15592 return NULL;
15593 }
15594
15595
15596 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15597 PyObject *resultobj = 0;
15598 wxJoystick *arg1 = (wxJoystick *) 0 ;
15599 wxString result;
15600 void *argp1 = 0 ;
15601 int res1 = 0 ;
15602 PyObject *swig_obj[1] ;
15603
15604 if (!args) SWIG_fail;
15605 swig_obj[0] = args;
15606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15607 if (!SWIG_IsOK(res1)) {
15608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15609 }
15610 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15611 {
15612 PyThreadState* __tstate = wxPyBeginAllowThreads();
15613 result = (arg1)->GetProductName();
15614 wxPyEndAllowThreads(__tstate);
15615 if (PyErr_Occurred()) SWIG_fail;
15616 }
15617 {
15618 #if wxUSE_UNICODE
15619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15620 #else
15621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15622 #endif
15623 }
15624 return resultobj;
15625 fail:
15626 return NULL;
15627 }
15628
15629
15630 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15631 PyObject *resultobj = 0;
15632 wxJoystick *arg1 = (wxJoystick *) 0 ;
15633 int result;
15634 void *argp1 = 0 ;
15635 int res1 = 0 ;
15636 PyObject *swig_obj[1] ;
15637
15638 if (!args) SWIG_fail;
15639 swig_obj[0] = args;
15640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15641 if (!SWIG_IsOK(res1)) {
15642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15643 }
15644 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15645 {
15646 PyThreadState* __tstate = wxPyBeginAllowThreads();
15647 result = (int)(arg1)->GetXMin();
15648 wxPyEndAllowThreads(__tstate);
15649 if (PyErr_Occurred()) SWIG_fail;
15650 }
15651 resultobj = SWIG_From_int(static_cast< int >(result));
15652 return resultobj;
15653 fail:
15654 return NULL;
15655 }
15656
15657
15658 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15659 PyObject *resultobj = 0;
15660 wxJoystick *arg1 = (wxJoystick *) 0 ;
15661 int result;
15662 void *argp1 = 0 ;
15663 int res1 = 0 ;
15664 PyObject *swig_obj[1] ;
15665
15666 if (!args) SWIG_fail;
15667 swig_obj[0] = args;
15668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15669 if (!SWIG_IsOK(res1)) {
15670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15671 }
15672 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15673 {
15674 PyThreadState* __tstate = wxPyBeginAllowThreads();
15675 result = (int)(arg1)->GetYMin();
15676 wxPyEndAllowThreads(__tstate);
15677 if (PyErr_Occurred()) SWIG_fail;
15678 }
15679 resultobj = SWIG_From_int(static_cast< int >(result));
15680 return resultobj;
15681 fail:
15682 return NULL;
15683 }
15684
15685
15686 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15687 PyObject *resultobj = 0;
15688 wxJoystick *arg1 = (wxJoystick *) 0 ;
15689 int result;
15690 void *argp1 = 0 ;
15691 int res1 = 0 ;
15692 PyObject *swig_obj[1] ;
15693
15694 if (!args) SWIG_fail;
15695 swig_obj[0] = args;
15696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15697 if (!SWIG_IsOK(res1)) {
15698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15699 }
15700 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15701 {
15702 PyThreadState* __tstate = wxPyBeginAllowThreads();
15703 result = (int)(arg1)->GetZMin();
15704 wxPyEndAllowThreads(__tstate);
15705 if (PyErr_Occurred()) SWIG_fail;
15706 }
15707 resultobj = SWIG_From_int(static_cast< int >(result));
15708 return resultobj;
15709 fail:
15710 return NULL;
15711 }
15712
15713
15714 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15715 PyObject *resultobj = 0;
15716 wxJoystick *arg1 = (wxJoystick *) 0 ;
15717 int result;
15718 void *argp1 = 0 ;
15719 int res1 = 0 ;
15720 PyObject *swig_obj[1] ;
15721
15722 if (!args) SWIG_fail;
15723 swig_obj[0] = args;
15724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15725 if (!SWIG_IsOK(res1)) {
15726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15727 }
15728 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15729 {
15730 PyThreadState* __tstate = wxPyBeginAllowThreads();
15731 result = (int)(arg1)->GetXMax();
15732 wxPyEndAllowThreads(__tstate);
15733 if (PyErr_Occurred()) SWIG_fail;
15734 }
15735 resultobj = SWIG_From_int(static_cast< int >(result));
15736 return resultobj;
15737 fail:
15738 return NULL;
15739 }
15740
15741
15742 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15743 PyObject *resultobj = 0;
15744 wxJoystick *arg1 = (wxJoystick *) 0 ;
15745 int result;
15746 void *argp1 = 0 ;
15747 int res1 = 0 ;
15748 PyObject *swig_obj[1] ;
15749
15750 if (!args) SWIG_fail;
15751 swig_obj[0] = args;
15752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15753 if (!SWIG_IsOK(res1)) {
15754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15755 }
15756 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15757 {
15758 PyThreadState* __tstate = wxPyBeginAllowThreads();
15759 result = (int)(arg1)->GetYMax();
15760 wxPyEndAllowThreads(__tstate);
15761 if (PyErr_Occurred()) SWIG_fail;
15762 }
15763 resultobj = SWIG_From_int(static_cast< int >(result));
15764 return resultobj;
15765 fail:
15766 return NULL;
15767 }
15768
15769
15770 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15771 PyObject *resultobj = 0;
15772 wxJoystick *arg1 = (wxJoystick *) 0 ;
15773 int result;
15774 void *argp1 = 0 ;
15775 int res1 = 0 ;
15776 PyObject *swig_obj[1] ;
15777
15778 if (!args) SWIG_fail;
15779 swig_obj[0] = args;
15780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15781 if (!SWIG_IsOK(res1)) {
15782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15783 }
15784 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15785 {
15786 PyThreadState* __tstate = wxPyBeginAllowThreads();
15787 result = (int)(arg1)->GetZMax();
15788 wxPyEndAllowThreads(__tstate);
15789 if (PyErr_Occurred()) SWIG_fail;
15790 }
15791 resultobj = SWIG_From_int(static_cast< int >(result));
15792 return resultobj;
15793 fail:
15794 return NULL;
15795 }
15796
15797
15798 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15799 PyObject *resultobj = 0;
15800 wxJoystick *arg1 = (wxJoystick *) 0 ;
15801 int result;
15802 void *argp1 = 0 ;
15803 int res1 = 0 ;
15804 PyObject *swig_obj[1] ;
15805
15806 if (!args) SWIG_fail;
15807 swig_obj[0] = args;
15808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15809 if (!SWIG_IsOK(res1)) {
15810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15811 }
15812 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15813 {
15814 PyThreadState* __tstate = wxPyBeginAllowThreads();
15815 result = (int)(arg1)->GetNumberButtons();
15816 wxPyEndAllowThreads(__tstate);
15817 if (PyErr_Occurred()) SWIG_fail;
15818 }
15819 resultobj = SWIG_From_int(static_cast< int >(result));
15820 return resultobj;
15821 fail:
15822 return NULL;
15823 }
15824
15825
15826 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15827 PyObject *resultobj = 0;
15828 wxJoystick *arg1 = (wxJoystick *) 0 ;
15829 int result;
15830 void *argp1 = 0 ;
15831 int res1 = 0 ;
15832 PyObject *swig_obj[1] ;
15833
15834 if (!args) SWIG_fail;
15835 swig_obj[0] = args;
15836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15837 if (!SWIG_IsOK(res1)) {
15838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15839 }
15840 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15841 {
15842 PyThreadState* __tstate = wxPyBeginAllowThreads();
15843 result = (int)(arg1)->GetNumberAxes();
15844 wxPyEndAllowThreads(__tstate);
15845 if (PyErr_Occurred()) SWIG_fail;
15846 }
15847 resultobj = SWIG_From_int(static_cast< int >(result));
15848 return resultobj;
15849 fail:
15850 return NULL;
15851 }
15852
15853
15854 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15855 PyObject *resultobj = 0;
15856 wxJoystick *arg1 = (wxJoystick *) 0 ;
15857 int result;
15858 void *argp1 = 0 ;
15859 int res1 = 0 ;
15860 PyObject *swig_obj[1] ;
15861
15862 if (!args) SWIG_fail;
15863 swig_obj[0] = args;
15864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15865 if (!SWIG_IsOK(res1)) {
15866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15867 }
15868 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15869 {
15870 PyThreadState* __tstate = wxPyBeginAllowThreads();
15871 result = (int)(arg1)->GetMaxButtons();
15872 wxPyEndAllowThreads(__tstate);
15873 if (PyErr_Occurred()) SWIG_fail;
15874 }
15875 resultobj = SWIG_From_int(static_cast< int >(result));
15876 return resultobj;
15877 fail:
15878 return NULL;
15879 }
15880
15881
15882 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15883 PyObject *resultobj = 0;
15884 wxJoystick *arg1 = (wxJoystick *) 0 ;
15885 int result;
15886 void *argp1 = 0 ;
15887 int res1 = 0 ;
15888 PyObject *swig_obj[1] ;
15889
15890 if (!args) SWIG_fail;
15891 swig_obj[0] = args;
15892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15893 if (!SWIG_IsOK(res1)) {
15894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15895 }
15896 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15897 {
15898 PyThreadState* __tstate = wxPyBeginAllowThreads();
15899 result = (int)(arg1)->GetMaxAxes();
15900 wxPyEndAllowThreads(__tstate);
15901 if (PyErr_Occurred()) SWIG_fail;
15902 }
15903 resultobj = SWIG_From_int(static_cast< int >(result));
15904 return resultobj;
15905 fail:
15906 return NULL;
15907 }
15908
15909
15910 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15911 PyObject *resultobj = 0;
15912 wxJoystick *arg1 = (wxJoystick *) 0 ;
15913 int result;
15914 void *argp1 = 0 ;
15915 int res1 = 0 ;
15916 PyObject *swig_obj[1] ;
15917
15918 if (!args) SWIG_fail;
15919 swig_obj[0] = args;
15920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15921 if (!SWIG_IsOK(res1)) {
15922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15923 }
15924 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15925 {
15926 PyThreadState* __tstate = wxPyBeginAllowThreads();
15927 result = (int)(arg1)->GetPollingMin();
15928 wxPyEndAllowThreads(__tstate);
15929 if (PyErr_Occurred()) SWIG_fail;
15930 }
15931 resultobj = SWIG_From_int(static_cast< int >(result));
15932 return resultobj;
15933 fail:
15934 return NULL;
15935 }
15936
15937
15938 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15939 PyObject *resultobj = 0;
15940 wxJoystick *arg1 = (wxJoystick *) 0 ;
15941 int result;
15942 void *argp1 = 0 ;
15943 int res1 = 0 ;
15944 PyObject *swig_obj[1] ;
15945
15946 if (!args) SWIG_fail;
15947 swig_obj[0] = args;
15948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15949 if (!SWIG_IsOK(res1)) {
15950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15951 }
15952 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15953 {
15954 PyThreadState* __tstate = wxPyBeginAllowThreads();
15955 result = (int)(arg1)->GetPollingMax();
15956 wxPyEndAllowThreads(__tstate);
15957 if (PyErr_Occurred()) SWIG_fail;
15958 }
15959 resultobj = SWIG_From_int(static_cast< int >(result));
15960 return resultobj;
15961 fail:
15962 return NULL;
15963 }
15964
15965
15966 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15967 PyObject *resultobj = 0;
15968 wxJoystick *arg1 = (wxJoystick *) 0 ;
15969 int result;
15970 void *argp1 = 0 ;
15971 int res1 = 0 ;
15972 PyObject *swig_obj[1] ;
15973
15974 if (!args) SWIG_fail;
15975 swig_obj[0] = args;
15976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15977 if (!SWIG_IsOK(res1)) {
15978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15979 }
15980 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15981 {
15982 PyThreadState* __tstate = wxPyBeginAllowThreads();
15983 result = (int)(arg1)->GetRudderMin();
15984 wxPyEndAllowThreads(__tstate);
15985 if (PyErr_Occurred()) SWIG_fail;
15986 }
15987 resultobj = SWIG_From_int(static_cast< int >(result));
15988 return resultobj;
15989 fail:
15990 return NULL;
15991 }
15992
15993
15994 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15995 PyObject *resultobj = 0;
15996 wxJoystick *arg1 = (wxJoystick *) 0 ;
15997 int result;
15998 void *argp1 = 0 ;
15999 int res1 = 0 ;
16000 PyObject *swig_obj[1] ;
16001
16002 if (!args) SWIG_fail;
16003 swig_obj[0] = args;
16004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16005 if (!SWIG_IsOK(res1)) {
16006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16007 }
16008 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16009 {
16010 PyThreadState* __tstate = wxPyBeginAllowThreads();
16011 result = (int)(arg1)->GetRudderMax();
16012 wxPyEndAllowThreads(__tstate);
16013 if (PyErr_Occurred()) SWIG_fail;
16014 }
16015 resultobj = SWIG_From_int(static_cast< int >(result));
16016 return resultobj;
16017 fail:
16018 return NULL;
16019 }
16020
16021
16022 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16023 PyObject *resultobj = 0;
16024 wxJoystick *arg1 = (wxJoystick *) 0 ;
16025 int result;
16026 void *argp1 = 0 ;
16027 int res1 = 0 ;
16028 PyObject *swig_obj[1] ;
16029
16030 if (!args) SWIG_fail;
16031 swig_obj[0] = args;
16032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16033 if (!SWIG_IsOK(res1)) {
16034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16035 }
16036 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16037 {
16038 PyThreadState* __tstate = wxPyBeginAllowThreads();
16039 result = (int)(arg1)->GetUMin();
16040 wxPyEndAllowThreads(__tstate);
16041 if (PyErr_Occurred()) SWIG_fail;
16042 }
16043 resultobj = SWIG_From_int(static_cast< int >(result));
16044 return resultobj;
16045 fail:
16046 return NULL;
16047 }
16048
16049
16050 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16051 PyObject *resultobj = 0;
16052 wxJoystick *arg1 = (wxJoystick *) 0 ;
16053 int result;
16054 void *argp1 = 0 ;
16055 int res1 = 0 ;
16056 PyObject *swig_obj[1] ;
16057
16058 if (!args) SWIG_fail;
16059 swig_obj[0] = args;
16060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16061 if (!SWIG_IsOK(res1)) {
16062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16063 }
16064 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16065 {
16066 PyThreadState* __tstate = wxPyBeginAllowThreads();
16067 result = (int)(arg1)->GetUMax();
16068 wxPyEndAllowThreads(__tstate);
16069 if (PyErr_Occurred()) SWIG_fail;
16070 }
16071 resultobj = SWIG_From_int(static_cast< int >(result));
16072 return resultobj;
16073 fail:
16074 return NULL;
16075 }
16076
16077
16078 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16079 PyObject *resultobj = 0;
16080 wxJoystick *arg1 = (wxJoystick *) 0 ;
16081 int result;
16082 void *argp1 = 0 ;
16083 int res1 = 0 ;
16084 PyObject *swig_obj[1] ;
16085
16086 if (!args) SWIG_fail;
16087 swig_obj[0] = args;
16088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16089 if (!SWIG_IsOK(res1)) {
16090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16091 }
16092 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16093 {
16094 PyThreadState* __tstate = wxPyBeginAllowThreads();
16095 result = (int)(arg1)->GetVMin();
16096 wxPyEndAllowThreads(__tstate);
16097 if (PyErr_Occurred()) SWIG_fail;
16098 }
16099 resultobj = SWIG_From_int(static_cast< int >(result));
16100 return resultobj;
16101 fail:
16102 return NULL;
16103 }
16104
16105
16106 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16107 PyObject *resultobj = 0;
16108 wxJoystick *arg1 = (wxJoystick *) 0 ;
16109 int result;
16110 void *argp1 = 0 ;
16111 int res1 = 0 ;
16112 PyObject *swig_obj[1] ;
16113
16114 if (!args) SWIG_fail;
16115 swig_obj[0] = args;
16116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16117 if (!SWIG_IsOK(res1)) {
16118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16119 }
16120 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16121 {
16122 PyThreadState* __tstate = wxPyBeginAllowThreads();
16123 result = (int)(arg1)->GetVMax();
16124 wxPyEndAllowThreads(__tstate);
16125 if (PyErr_Occurred()) SWIG_fail;
16126 }
16127 resultobj = SWIG_From_int(static_cast< int >(result));
16128 return resultobj;
16129 fail:
16130 return NULL;
16131 }
16132
16133
16134 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16135 PyObject *resultobj = 0;
16136 wxJoystick *arg1 = (wxJoystick *) 0 ;
16137 bool result;
16138 void *argp1 = 0 ;
16139 int res1 = 0 ;
16140 PyObject *swig_obj[1] ;
16141
16142 if (!args) SWIG_fail;
16143 swig_obj[0] = args;
16144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16145 if (!SWIG_IsOK(res1)) {
16146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16147 }
16148 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16149 {
16150 PyThreadState* __tstate = wxPyBeginAllowThreads();
16151 result = (bool)(arg1)->HasRudder();
16152 wxPyEndAllowThreads(__tstate);
16153 if (PyErr_Occurred()) SWIG_fail;
16154 }
16155 {
16156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16157 }
16158 return resultobj;
16159 fail:
16160 return NULL;
16161 }
16162
16163
16164 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16165 PyObject *resultobj = 0;
16166 wxJoystick *arg1 = (wxJoystick *) 0 ;
16167 bool result;
16168 void *argp1 = 0 ;
16169 int res1 = 0 ;
16170 PyObject *swig_obj[1] ;
16171
16172 if (!args) SWIG_fail;
16173 swig_obj[0] = args;
16174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16175 if (!SWIG_IsOK(res1)) {
16176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16177 }
16178 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16179 {
16180 PyThreadState* __tstate = wxPyBeginAllowThreads();
16181 result = (bool)(arg1)->HasZ();
16182 wxPyEndAllowThreads(__tstate);
16183 if (PyErr_Occurred()) SWIG_fail;
16184 }
16185 {
16186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16187 }
16188 return resultobj;
16189 fail:
16190 return NULL;
16191 }
16192
16193
16194 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16195 PyObject *resultobj = 0;
16196 wxJoystick *arg1 = (wxJoystick *) 0 ;
16197 bool result;
16198 void *argp1 = 0 ;
16199 int res1 = 0 ;
16200 PyObject *swig_obj[1] ;
16201
16202 if (!args) SWIG_fail;
16203 swig_obj[0] = args;
16204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16205 if (!SWIG_IsOK(res1)) {
16206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16207 }
16208 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16209 {
16210 PyThreadState* __tstate = wxPyBeginAllowThreads();
16211 result = (bool)(arg1)->HasU();
16212 wxPyEndAllowThreads(__tstate);
16213 if (PyErr_Occurred()) SWIG_fail;
16214 }
16215 {
16216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16217 }
16218 return resultobj;
16219 fail:
16220 return NULL;
16221 }
16222
16223
16224 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16225 PyObject *resultobj = 0;
16226 wxJoystick *arg1 = (wxJoystick *) 0 ;
16227 bool result;
16228 void *argp1 = 0 ;
16229 int res1 = 0 ;
16230 PyObject *swig_obj[1] ;
16231
16232 if (!args) SWIG_fail;
16233 swig_obj[0] = args;
16234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16235 if (!SWIG_IsOK(res1)) {
16236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16237 }
16238 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16239 {
16240 PyThreadState* __tstate = wxPyBeginAllowThreads();
16241 result = (bool)(arg1)->HasV();
16242 wxPyEndAllowThreads(__tstate);
16243 if (PyErr_Occurred()) SWIG_fail;
16244 }
16245 {
16246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16247 }
16248 return resultobj;
16249 fail:
16250 return NULL;
16251 }
16252
16253
16254 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16255 PyObject *resultobj = 0;
16256 wxJoystick *arg1 = (wxJoystick *) 0 ;
16257 bool result;
16258 void *argp1 = 0 ;
16259 int res1 = 0 ;
16260 PyObject *swig_obj[1] ;
16261
16262 if (!args) SWIG_fail;
16263 swig_obj[0] = args;
16264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16265 if (!SWIG_IsOK(res1)) {
16266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16267 }
16268 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16269 {
16270 PyThreadState* __tstate = wxPyBeginAllowThreads();
16271 result = (bool)(arg1)->HasPOV();
16272 wxPyEndAllowThreads(__tstate);
16273 if (PyErr_Occurred()) SWIG_fail;
16274 }
16275 {
16276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16277 }
16278 return resultobj;
16279 fail:
16280 return NULL;
16281 }
16282
16283
16284 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16285 PyObject *resultobj = 0;
16286 wxJoystick *arg1 = (wxJoystick *) 0 ;
16287 bool result;
16288 void *argp1 = 0 ;
16289 int res1 = 0 ;
16290 PyObject *swig_obj[1] ;
16291
16292 if (!args) SWIG_fail;
16293 swig_obj[0] = args;
16294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16295 if (!SWIG_IsOK(res1)) {
16296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16297 }
16298 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16299 {
16300 PyThreadState* __tstate = wxPyBeginAllowThreads();
16301 result = (bool)(arg1)->HasPOV4Dir();
16302 wxPyEndAllowThreads(__tstate);
16303 if (PyErr_Occurred()) SWIG_fail;
16304 }
16305 {
16306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16307 }
16308 return resultobj;
16309 fail:
16310 return NULL;
16311 }
16312
16313
16314 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16315 PyObject *resultobj = 0;
16316 wxJoystick *arg1 = (wxJoystick *) 0 ;
16317 bool result;
16318 void *argp1 = 0 ;
16319 int res1 = 0 ;
16320 PyObject *swig_obj[1] ;
16321
16322 if (!args) SWIG_fail;
16323 swig_obj[0] = args;
16324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16325 if (!SWIG_IsOK(res1)) {
16326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16327 }
16328 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16329 {
16330 PyThreadState* __tstate = wxPyBeginAllowThreads();
16331 result = (bool)(arg1)->HasPOVCTS();
16332 wxPyEndAllowThreads(__tstate);
16333 if (PyErr_Occurred()) SWIG_fail;
16334 }
16335 {
16336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16337 }
16338 return resultobj;
16339 fail:
16340 return NULL;
16341 }
16342
16343
16344 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16345 PyObject *resultobj = 0;
16346 wxJoystick *arg1 = (wxJoystick *) 0 ;
16347 wxWindow *arg2 = (wxWindow *) 0 ;
16348 int arg3 = (int) 0 ;
16349 bool result;
16350 void *argp1 = 0 ;
16351 int res1 = 0 ;
16352 void *argp2 = 0 ;
16353 int res2 = 0 ;
16354 int val3 ;
16355 int ecode3 = 0 ;
16356 PyObject * obj0 = 0 ;
16357 PyObject * obj1 = 0 ;
16358 PyObject * obj2 = 0 ;
16359 char * kwnames[] = {
16360 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16361 };
16362
16363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16365 if (!SWIG_IsOK(res1)) {
16366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16367 }
16368 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16369 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16370 if (!SWIG_IsOK(res2)) {
16371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16372 }
16373 arg2 = reinterpret_cast< wxWindow * >(argp2);
16374 if (obj2) {
16375 ecode3 = SWIG_AsVal_int(obj2, &val3);
16376 if (!SWIG_IsOK(ecode3)) {
16377 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16378 }
16379 arg3 = static_cast< int >(val3);
16380 }
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 result = (bool)(arg1)->SetCapture(arg2,arg3);
16384 wxPyEndAllowThreads(__tstate);
16385 if (PyErr_Occurred()) SWIG_fail;
16386 }
16387 {
16388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16389 }
16390 return resultobj;
16391 fail:
16392 return NULL;
16393 }
16394
16395
16396 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16397 PyObject *resultobj = 0;
16398 wxJoystick *arg1 = (wxJoystick *) 0 ;
16399 bool result;
16400 void *argp1 = 0 ;
16401 int res1 = 0 ;
16402 PyObject *swig_obj[1] ;
16403
16404 if (!args) SWIG_fail;
16405 swig_obj[0] = args;
16406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16407 if (!SWIG_IsOK(res1)) {
16408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16409 }
16410 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16411 {
16412 PyThreadState* __tstate = wxPyBeginAllowThreads();
16413 result = (bool)(arg1)->ReleaseCapture();
16414 wxPyEndAllowThreads(__tstate);
16415 if (PyErr_Occurred()) SWIG_fail;
16416 }
16417 {
16418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16419 }
16420 return resultobj;
16421 fail:
16422 return NULL;
16423 }
16424
16425
16426 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16427 PyObject *obj;
16428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16429 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16430 return SWIG_Py_Void();
16431 }
16432
16433 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16434 return SWIG_Python_InitShadowInstance(args);
16435 }
16436
16437 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16438 PyObject *resultobj = 0;
16439 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16440 int arg2 = (int) 0 ;
16441 int arg3 = (int) wxJOYSTICK1 ;
16442 int arg4 = (int) 0 ;
16443 wxJoystickEvent *result = 0 ;
16444 int val1 ;
16445 int ecode1 = 0 ;
16446 int val2 ;
16447 int ecode2 = 0 ;
16448 int val3 ;
16449 int ecode3 = 0 ;
16450 int val4 ;
16451 int ecode4 = 0 ;
16452 PyObject * obj0 = 0 ;
16453 PyObject * obj1 = 0 ;
16454 PyObject * obj2 = 0 ;
16455 PyObject * obj3 = 0 ;
16456 char * kwnames[] = {
16457 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16458 };
16459
16460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16461 if (obj0) {
16462 ecode1 = SWIG_AsVal_int(obj0, &val1);
16463 if (!SWIG_IsOK(ecode1)) {
16464 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16465 }
16466 arg1 = static_cast< wxEventType >(val1);
16467 }
16468 if (obj1) {
16469 ecode2 = SWIG_AsVal_int(obj1, &val2);
16470 if (!SWIG_IsOK(ecode2)) {
16471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16472 }
16473 arg2 = static_cast< int >(val2);
16474 }
16475 if (obj2) {
16476 ecode3 = SWIG_AsVal_int(obj2, &val3);
16477 if (!SWIG_IsOK(ecode3)) {
16478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16479 }
16480 arg3 = static_cast< int >(val3);
16481 }
16482 if (obj3) {
16483 ecode4 = SWIG_AsVal_int(obj3, &val4);
16484 if (!SWIG_IsOK(ecode4)) {
16485 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16486 }
16487 arg4 = static_cast< int >(val4);
16488 }
16489 {
16490 PyThreadState* __tstate = wxPyBeginAllowThreads();
16491 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16492 wxPyEndAllowThreads(__tstate);
16493 if (PyErr_Occurred()) SWIG_fail;
16494 }
16495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16496 return resultobj;
16497 fail:
16498 return NULL;
16499 }
16500
16501
16502 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16503 PyObject *resultobj = 0;
16504 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16505 wxPoint result;
16506 void *argp1 = 0 ;
16507 int res1 = 0 ;
16508 PyObject *swig_obj[1] ;
16509
16510 if (!args) SWIG_fail;
16511 swig_obj[0] = args;
16512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16513 if (!SWIG_IsOK(res1)) {
16514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16515 }
16516 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16517 {
16518 PyThreadState* __tstate = wxPyBeginAllowThreads();
16519 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16520 wxPyEndAllowThreads(__tstate);
16521 if (PyErr_Occurred()) SWIG_fail;
16522 }
16523 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16524 return resultobj;
16525 fail:
16526 return NULL;
16527 }
16528
16529
16530 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16531 PyObject *resultobj = 0;
16532 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16533 int result;
16534 void *argp1 = 0 ;
16535 int res1 = 0 ;
16536 PyObject *swig_obj[1] ;
16537
16538 if (!args) SWIG_fail;
16539 swig_obj[0] = args;
16540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16541 if (!SWIG_IsOK(res1)) {
16542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16543 }
16544 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16545 {
16546 PyThreadState* __tstate = wxPyBeginAllowThreads();
16547 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16548 wxPyEndAllowThreads(__tstate);
16549 if (PyErr_Occurred()) SWIG_fail;
16550 }
16551 resultobj = SWIG_From_int(static_cast< int >(result));
16552 return resultobj;
16553 fail:
16554 return NULL;
16555 }
16556
16557
16558 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16559 PyObject *resultobj = 0;
16560 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16561 int result;
16562 void *argp1 = 0 ;
16563 int res1 = 0 ;
16564 PyObject *swig_obj[1] ;
16565
16566 if (!args) SWIG_fail;
16567 swig_obj[0] = args;
16568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16569 if (!SWIG_IsOK(res1)) {
16570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16571 }
16572 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16573 {
16574 PyThreadState* __tstate = wxPyBeginAllowThreads();
16575 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16576 wxPyEndAllowThreads(__tstate);
16577 if (PyErr_Occurred()) SWIG_fail;
16578 }
16579 resultobj = SWIG_From_int(static_cast< int >(result));
16580 return resultobj;
16581 fail:
16582 return NULL;
16583 }
16584
16585
16586 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16587 PyObject *resultobj = 0;
16588 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16589 int result;
16590 void *argp1 = 0 ;
16591 int res1 = 0 ;
16592 PyObject *swig_obj[1] ;
16593
16594 if (!args) SWIG_fail;
16595 swig_obj[0] = args;
16596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16597 if (!SWIG_IsOK(res1)) {
16598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16599 }
16600 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16601 {
16602 PyThreadState* __tstate = wxPyBeginAllowThreads();
16603 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16604 wxPyEndAllowThreads(__tstate);
16605 if (PyErr_Occurred()) SWIG_fail;
16606 }
16607 resultobj = SWIG_From_int(static_cast< int >(result));
16608 return resultobj;
16609 fail:
16610 return NULL;
16611 }
16612
16613
16614 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16615 PyObject *resultobj = 0;
16616 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16617 int result;
16618 void *argp1 = 0 ;
16619 int res1 = 0 ;
16620 PyObject *swig_obj[1] ;
16621
16622 if (!args) SWIG_fail;
16623 swig_obj[0] = args;
16624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16625 if (!SWIG_IsOK(res1)) {
16626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16627 }
16628 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16629 {
16630 PyThreadState* __tstate = wxPyBeginAllowThreads();
16631 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16632 wxPyEndAllowThreads(__tstate);
16633 if (PyErr_Occurred()) SWIG_fail;
16634 }
16635 resultobj = SWIG_From_int(static_cast< int >(result));
16636 return resultobj;
16637 fail:
16638 return NULL;
16639 }
16640
16641
16642 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16643 PyObject *resultobj = 0;
16644 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16645 int arg2 ;
16646 void *argp1 = 0 ;
16647 int res1 = 0 ;
16648 int val2 ;
16649 int ecode2 = 0 ;
16650 PyObject * obj0 = 0 ;
16651 PyObject * obj1 = 0 ;
16652 char * kwnames[] = {
16653 (char *) "self",(char *) "stick", NULL
16654 };
16655
16656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16658 if (!SWIG_IsOK(res1)) {
16659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16660 }
16661 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16662 ecode2 = SWIG_AsVal_int(obj1, &val2);
16663 if (!SWIG_IsOK(ecode2)) {
16664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16665 }
16666 arg2 = static_cast< int >(val2);
16667 {
16668 PyThreadState* __tstate = wxPyBeginAllowThreads();
16669 (arg1)->SetJoystick(arg2);
16670 wxPyEndAllowThreads(__tstate);
16671 if (PyErr_Occurred()) SWIG_fail;
16672 }
16673 resultobj = SWIG_Py_Void();
16674 return resultobj;
16675 fail:
16676 return NULL;
16677 }
16678
16679
16680 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16681 PyObject *resultobj = 0;
16682 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16683 int arg2 ;
16684 void *argp1 = 0 ;
16685 int res1 = 0 ;
16686 int val2 ;
16687 int ecode2 = 0 ;
16688 PyObject * obj0 = 0 ;
16689 PyObject * obj1 = 0 ;
16690 char * kwnames[] = {
16691 (char *) "self",(char *) "state", NULL
16692 };
16693
16694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16696 if (!SWIG_IsOK(res1)) {
16697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16698 }
16699 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16700 ecode2 = SWIG_AsVal_int(obj1, &val2);
16701 if (!SWIG_IsOK(ecode2)) {
16702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16703 }
16704 arg2 = static_cast< int >(val2);
16705 {
16706 PyThreadState* __tstate = wxPyBeginAllowThreads();
16707 (arg1)->SetButtonState(arg2);
16708 wxPyEndAllowThreads(__tstate);
16709 if (PyErr_Occurred()) SWIG_fail;
16710 }
16711 resultobj = SWIG_Py_Void();
16712 return resultobj;
16713 fail:
16714 return NULL;
16715 }
16716
16717
16718 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16719 PyObject *resultobj = 0;
16720 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16721 int arg2 ;
16722 void *argp1 = 0 ;
16723 int res1 = 0 ;
16724 int val2 ;
16725 int ecode2 = 0 ;
16726 PyObject * obj0 = 0 ;
16727 PyObject * obj1 = 0 ;
16728 char * kwnames[] = {
16729 (char *) "self",(char *) "change", NULL
16730 };
16731
16732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16734 if (!SWIG_IsOK(res1)) {
16735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16736 }
16737 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16738 ecode2 = SWIG_AsVal_int(obj1, &val2);
16739 if (!SWIG_IsOK(ecode2)) {
16740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16741 }
16742 arg2 = static_cast< int >(val2);
16743 {
16744 PyThreadState* __tstate = wxPyBeginAllowThreads();
16745 (arg1)->SetButtonChange(arg2);
16746 wxPyEndAllowThreads(__tstate);
16747 if (PyErr_Occurred()) SWIG_fail;
16748 }
16749 resultobj = SWIG_Py_Void();
16750 return resultobj;
16751 fail:
16752 return NULL;
16753 }
16754
16755
16756 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16757 PyObject *resultobj = 0;
16758 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16759 wxPoint *arg2 = 0 ;
16760 void *argp1 = 0 ;
16761 int res1 = 0 ;
16762 wxPoint temp2 ;
16763 PyObject * obj0 = 0 ;
16764 PyObject * obj1 = 0 ;
16765 char * kwnames[] = {
16766 (char *) "self",(char *) "pos", NULL
16767 };
16768
16769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16771 if (!SWIG_IsOK(res1)) {
16772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16773 }
16774 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16775 {
16776 arg2 = &temp2;
16777 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16778 }
16779 {
16780 PyThreadState* __tstate = wxPyBeginAllowThreads();
16781 (arg1)->SetPosition((wxPoint const &)*arg2);
16782 wxPyEndAllowThreads(__tstate);
16783 if (PyErr_Occurred()) SWIG_fail;
16784 }
16785 resultobj = SWIG_Py_Void();
16786 return resultobj;
16787 fail:
16788 return NULL;
16789 }
16790
16791
16792 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16793 PyObject *resultobj = 0;
16794 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16795 int arg2 ;
16796 void *argp1 = 0 ;
16797 int res1 = 0 ;
16798 int val2 ;
16799 int ecode2 = 0 ;
16800 PyObject * obj0 = 0 ;
16801 PyObject * obj1 = 0 ;
16802 char * kwnames[] = {
16803 (char *) "self",(char *) "zPos", NULL
16804 };
16805
16806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16808 if (!SWIG_IsOK(res1)) {
16809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16810 }
16811 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16812 ecode2 = SWIG_AsVal_int(obj1, &val2);
16813 if (!SWIG_IsOK(ecode2)) {
16814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16815 }
16816 arg2 = static_cast< int >(val2);
16817 {
16818 PyThreadState* __tstate = wxPyBeginAllowThreads();
16819 (arg1)->SetZPosition(arg2);
16820 wxPyEndAllowThreads(__tstate);
16821 if (PyErr_Occurred()) SWIG_fail;
16822 }
16823 resultobj = SWIG_Py_Void();
16824 return resultobj;
16825 fail:
16826 return NULL;
16827 }
16828
16829
16830 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16831 PyObject *resultobj = 0;
16832 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16833 bool result;
16834 void *argp1 = 0 ;
16835 int res1 = 0 ;
16836 PyObject *swig_obj[1] ;
16837
16838 if (!args) SWIG_fail;
16839 swig_obj[0] = args;
16840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16841 if (!SWIG_IsOK(res1)) {
16842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16843 }
16844 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16845 {
16846 PyThreadState* __tstate = wxPyBeginAllowThreads();
16847 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16848 wxPyEndAllowThreads(__tstate);
16849 if (PyErr_Occurred()) SWIG_fail;
16850 }
16851 {
16852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16853 }
16854 return resultobj;
16855 fail:
16856 return NULL;
16857 }
16858
16859
16860 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16861 PyObject *resultobj = 0;
16862 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16863 bool result;
16864 void *argp1 = 0 ;
16865 int res1 = 0 ;
16866 PyObject *swig_obj[1] ;
16867
16868 if (!args) SWIG_fail;
16869 swig_obj[0] = args;
16870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16871 if (!SWIG_IsOK(res1)) {
16872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16873 }
16874 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16875 {
16876 PyThreadState* __tstate = wxPyBeginAllowThreads();
16877 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16878 wxPyEndAllowThreads(__tstate);
16879 if (PyErr_Occurred()) SWIG_fail;
16880 }
16881 {
16882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16883 }
16884 return resultobj;
16885 fail:
16886 return NULL;
16887 }
16888
16889
16890 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16891 PyObject *resultobj = 0;
16892 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16893 bool result;
16894 void *argp1 = 0 ;
16895 int res1 = 0 ;
16896 PyObject *swig_obj[1] ;
16897
16898 if (!args) SWIG_fail;
16899 swig_obj[0] = args;
16900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16901 if (!SWIG_IsOK(res1)) {
16902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16903 }
16904 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16905 {
16906 PyThreadState* __tstate = wxPyBeginAllowThreads();
16907 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16908 wxPyEndAllowThreads(__tstate);
16909 if (PyErr_Occurred()) SWIG_fail;
16910 }
16911 {
16912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16913 }
16914 return resultobj;
16915 fail:
16916 return NULL;
16917 }
16918
16919
16920 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16921 PyObject *resultobj = 0;
16922 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16923 int arg2 = (int) wxJOY_BUTTON_ANY ;
16924 bool result;
16925 void *argp1 = 0 ;
16926 int res1 = 0 ;
16927 int val2 ;
16928 int ecode2 = 0 ;
16929 PyObject * obj0 = 0 ;
16930 PyObject * obj1 = 0 ;
16931 char * kwnames[] = {
16932 (char *) "self",(char *) "but", NULL
16933 };
16934
16935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
16936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16937 if (!SWIG_IsOK(res1)) {
16938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16939 }
16940 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16941 if (obj1) {
16942 ecode2 = SWIG_AsVal_int(obj1, &val2);
16943 if (!SWIG_IsOK(ecode2)) {
16944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
16945 }
16946 arg2 = static_cast< int >(val2);
16947 }
16948 {
16949 PyThreadState* __tstate = wxPyBeginAllowThreads();
16950 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
16951 wxPyEndAllowThreads(__tstate);
16952 if (PyErr_Occurred()) SWIG_fail;
16953 }
16954 {
16955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16956 }
16957 return resultobj;
16958 fail:
16959 return NULL;
16960 }
16961
16962
16963 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16964 PyObject *resultobj = 0;
16965 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16966 int arg2 = (int) wxJOY_BUTTON_ANY ;
16967 bool result;
16968 void *argp1 = 0 ;
16969 int res1 = 0 ;
16970 int val2 ;
16971 int ecode2 = 0 ;
16972 PyObject * obj0 = 0 ;
16973 PyObject * obj1 = 0 ;
16974 char * kwnames[] = {
16975 (char *) "self",(char *) "but", NULL
16976 };
16977
16978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
16979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16980 if (!SWIG_IsOK(res1)) {
16981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16982 }
16983 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16984 if (obj1) {
16985 ecode2 = SWIG_AsVal_int(obj1, &val2);
16986 if (!SWIG_IsOK(ecode2)) {
16987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
16988 }
16989 arg2 = static_cast< int >(val2);
16990 }
16991 {
16992 PyThreadState* __tstate = wxPyBeginAllowThreads();
16993 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
16994 wxPyEndAllowThreads(__tstate);
16995 if (PyErr_Occurred()) SWIG_fail;
16996 }
16997 {
16998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16999 }
17000 return resultobj;
17001 fail:
17002 return NULL;
17003 }
17004
17005
17006 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17007 PyObject *resultobj = 0;
17008 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17009 int arg2 = (int) wxJOY_BUTTON_ANY ;
17010 bool result;
17011 void *argp1 = 0 ;
17012 int res1 = 0 ;
17013 int val2 ;
17014 int ecode2 = 0 ;
17015 PyObject * obj0 = 0 ;
17016 PyObject * obj1 = 0 ;
17017 char * kwnames[] = {
17018 (char *) "self",(char *) "but", NULL
17019 };
17020
17021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17023 if (!SWIG_IsOK(res1)) {
17024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17025 }
17026 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17027 if (obj1) {
17028 ecode2 = SWIG_AsVal_int(obj1, &val2);
17029 if (!SWIG_IsOK(ecode2)) {
17030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17031 }
17032 arg2 = static_cast< int >(val2);
17033 }
17034 {
17035 PyThreadState* __tstate = wxPyBeginAllowThreads();
17036 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17037 wxPyEndAllowThreads(__tstate);
17038 if (PyErr_Occurred()) SWIG_fail;
17039 }
17040 {
17041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17042 }
17043 return resultobj;
17044 fail:
17045 return NULL;
17046 }
17047
17048
17049 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17050 PyObject *obj;
17051 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17052 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17053 return SWIG_Py_Void();
17054 }
17055
17056 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17057 return SWIG_Python_InitShadowInstance(args);
17058 }
17059
17060 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17061 PyObject *resultobj = 0;
17062 wxString const &arg1_defvalue = wxPyEmptyString ;
17063 wxString *arg1 = (wxString *) &arg1_defvalue ;
17064 wxSound *result = 0 ;
17065 bool temp1 = false ;
17066 PyObject * obj0 = 0 ;
17067 char * kwnames[] = {
17068 (char *) "fileName", NULL
17069 };
17070
17071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17072 if (obj0) {
17073 {
17074 arg1 = wxString_in_helper(obj0);
17075 if (arg1 == NULL) SWIG_fail;
17076 temp1 = true;
17077 }
17078 }
17079 {
17080 if (!wxPyCheckForApp()) SWIG_fail;
17081 PyThreadState* __tstate = wxPyBeginAllowThreads();
17082 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17083 wxPyEndAllowThreads(__tstate);
17084 if (PyErr_Occurred()) SWIG_fail;
17085 }
17086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17087 {
17088 if (temp1)
17089 delete arg1;
17090 }
17091 return resultobj;
17092 fail:
17093 {
17094 if (temp1)
17095 delete arg1;
17096 }
17097 return NULL;
17098 }
17099
17100
17101 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17102 PyObject *resultobj = 0;
17103 PyObject *arg1 = (PyObject *) 0 ;
17104 wxSound *result = 0 ;
17105 PyObject * obj0 = 0 ;
17106 char * kwnames[] = {
17107 (char *) "data", NULL
17108 };
17109
17110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17111 arg1 = obj0;
17112 {
17113 if (!wxPyCheckForApp()) SWIG_fail;
17114 PyThreadState* __tstate = wxPyBeginAllowThreads();
17115 result = (wxSound *)new_wxSound(arg1);
17116 wxPyEndAllowThreads(__tstate);
17117 if (PyErr_Occurred()) SWIG_fail;
17118 }
17119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17120 return resultobj;
17121 fail:
17122 return NULL;
17123 }
17124
17125
17126 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17127 PyObject *resultobj = 0;
17128 wxSound *arg1 = (wxSound *) 0 ;
17129 void *argp1 = 0 ;
17130 int res1 = 0 ;
17131 PyObject *swig_obj[1] ;
17132
17133 if (!args) SWIG_fail;
17134 swig_obj[0] = args;
17135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17136 if (!SWIG_IsOK(res1)) {
17137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17138 }
17139 arg1 = reinterpret_cast< wxSound * >(argp1);
17140 {
17141 PyThreadState* __tstate = wxPyBeginAllowThreads();
17142 delete arg1;
17143
17144 wxPyEndAllowThreads(__tstate);
17145 if (PyErr_Occurred()) SWIG_fail;
17146 }
17147 resultobj = SWIG_Py_Void();
17148 return resultobj;
17149 fail:
17150 return NULL;
17151 }
17152
17153
17154 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17155 PyObject *resultobj = 0;
17156 wxSound *arg1 = (wxSound *) 0 ;
17157 wxString *arg2 = 0 ;
17158 bool result;
17159 void *argp1 = 0 ;
17160 int res1 = 0 ;
17161 bool temp2 = false ;
17162 PyObject * obj0 = 0 ;
17163 PyObject * obj1 = 0 ;
17164 char * kwnames[] = {
17165 (char *) "self",(char *) "fileName", NULL
17166 };
17167
17168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17170 if (!SWIG_IsOK(res1)) {
17171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17172 }
17173 arg1 = reinterpret_cast< wxSound * >(argp1);
17174 {
17175 arg2 = wxString_in_helper(obj1);
17176 if (arg2 == NULL) SWIG_fail;
17177 temp2 = true;
17178 }
17179 {
17180 PyThreadState* __tstate = wxPyBeginAllowThreads();
17181 result = (bool)(arg1)->Create((wxString const &)*arg2);
17182 wxPyEndAllowThreads(__tstate);
17183 if (PyErr_Occurred()) SWIG_fail;
17184 }
17185 {
17186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17187 }
17188 {
17189 if (temp2)
17190 delete arg2;
17191 }
17192 return resultobj;
17193 fail:
17194 {
17195 if (temp2)
17196 delete arg2;
17197 }
17198 return NULL;
17199 }
17200
17201
17202 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17203 PyObject *resultobj = 0;
17204 wxSound *arg1 = (wxSound *) 0 ;
17205 PyObject *arg2 = (PyObject *) 0 ;
17206 bool result;
17207 void *argp1 = 0 ;
17208 int res1 = 0 ;
17209 PyObject * obj0 = 0 ;
17210 PyObject * obj1 = 0 ;
17211 char * kwnames[] = {
17212 (char *) "self",(char *) "data", NULL
17213 };
17214
17215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17217 if (!SWIG_IsOK(res1)) {
17218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17219 }
17220 arg1 = reinterpret_cast< wxSound * >(argp1);
17221 arg2 = obj1;
17222 {
17223 PyThreadState* __tstate = wxPyBeginAllowThreads();
17224 result = (bool)wxSound_CreateFromData(arg1,arg2);
17225 wxPyEndAllowThreads(__tstate);
17226 if (PyErr_Occurred()) SWIG_fail;
17227 }
17228 {
17229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17230 }
17231 return resultobj;
17232 fail:
17233 return NULL;
17234 }
17235
17236
17237 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17238 PyObject *resultobj = 0;
17239 wxSound *arg1 = (wxSound *) 0 ;
17240 bool result;
17241 void *argp1 = 0 ;
17242 int res1 = 0 ;
17243 PyObject *swig_obj[1] ;
17244
17245 if (!args) SWIG_fail;
17246 swig_obj[0] = args;
17247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17248 if (!SWIG_IsOK(res1)) {
17249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17250 }
17251 arg1 = reinterpret_cast< wxSound * >(argp1);
17252 {
17253 PyThreadState* __tstate = wxPyBeginAllowThreads();
17254 result = (bool)(arg1)->IsOk();
17255 wxPyEndAllowThreads(__tstate);
17256 if (PyErr_Occurred()) SWIG_fail;
17257 }
17258 {
17259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17260 }
17261 return resultobj;
17262 fail:
17263 return NULL;
17264 }
17265
17266
17267 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17268 PyObject *resultobj = 0;
17269 wxSound *arg1 = (wxSound *) 0 ;
17270 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17271 bool result;
17272 void *argp1 = 0 ;
17273 int res1 = 0 ;
17274 unsigned int val2 ;
17275 int ecode2 = 0 ;
17276 PyObject * obj0 = 0 ;
17277 PyObject * obj1 = 0 ;
17278 char * kwnames[] = {
17279 (char *) "self",(char *) "flags", NULL
17280 };
17281
17282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17284 if (!SWIG_IsOK(res1)) {
17285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17286 }
17287 arg1 = reinterpret_cast< wxSound * >(argp1);
17288 if (obj1) {
17289 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17290 if (!SWIG_IsOK(ecode2)) {
17291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17292 }
17293 arg2 = static_cast< unsigned int >(val2);
17294 }
17295 {
17296 if (!wxPyCheckForApp()) SWIG_fail;
17297 PyThreadState* __tstate = wxPyBeginAllowThreads();
17298 result = (bool)((wxSound const *)arg1)->Play(arg2);
17299 wxPyEndAllowThreads(__tstate);
17300 if (PyErr_Occurred()) SWIG_fail;
17301 }
17302 {
17303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17304 }
17305 return resultobj;
17306 fail:
17307 return NULL;
17308 }
17309
17310
17311 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17312 PyObject *resultobj = 0;
17313 wxString *arg1 = 0 ;
17314 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17315 bool result;
17316 bool temp1 = false ;
17317 unsigned int val2 ;
17318 int ecode2 = 0 ;
17319 PyObject * obj0 = 0 ;
17320 PyObject * obj1 = 0 ;
17321 char * kwnames[] = {
17322 (char *) "filename",(char *) "flags", NULL
17323 };
17324
17325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17326 {
17327 arg1 = wxString_in_helper(obj0);
17328 if (arg1 == NULL) SWIG_fail;
17329 temp1 = true;
17330 }
17331 if (obj1) {
17332 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17333 if (!SWIG_IsOK(ecode2)) {
17334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17335 }
17336 arg2 = static_cast< unsigned int >(val2);
17337 }
17338 {
17339 if (!wxPyCheckForApp()) SWIG_fail;
17340 PyThreadState* __tstate = wxPyBeginAllowThreads();
17341 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17342 wxPyEndAllowThreads(__tstate);
17343 if (PyErr_Occurred()) SWIG_fail;
17344 }
17345 {
17346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17347 }
17348 {
17349 if (temp1)
17350 delete arg1;
17351 }
17352 return resultobj;
17353 fail:
17354 {
17355 if (temp1)
17356 delete arg1;
17357 }
17358 return NULL;
17359 }
17360
17361
17362 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17363 PyObject *resultobj = 0;
17364
17365 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17366 {
17367 if (!wxPyCheckForApp()) SWIG_fail;
17368 PyThreadState* __tstate = wxPyBeginAllowThreads();
17369 wxSound::Stop();
17370 wxPyEndAllowThreads(__tstate);
17371 if (PyErr_Occurred()) SWIG_fail;
17372 }
17373 resultobj = SWIG_Py_Void();
17374 return resultobj;
17375 fail:
17376 return NULL;
17377 }
17378
17379
17380 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17381 PyObject *obj;
17382 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17383 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17384 return SWIG_Py_Void();
17385 }
17386
17387 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17388 return SWIG_Python_InitShadowInstance(args);
17389 }
17390
17391 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17392 PyObject *resultobj = 0;
17393 wxString *arg1 = 0 ;
17394 wxString *arg2 = 0 ;
17395 wxString *arg3 = 0 ;
17396 wxString *arg4 = 0 ;
17397 wxFileTypeInfo *result = 0 ;
17398 bool temp1 = false ;
17399 bool temp2 = false ;
17400 bool temp3 = false ;
17401 bool temp4 = false ;
17402 PyObject * obj0 = 0 ;
17403 PyObject * obj1 = 0 ;
17404 PyObject * obj2 = 0 ;
17405 PyObject * obj3 = 0 ;
17406 char * kwnames[] = {
17407 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17408 };
17409
17410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17411 {
17412 arg1 = wxString_in_helper(obj0);
17413 if (arg1 == NULL) SWIG_fail;
17414 temp1 = true;
17415 }
17416 {
17417 arg2 = wxString_in_helper(obj1);
17418 if (arg2 == NULL) SWIG_fail;
17419 temp2 = true;
17420 }
17421 {
17422 arg3 = wxString_in_helper(obj2);
17423 if (arg3 == NULL) SWIG_fail;
17424 temp3 = true;
17425 }
17426 {
17427 arg4 = wxString_in_helper(obj3);
17428 if (arg4 == NULL) SWIG_fail;
17429 temp4 = true;
17430 }
17431 {
17432 PyThreadState* __tstate = wxPyBeginAllowThreads();
17433 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17434 wxPyEndAllowThreads(__tstate);
17435 if (PyErr_Occurred()) SWIG_fail;
17436 }
17437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17438 {
17439 if (temp1)
17440 delete arg1;
17441 }
17442 {
17443 if (temp2)
17444 delete arg2;
17445 }
17446 {
17447 if (temp3)
17448 delete arg3;
17449 }
17450 {
17451 if (temp4)
17452 delete arg4;
17453 }
17454 return resultobj;
17455 fail:
17456 {
17457 if (temp1)
17458 delete arg1;
17459 }
17460 {
17461 if (temp2)
17462 delete arg2;
17463 }
17464 {
17465 if (temp3)
17466 delete arg3;
17467 }
17468 {
17469 if (temp4)
17470 delete arg4;
17471 }
17472 return NULL;
17473 }
17474
17475
17476 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17477 PyObject *resultobj = 0;
17478 wxArrayString *arg1 = 0 ;
17479 wxFileTypeInfo *result = 0 ;
17480 bool temp1 = false ;
17481 PyObject * obj0 = 0 ;
17482 char * kwnames[] = {
17483 (char *) "sArray", NULL
17484 };
17485
17486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17487 {
17488 if (! PySequence_Check(obj0)) {
17489 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17490 SWIG_fail;
17491 }
17492 arg1 = new wxArrayString;
17493 temp1 = true;
17494 int i, len=PySequence_Length(obj0);
17495 for (i=0; i<len; i++) {
17496 PyObject* item = PySequence_GetItem(obj0, i);
17497 wxString* s = wxString_in_helper(item);
17498 if (PyErr_Occurred()) SWIG_fail;
17499 arg1->Add(*s);
17500 delete s;
17501 Py_DECREF(item);
17502 }
17503 }
17504 {
17505 PyThreadState* __tstate = wxPyBeginAllowThreads();
17506 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17507 wxPyEndAllowThreads(__tstate);
17508 if (PyErr_Occurred()) SWIG_fail;
17509 }
17510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17511 {
17512 if (temp1) delete arg1;
17513 }
17514 return resultobj;
17515 fail:
17516 {
17517 if (temp1) delete arg1;
17518 }
17519 return NULL;
17520 }
17521
17522
17523 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17524 PyObject *resultobj = 0;
17525 wxFileTypeInfo *result = 0 ;
17526
17527 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17528 {
17529 PyThreadState* __tstate = wxPyBeginAllowThreads();
17530 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17531 wxPyEndAllowThreads(__tstate);
17532 if (PyErr_Occurred()) SWIG_fail;
17533 }
17534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17535 return resultobj;
17536 fail:
17537 return NULL;
17538 }
17539
17540
17541 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17542 PyObject *resultobj = 0;
17543 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17544 bool result;
17545 void *argp1 = 0 ;
17546 int res1 = 0 ;
17547 PyObject *swig_obj[1] ;
17548
17549 if (!args) SWIG_fail;
17550 swig_obj[0] = args;
17551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17552 if (!SWIG_IsOK(res1)) {
17553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17554 }
17555 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17556 {
17557 PyThreadState* __tstate = wxPyBeginAllowThreads();
17558 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17559 wxPyEndAllowThreads(__tstate);
17560 if (PyErr_Occurred()) SWIG_fail;
17561 }
17562 {
17563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17564 }
17565 return resultobj;
17566 fail:
17567 return NULL;
17568 }
17569
17570
17571 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17572 PyObject *resultobj = 0;
17573 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17574 wxString *arg2 = 0 ;
17575 int arg3 = (int) 0 ;
17576 void *argp1 = 0 ;
17577 int res1 = 0 ;
17578 bool temp2 = false ;
17579 int val3 ;
17580 int ecode3 = 0 ;
17581 PyObject * obj0 = 0 ;
17582 PyObject * obj1 = 0 ;
17583 PyObject * obj2 = 0 ;
17584 char * kwnames[] = {
17585 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17586 };
17587
17588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17590 if (!SWIG_IsOK(res1)) {
17591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17592 }
17593 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17594 {
17595 arg2 = wxString_in_helper(obj1);
17596 if (arg2 == NULL) SWIG_fail;
17597 temp2 = true;
17598 }
17599 if (obj2) {
17600 ecode3 = SWIG_AsVal_int(obj2, &val3);
17601 if (!SWIG_IsOK(ecode3)) {
17602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17603 }
17604 arg3 = static_cast< int >(val3);
17605 }
17606 {
17607 PyThreadState* __tstate = wxPyBeginAllowThreads();
17608 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17609 wxPyEndAllowThreads(__tstate);
17610 if (PyErr_Occurred()) SWIG_fail;
17611 }
17612 resultobj = SWIG_Py_Void();
17613 {
17614 if (temp2)
17615 delete arg2;
17616 }
17617 return resultobj;
17618 fail:
17619 {
17620 if (temp2)
17621 delete arg2;
17622 }
17623 return NULL;
17624 }
17625
17626
17627 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17628 PyObject *resultobj = 0;
17629 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17630 wxString *arg2 = 0 ;
17631 void *argp1 = 0 ;
17632 int res1 = 0 ;
17633 bool temp2 = false ;
17634 PyObject * obj0 = 0 ;
17635 PyObject * obj1 = 0 ;
17636 char * kwnames[] = {
17637 (char *) "self",(char *) "shortDesc", NULL
17638 };
17639
17640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17642 if (!SWIG_IsOK(res1)) {
17643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17644 }
17645 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17646 {
17647 arg2 = wxString_in_helper(obj1);
17648 if (arg2 == NULL) SWIG_fail;
17649 temp2 = true;
17650 }
17651 {
17652 PyThreadState* __tstate = wxPyBeginAllowThreads();
17653 (arg1)->SetShortDesc((wxString const &)*arg2);
17654 wxPyEndAllowThreads(__tstate);
17655 if (PyErr_Occurred()) SWIG_fail;
17656 }
17657 resultobj = SWIG_Py_Void();
17658 {
17659 if (temp2)
17660 delete arg2;
17661 }
17662 return resultobj;
17663 fail:
17664 {
17665 if (temp2)
17666 delete arg2;
17667 }
17668 return NULL;
17669 }
17670
17671
17672 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17673 PyObject *resultobj = 0;
17674 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17675 wxString *result = 0 ;
17676 void *argp1 = 0 ;
17677 int res1 = 0 ;
17678 PyObject *swig_obj[1] ;
17679
17680 if (!args) SWIG_fail;
17681 swig_obj[0] = args;
17682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17683 if (!SWIG_IsOK(res1)) {
17684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17685 }
17686 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17687 {
17688 PyThreadState* __tstate = wxPyBeginAllowThreads();
17689 {
17690 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17691 result = (wxString *) &_result_ref;
17692 }
17693 wxPyEndAllowThreads(__tstate);
17694 if (PyErr_Occurred()) SWIG_fail;
17695 }
17696 {
17697 #if wxUSE_UNICODE
17698 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17699 #else
17700 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17701 #endif
17702 }
17703 return resultobj;
17704 fail:
17705 return NULL;
17706 }
17707
17708
17709 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17710 PyObject *resultobj = 0;
17711 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17712 wxString *result = 0 ;
17713 void *argp1 = 0 ;
17714 int res1 = 0 ;
17715 PyObject *swig_obj[1] ;
17716
17717 if (!args) SWIG_fail;
17718 swig_obj[0] = args;
17719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17720 if (!SWIG_IsOK(res1)) {
17721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17722 }
17723 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17724 {
17725 PyThreadState* __tstate = wxPyBeginAllowThreads();
17726 {
17727 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17728 result = (wxString *) &_result_ref;
17729 }
17730 wxPyEndAllowThreads(__tstate);
17731 if (PyErr_Occurred()) SWIG_fail;
17732 }
17733 {
17734 #if wxUSE_UNICODE
17735 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17736 #else
17737 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17738 #endif
17739 }
17740 return resultobj;
17741 fail:
17742 return NULL;
17743 }
17744
17745
17746 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17747 PyObject *resultobj = 0;
17748 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17749 wxString *result = 0 ;
17750 void *argp1 = 0 ;
17751 int res1 = 0 ;
17752 PyObject *swig_obj[1] ;
17753
17754 if (!args) SWIG_fail;
17755 swig_obj[0] = args;
17756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17757 if (!SWIG_IsOK(res1)) {
17758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17759 }
17760 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17761 {
17762 PyThreadState* __tstate = wxPyBeginAllowThreads();
17763 {
17764 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17765 result = (wxString *) &_result_ref;
17766 }
17767 wxPyEndAllowThreads(__tstate);
17768 if (PyErr_Occurred()) SWIG_fail;
17769 }
17770 {
17771 #if wxUSE_UNICODE
17772 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17773 #else
17774 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17775 #endif
17776 }
17777 return resultobj;
17778 fail:
17779 return NULL;
17780 }
17781
17782
17783 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17784 PyObject *resultobj = 0;
17785 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17786 wxString *result = 0 ;
17787 void *argp1 = 0 ;
17788 int res1 = 0 ;
17789 PyObject *swig_obj[1] ;
17790
17791 if (!args) SWIG_fail;
17792 swig_obj[0] = args;
17793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17794 if (!SWIG_IsOK(res1)) {
17795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17796 }
17797 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17798 {
17799 PyThreadState* __tstate = wxPyBeginAllowThreads();
17800 {
17801 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17802 result = (wxString *) &_result_ref;
17803 }
17804 wxPyEndAllowThreads(__tstate);
17805 if (PyErr_Occurred()) SWIG_fail;
17806 }
17807 {
17808 #if wxUSE_UNICODE
17809 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17810 #else
17811 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17812 #endif
17813 }
17814 return resultobj;
17815 fail:
17816 return NULL;
17817 }
17818
17819
17820 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17821 PyObject *resultobj = 0;
17822 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17823 wxString *result = 0 ;
17824 void *argp1 = 0 ;
17825 int res1 = 0 ;
17826 PyObject *swig_obj[1] ;
17827
17828 if (!args) SWIG_fail;
17829 swig_obj[0] = args;
17830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17831 if (!SWIG_IsOK(res1)) {
17832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17833 }
17834 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17835 {
17836 PyThreadState* __tstate = wxPyBeginAllowThreads();
17837 {
17838 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17839 result = (wxString *) &_result_ref;
17840 }
17841 wxPyEndAllowThreads(__tstate);
17842 if (PyErr_Occurred()) SWIG_fail;
17843 }
17844 {
17845 #if wxUSE_UNICODE
17846 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17847 #else
17848 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17849 #endif
17850 }
17851 return resultobj;
17852 fail:
17853 return NULL;
17854 }
17855
17856
17857 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17858 PyObject *resultobj = 0;
17859 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17860 wxArrayString *result = 0 ;
17861 void *argp1 = 0 ;
17862 int res1 = 0 ;
17863 PyObject *swig_obj[1] ;
17864
17865 if (!args) SWIG_fail;
17866 swig_obj[0] = args;
17867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17868 if (!SWIG_IsOK(res1)) {
17869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17870 }
17871 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17872 {
17873 PyThreadState* __tstate = wxPyBeginAllowThreads();
17874 {
17875 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17876 result = (wxArrayString *) &_result_ref;
17877 }
17878 wxPyEndAllowThreads(__tstate);
17879 if (PyErr_Occurred()) SWIG_fail;
17880 }
17881 {
17882 resultobj = wxArrayString2PyList_helper(*result);
17883 }
17884 return resultobj;
17885 fail:
17886 return NULL;
17887 }
17888
17889
17890 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17891 PyObject *resultobj = 0;
17892 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17893 size_t result;
17894 void *argp1 = 0 ;
17895 int res1 = 0 ;
17896 PyObject *swig_obj[1] ;
17897
17898 if (!args) SWIG_fail;
17899 swig_obj[0] = args;
17900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17901 if (!SWIG_IsOK(res1)) {
17902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17903 }
17904 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17905 {
17906 PyThreadState* __tstate = wxPyBeginAllowThreads();
17907 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17908 wxPyEndAllowThreads(__tstate);
17909 if (PyErr_Occurred()) SWIG_fail;
17910 }
17911 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17912 return resultobj;
17913 fail:
17914 return NULL;
17915 }
17916
17917
17918 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17919 PyObject *resultobj = 0;
17920 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17921 wxString *result = 0 ;
17922 void *argp1 = 0 ;
17923 int res1 = 0 ;
17924 PyObject *swig_obj[1] ;
17925
17926 if (!args) SWIG_fail;
17927 swig_obj[0] = args;
17928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17929 if (!SWIG_IsOK(res1)) {
17930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17931 }
17932 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17933 {
17934 PyThreadState* __tstate = wxPyBeginAllowThreads();
17935 {
17936 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
17937 result = (wxString *) &_result_ref;
17938 }
17939 wxPyEndAllowThreads(__tstate);
17940 if (PyErr_Occurred()) SWIG_fail;
17941 }
17942 {
17943 #if wxUSE_UNICODE
17944 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17945 #else
17946 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17947 #endif
17948 }
17949 return resultobj;
17950 fail:
17951 return NULL;
17952 }
17953
17954
17955 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17956 PyObject *resultobj = 0;
17957 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17958 int result;
17959 void *argp1 = 0 ;
17960 int res1 = 0 ;
17961 PyObject *swig_obj[1] ;
17962
17963 if (!args) SWIG_fail;
17964 swig_obj[0] = args;
17965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17966 if (!SWIG_IsOK(res1)) {
17967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17968 }
17969 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17970 {
17971 PyThreadState* __tstate = wxPyBeginAllowThreads();
17972 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
17973 wxPyEndAllowThreads(__tstate);
17974 if (PyErr_Occurred()) SWIG_fail;
17975 }
17976 resultobj = SWIG_From_int(static_cast< int >(result));
17977 return resultobj;
17978 fail:
17979 return NULL;
17980 }
17981
17982
17983 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17984 PyObject *obj;
17985 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17986 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
17987 return SWIG_Py_Void();
17988 }
17989
17990 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17991 return SWIG_Python_InitShadowInstance(args);
17992 }
17993
17994 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17995 PyObject *resultobj = 0;
17996 wxFileTypeInfo *arg1 = 0 ;
17997 wxFileType *result = 0 ;
17998 void *argp1 = 0 ;
17999 int res1 = 0 ;
18000 PyObject * obj0 = 0 ;
18001 char * kwnames[] = {
18002 (char *) "ftInfo", NULL
18003 };
18004
18005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18006 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18007 if (!SWIG_IsOK(res1)) {
18008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18009 }
18010 if (!argp1) {
18011 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18012 }
18013 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18014 {
18015 PyThreadState* __tstate = wxPyBeginAllowThreads();
18016 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18017 wxPyEndAllowThreads(__tstate);
18018 if (PyErr_Occurred()) SWIG_fail;
18019 }
18020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18021 return resultobj;
18022 fail:
18023 return NULL;
18024 }
18025
18026
18027 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18028 PyObject *resultobj = 0;
18029 wxFileType *arg1 = (wxFileType *) 0 ;
18030 void *argp1 = 0 ;
18031 int res1 = 0 ;
18032 PyObject *swig_obj[1] ;
18033
18034 if (!args) SWIG_fail;
18035 swig_obj[0] = args;
18036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18037 if (!SWIG_IsOK(res1)) {
18038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18039 }
18040 arg1 = reinterpret_cast< wxFileType * >(argp1);
18041 {
18042 PyThreadState* __tstate = wxPyBeginAllowThreads();
18043 delete arg1;
18044
18045 wxPyEndAllowThreads(__tstate);
18046 if (PyErr_Occurred()) SWIG_fail;
18047 }
18048 resultobj = SWIG_Py_Void();
18049 return resultobj;
18050 fail:
18051 return NULL;
18052 }
18053
18054
18055 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18056 PyObject *resultobj = 0;
18057 wxFileType *arg1 = (wxFileType *) 0 ;
18058 PyObject *result = 0 ;
18059 void *argp1 = 0 ;
18060 int res1 = 0 ;
18061 PyObject *swig_obj[1] ;
18062
18063 if (!args) SWIG_fail;
18064 swig_obj[0] = args;
18065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18066 if (!SWIG_IsOK(res1)) {
18067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18068 }
18069 arg1 = reinterpret_cast< wxFileType * >(argp1);
18070 {
18071 PyThreadState* __tstate = wxPyBeginAllowThreads();
18072 result = (PyObject *)wxFileType_GetMimeType(arg1);
18073 wxPyEndAllowThreads(__tstate);
18074 if (PyErr_Occurred()) SWIG_fail;
18075 }
18076 resultobj = result;
18077 return resultobj;
18078 fail:
18079 return NULL;
18080 }
18081
18082
18083 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18084 PyObject *resultobj = 0;
18085 wxFileType *arg1 = (wxFileType *) 0 ;
18086 PyObject *result = 0 ;
18087 void *argp1 = 0 ;
18088 int res1 = 0 ;
18089 PyObject *swig_obj[1] ;
18090
18091 if (!args) SWIG_fail;
18092 swig_obj[0] = args;
18093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18094 if (!SWIG_IsOK(res1)) {
18095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18096 }
18097 arg1 = reinterpret_cast< wxFileType * >(argp1);
18098 {
18099 PyThreadState* __tstate = wxPyBeginAllowThreads();
18100 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18101 wxPyEndAllowThreads(__tstate);
18102 if (PyErr_Occurred()) SWIG_fail;
18103 }
18104 resultobj = result;
18105 return resultobj;
18106 fail:
18107 return NULL;
18108 }
18109
18110
18111 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18112 PyObject *resultobj = 0;
18113 wxFileType *arg1 = (wxFileType *) 0 ;
18114 PyObject *result = 0 ;
18115 void *argp1 = 0 ;
18116 int res1 = 0 ;
18117 PyObject *swig_obj[1] ;
18118
18119 if (!args) SWIG_fail;
18120 swig_obj[0] = args;
18121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18122 if (!SWIG_IsOK(res1)) {
18123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18124 }
18125 arg1 = reinterpret_cast< wxFileType * >(argp1);
18126 {
18127 PyThreadState* __tstate = wxPyBeginAllowThreads();
18128 result = (PyObject *)wxFileType_GetExtensions(arg1);
18129 wxPyEndAllowThreads(__tstate);
18130 if (PyErr_Occurred()) SWIG_fail;
18131 }
18132 resultobj = result;
18133 return resultobj;
18134 fail:
18135 return NULL;
18136 }
18137
18138
18139 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18140 PyObject *resultobj = 0;
18141 wxFileType *arg1 = (wxFileType *) 0 ;
18142 wxIcon *result = 0 ;
18143 void *argp1 = 0 ;
18144 int res1 = 0 ;
18145 PyObject *swig_obj[1] ;
18146
18147 if (!args) SWIG_fail;
18148 swig_obj[0] = args;
18149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18150 if (!SWIG_IsOK(res1)) {
18151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18152 }
18153 arg1 = reinterpret_cast< wxFileType * >(argp1);
18154 {
18155 PyThreadState* __tstate = wxPyBeginAllowThreads();
18156 result = (wxIcon *)wxFileType_GetIcon(arg1);
18157 wxPyEndAllowThreads(__tstate);
18158 if (PyErr_Occurred()) SWIG_fail;
18159 }
18160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18161 return resultobj;
18162 fail:
18163 return NULL;
18164 }
18165
18166
18167 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18168 PyObject *resultobj = 0;
18169 wxFileType *arg1 = (wxFileType *) 0 ;
18170 PyObject *result = 0 ;
18171 void *argp1 = 0 ;
18172 int res1 = 0 ;
18173 PyObject *swig_obj[1] ;
18174
18175 if (!args) SWIG_fail;
18176 swig_obj[0] = args;
18177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18178 if (!SWIG_IsOK(res1)) {
18179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18180 }
18181 arg1 = reinterpret_cast< wxFileType * >(argp1);
18182 {
18183 PyThreadState* __tstate = wxPyBeginAllowThreads();
18184 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18185 wxPyEndAllowThreads(__tstate);
18186 if (PyErr_Occurred()) SWIG_fail;
18187 }
18188 resultobj = result;
18189 return resultobj;
18190 fail:
18191 return NULL;
18192 }
18193
18194
18195 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18196 PyObject *resultobj = 0;
18197 wxFileType *arg1 = (wxFileType *) 0 ;
18198 PyObject *result = 0 ;
18199 void *argp1 = 0 ;
18200 int res1 = 0 ;
18201 PyObject *swig_obj[1] ;
18202
18203 if (!args) SWIG_fail;
18204 swig_obj[0] = args;
18205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18206 if (!SWIG_IsOK(res1)) {
18207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18208 }
18209 arg1 = reinterpret_cast< wxFileType * >(argp1);
18210 {
18211 PyThreadState* __tstate = wxPyBeginAllowThreads();
18212 result = (PyObject *)wxFileType_GetDescription(arg1);
18213 wxPyEndAllowThreads(__tstate);
18214 if (PyErr_Occurred()) SWIG_fail;
18215 }
18216 resultobj = result;
18217 return resultobj;
18218 fail:
18219 return NULL;
18220 }
18221
18222
18223 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18224 PyObject *resultobj = 0;
18225 wxFileType *arg1 = (wxFileType *) 0 ;
18226 wxString *arg2 = 0 ;
18227 wxString const &arg3_defvalue = wxPyEmptyString ;
18228 wxString *arg3 = (wxString *) &arg3_defvalue ;
18229 PyObject *result = 0 ;
18230 void *argp1 = 0 ;
18231 int res1 = 0 ;
18232 bool temp2 = false ;
18233 bool temp3 = false ;
18234 PyObject * obj0 = 0 ;
18235 PyObject * obj1 = 0 ;
18236 PyObject * obj2 = 0 ;
18237 char * kwnames[] = {
18238 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18239 };
18240
18241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18243 if (!SWIG_IsOK(res1)) {
18244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18245 }
18246 arg1 = reinterpret_cast< wxFileType * >(argp1);
18247 {
18248 arg2 = wxString_in_helper(obj1);
18249 if (arg2 == NULL) SWIG_fail;
18250 temp2 = true;
18251 }
18252 if (obj2) {
18253 {
18254 arg3 = wxString_in_helper(obj2);
18255 if (arg3 == NULL) SWIG_fail;
18256 temp3 = true;
18257 }
18258 }
18259 {
18260 PyThreadState* __tstate = wxPyBeginAllowThreads();
18261 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18262 wxPyEndAllowThreads(__tstate);
18263 if (PyErr_Occurred()) SWIG_fail;
18264 }
18265 resultobj = result;
18266 {
18267 if (temp2)
18268 delete arg2;
18269 }
18270 {
18271 if (temp3)
18272 delete arg3;
18273 }
18274 return resultobj;
18275 fail:
18276 {
18277 if (temp2)
18278 delete arg2;
18279 }
18280 {
18281 if (temp3)
18282 delete arg3;
18283 }
18284 return NULL;
18285 }
18286
18287
18288 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18289 PyObject *resultobj = 0;
18290 wxFileType *arg1 = (wxFileType *) 0 ;
18291 wxString *arg2 = 0 ;
18292 wxString const &arg3_defvalue = wxPyEmptyString ;
18293 wxString *arg3 = (wxString *) &arg3_defvalue ;
18294 PyObject *result = 0 ;
18295 void *argp1 = 0 ;
18296 int res1 = 0 ;
18297 bool temp2 = false ;
18298 bool temp3 = false ;
18299 PyObject * obj0 = 0 ;
18300 PyObject * obj1 = 0 ;
18301 PyObject * obj2 = 0 ;
18302 char * kwnames[] = {
18303 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18304 };
18305
18306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18308 if (!SWIG_IsOK(res1)) {
18309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18310 }
18311 arg1 = reinterpret_cast< wxFileType * >(argp1);
18312 {
18313 arg2 = wxString_in_helper(obj1);
18314 if (arg2 == NULL) SWIG_fail;
18315 temp2 = true;
18316 }
18317 if (obj2) {
18318 {
18319 arg3 = wxString_in_helper(obj2);
18320 if (arg3 == NULL) SWIG_fail;
18321 temp3 = true;
18322 }
18323 }
18324 {
18325 PyThreadState* __tstate = wxPyBeginAllowThreads();
18326 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18327 wxPyEndAllowThreads(__tstate);
18328 if (PyErr_Occurred()) SWIG_fail;
18329 }
18330 resultobj = result;
18331 {
18332 if (temp2)
18333 delete arg2;
18334 }
18335 {
18336 if (temp3)
18337 delete arg3;
18338 }
18339 return resultobj;
18340 fail:
18341 {
18342 if (temp2)
18343 delete arg2;
18344 }
18345 {
18346 if (temp3)
18347 delete arg3;
18348 }
18349 return NULL;
18350 }
18351
18352
18353 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18354 PyObject *resultobj = 0;
18355 wxFileType *arg1 = (wxFileType *) 0 ;
18356 wxString *arg2 = 0 ;
18357 wxString const &arg3_defvalue = wxPyEmptyString ;
18358 wxString *arg3 = (wxString *) &arg3_defvalue ;
18359 PyObject *result = 0 ;
18360 void *argp1 = 0 ;
18361 int res1 = 0 ;
18362 bool temp2 = false ;
18363 bool temp3 = false ;
18364 PyObject * obj0 = 0 ;
18365 PyObject * obj1 = 0 ;
18366 PyObject * obj2 = 0 ;
18367 char * kwnames[] = {
18368 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18369 };
18370
18371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18373 if (!SWIG_IsOK(res1)) {
18374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18375 }
18376 arg1 = reinterpret_cast< wxFileType * >(argp1);
18377 {
18378 arg2 = wxString_in_helper(obj1);
18379 if (arg2 == NULL) SWIG_fail;
18380 temp2 = true;
18381 }
18382 if (obj2) {
18383 {
18384 arg3 = wxString_in_helper(obj2);
18385 if (arg3 == NULL) SWIG_fail;
18386 temp3 = true;
18387 }
18388 }
18389 {
18390 PyThreadState* __tstate = wxPyBeginAllowThreads();
18391 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18392 wxPyEndAllowThreads(__tstate);
18393 if (PyErr_Occurred()) SWIG_fail;
18394 }
18395 resultobj = result;
18396 {
18397 if (temp2)
18398 delete arg2;
18399 }
18400 {
18401 if (temp3)
18402 delete arg3;
18403 }
18404 return resultobj;
18405 fail:
18406 {
18407 if (temp2)
18408 delete arg2;
18409 }
18410 {
18411 if (temp3)
18412 delete arg3;
18413 }
18414 return NULL;
18415 }
18416
18417
18418 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18419 PyObject *resultobj = 0;
18420 wxFileType *arg1 = (wxFileType *) 0 ;
18421 wxString *arg2 = 0 ;
18422 wxString *arg3 = 0 ;
18423 bool arg4 = (bool) true ;
18424 bool result;
18425 void *argp1 = 0 ;
18426 int res1 = 0 ;
18427 bool temp2 = false ;
18428 bool temp3 = false ;
18429 bool val4 ;
18430 int ecode4 = 0 ;
18431 PyObject * obj0 = 0 ;
18432 PyObject * obj1 = 0 ;
18433 PyObject * obj2 = 0 ;
18434 PyObject * obj3 = 0 ;
18435 char * kwnames[] = {
18436 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18437 };
18438
18439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18441 if (!SWIG_IsOK(res1)) {
18442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18443 }
18444 arg1 = reinterpret_cast< wxFileType * >(argp1);
18445 {
18446 arg2 = wxString_in_helper(obj1);
18447 if (arg2 == NULL) SWIG_fail;
18448 temp2 = true;
18449 }
18450 {
18451 arg3 = wxString_in_helper(obj2);
18452 if (arg3 == NULL) SWIG_fail;
18453 temp3 = true;
18454 }
18455 if (obj3) {
18456 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18457 if (!SWIG_IsOK(ecode4)) {
18458 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18459 }
18460 arg4 = static_cast< bool >(val4);
18461 }
18462 {
18463 PyThreadState* __tstate = wxPyBeginAllowThreads();
18464 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18465 wxPyEndAllowThreads(__tstate);
18466 if (PyErr_Occurred()) SWIG_fail;
18467 }
18468 {
18469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18470 }
18471 {
18472 if (temp2)
18473 delete arg2;
18474 }
18475 {
18476 if (temp3)
18477 delete arg3;
18478 }
18479 return resultobj;
18480 fail:
18481 {
18482 if (temp2)
18483 delete arg2;
18484 }
18485 {
18486 if (temp3)
18487 delete arg3;
18488 }
18489 return NULL;
18490 }
18491
18492
18493 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18494 PyObject *resultobj = 0;
18495 wxFileType *arg1 = (wxFileType *) 0 ;
18496 wxString const &arg2_defvalue = wxPyEmptyString ;
18497 wxString *arg2 = (wxString *) &arg2_defvalue ;
18498 int arg3 = (int) 0 ;
18499 bool result;
18500 void *argp1 = 0 ;
18501 int res1 = 0 ;
18502 bool temp2 = false ;
18503 int val3 ;
18504 int ecode3 = 0 ;
18505 PyObject * obj0 = 0 ;
18506 PyObject * obj1 = 0 ;
18507 PyObject * obj2 = 0 ;
18508 char * kwnames[] = {
18509 (char *) "self",(char *) "cmd",(char *) "index", NULL
18510 };
18511
18512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18514 if (!SWIG_IsOK(res1)) {
18515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18516 }
18517 arg1 = reinterpret_cast< wxFileType * >(argp1);
18518 if (obj1) {
18519 {
18520 arg2 = wxString_in_helper(obj1);
18521 if (arg2 == NULL) SWIG_fail;
18522 temp2 = true;
18523 }
18524 }
18525 if (obj2) {
18526 ecode3 = SWIG_AsVal_int(obj2, &val3);
18527 if (!SWIG_IsOK(ecode3)) {
18528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18529 }
18530 arg3 = static_cast< int >(val3);
18531 }
18532 {
18533 PyThreadState* __tstate = wxPyBeginAllowThreads();
18534 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18535 wxPyEndAllowThreads(__tstate);
18536 if (PyErr_Occurred()) SWIG_fail;
18537 }
18538 {
18539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18540 }
18541 {
18542 if (temp2)
18543 delete arg2;
18544 }
18545 return resultobj;
18546 fail:
18547 {
18548 if (temp2)
18549 delete arg2;
18550 }
18551 return NULL;
18552 }
18553
18554
18555 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18556 PyObject *resultobj = 0;
18557 wxFileType *arg1 = (wxFileType *) 0 ;
18558 bool result;
18559 void *argp1 = 0 ;
18560 int res1 = 0 ;
18561 PyObject *swig_obj[1] ;
18562
18563 if (!args) SWIG_fail;
18564 swig_obj[0] = args;
18565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18566 if (!SWIG_IsOK(res1)) {
18567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18568 }
18569 arg1 = reinterpret_cast< wxFileType * >(argp1);
18570 {
18571 PyThreadState* __tstate = wxPyBeginAllowThreads();
18572 result = (bool)(arg1)->Unassociate();
18573 wxPyEndAllowThreads(__tstate);
18574 if (PyErr_Occurred()) SWIG_fail;
18575 }
18576 {
18577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18578 }
18579 return resultobj;
18580 fail:
18581 return NULL;
18582 }
18583
18584
18585 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18586 PyObject *resultobj = 0;
18587 wxString *arg1 = 0 ;
18588 wxString *arg2 = 0 ;
18589 wxString const &arg3_defvalue = wxPyEmptyString ;
18590 wxString *arg3 = (wxString *) &arg3_defvalue ;
18591 wxString result;
18592 bool temp1 = false ;
18593 bool temp2 = false ;
18594 bool temp3 = false ;
18595 PyObject * obj0 = 0 ;
18596 PyObject * obj1 = 0 ;
18597 PyObject * obj2 = 0 ;
18598 char * kwnames[] = {
18599 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18600 };
18601
18602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18603 {
18604 arg1 = wxString_in_helper(obj0);
18605 if (arg1 == NULL) SWIG_fail;
18606 temp1 = true;
18607 }
18608 {
18609 arg2 = wxString_in_helper(obj1);
18610 if (arg2 == NULL) SWIG_fail;
18611 temp2 = true;
18612 }
18613 if (obj2) {
18614 {
18615 arg3 = wxString_in_helper(obj2);
18616 if (arg3 == NULL) SWIG_fail;
18617 temp3 = true;
18618 }
18619 }
18620 {
18621 PyThreadState* __tstate = wxPyBeginAllowThreads();
18622 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18623 wxPyEndAllowThreads(__tstate);
18624 if (PyErr_Occurred()) SWIG_fail;
18625 }
18626 {
18627 #if wxUSE_UNICODE
18628 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18629 #else
18630 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18631 #endif
18632 }
18633 {
18634 if (temp1)
18635 delete arg1;
18636 }
18637 {
18638 if (temp2)
18639 delete arg2;
18640 }
18641 {
18642 if (temp3)
18643 delete arg3;
18644 }
18645 return resultobj;
18646 fail:
18647 {
18648 if (temp1)
18649 delete arg1;
18650 }
18651 {
18652 if (temp2)
18653 delete arg2;
18654 }
18655 {
18656 if (temp3)
18657 delete arg3;
18658 }
18659 return NULL;
18660 }
18661
18662
18663 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18664 PyObject *obj;
18665 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18666 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18667 return SWIG_Py_Void();
18668 }
18669
18670 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18671 return SWIG_Python_InitShadowInstance(args);
18672 }
18673
18674 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18675 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18676 return 1;
18677 }
18678
18679
18680 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18681 PyObject *pyobj = 0;
18682
18683 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18684 return pyobj;
18685 }
18686
18687
18688 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18689 PyObject *resultobj = 0;
18690 wxString *arg1 = 0 ;
18691 wxString *arg2 = 0 ;
18692 bool result;
18693 bool temp1 = false ;
18694 bool temp2 = false ;
18695 PyObject * obj0 = 0 ;
18696 PyObject * obj1 = 0 ;
18697 char * kwnames[] = {
18698 (char *) "mimeType",(char *) "wildcard", NULL
18699 };
18700
18701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18702 {
18703 arg1 = wxString_in_helper(obj0);
18704 if (arg1 == NULL) SWIG_fail;
18705 temp1 = true;
18706 }
18707 {
18708 arg2 = wxString_in_helper(obj1);
18709 if (arg2 == NULL) SWIG_fail;
18710 temp2 = true;
18711 }
18712 {
18713 PyThreadState* __tstate = wxPyBeginAllowThreads();
18714 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18715 wxPyEndAllowThreads(__tstate);
18716 if (PyErr_Occurred()) SWIG_fail;
18717 }
18718 {
18719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18720 }
18721 {
18722 if (temp1)
18723 delete arg1;
18724 }
18725 {
18726 if (temp2)
18727 delete arg2;
18728 }
18729 return resultobj;
18730 fail:
18731 {
18732 if (temp1)
18733 delete arg1;
18734 }
18735 {
18736 if (temp2)
18737 delete arg2;
18738 }
18739 return NULL;
18740 }
18741
18742
18743 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18744 PyObject *resultobj = 0;
18745 wxMimeTypesManager *result = 0 ;
18746
18747 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18748 {
18749 PyThreadState* __tstate = wxPyBeginAllowThreads();
18750 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18751 wxPyEndAllowThreads(__tstate);
18752 if (PyErr_Occurred()) SWIG_fail;
18753 }
18754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18755 return resultobj;
18756 fail:
18757 return NULL;
18758 }
18759
18760
18761 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18762 PyObject *resultobj = 0;
18763 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18764 int arg2 = (int) wxMAILCAP_ALL ;
18765 wxString const &arg3_defvalue = wxPyEmptyString ;
18766 wxString *arg3 = (wxString *) &arg3_defvalue ;
18767 void *argp1 = 0 ;
18768 int res1 = 0 ;
18769 int val2 ;
18770 int ecode2 = 0 ;
18771 bool temp3 = false ;
18772 PyObject * obj0 = 0 ;
18773 PyObject * obj1 = 0 ;
18774 PyObject * obj2 = 0 ;
18775 char * kwnames[] = {
18776 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18777 };
18778
18779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18781 if (!SWIG_IsOK(res1)) {
18782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18783 }
18784 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18785 if (obj1) {
18786 ecode2 = SWIG_AsVal_int(obj1, &val2);
18787 if (!SWIG_IsOK(ecode2)) {
18788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18789 }
18790 arg2 = static_cast< int >(val2);
18791 }
18792 if (obj2) {
18793 {
18794 arg3 = wxString_in_helper(obj2);
18795 if (arg3 == NULL) SWIG_fail;
18796 temp3 = true;
18797 }
18798 }
18799 {
18800 PyThreadState* __tstate = wxPyBeginAllowThreads();
18801 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18802 wxPyEndAllowThreads(__tstate);
18803 if (PyErr_Occurred()) SWIG_fail;
18804 }
18805 resultobj = SWIG_Py_Void();
18806 {
18807 if (temp3)
18808 delete arg3;
18809 }
18810 return resultobj;
18811 fail:
18812 {
18813 if (temp3)
18814 delete arg3;
18815 }
18816 return NULL;
18817 }
18818
18819
18820 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18821 PyObject *resultobj = 0;
18822 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18823 void *argp1 = 0 ;
18824 int res1 = 0 ;
18825 PyObject *swig_obj[1] ;
18826
18827 if (!args) SWIG_fail;
18828 swig_obj[0] = args;
18829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18830 if (!SWIG_IsOK(res1)) {
18831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18832 }
18833 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18834 {
18835 PyThreadState* __tstate = wxPyBeginAllowThreads();
18836 (arg1)->ClearData();
18837 wxPyEndAllowThreads(__tstate);
18838 if (PyErr_Occurred()) SWIG_fail;
18839 }
18840 resultobj = SWIG_Py_Void();
18841 return resultobj;
18842 fail:
18843 return NULL;
18844 }
18845
18846
18847 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18848 PyObject *resultobj = 0;
18849 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18850 wxString *arg2 = 0 ;
18851 wxFileType *result = 0 ;
18852 void *argp1 = 0 ;
18853 int res1 = 0 ;
18854 bool temp2 = false ;
18855 PyObject * obj0 = 0 ;
18856 PyObject * obj1 = 0 ;
18857 char * kwnames[] = {
18858 (char *) "self",(char *) "ext", NULL
18859 };
18860
18861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18863 if (!SWIG_IsOK(res1)) {
18864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18865 }
18866 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18867 {
18868 arg2 = wxString_in_helper(obj1);
18869 if (arg2 == NULL) SWIG_fail;
18870 temp2 = true;
18871 }
18872 {
18873 PyThreadState* __tstate = wxPyBeginAllowThreads();
18874 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18875 wxPyEndAllowThreads(__tstate);
18876 if (PyErr_Occurred()) SWIG_fail;
18877 }
18878 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18879 {
18880 if (temp2)
18881 delete arg2;
18882 }
18883 return resultobj;
18884 fail:
18885 {
18886 if (temp2)
18887 delete arg2;
18888 }
18889 return NULL;
18890 }
18891
18892
18893 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18894 PyObject *resultobj = 0;
18895 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18896 wxString *arg2 = 0 ;
18897 wxFileType *result = 0 ;
18898 void *argp1 = 0 ;
18899 int res1 = 0 ;
18900 bool temp2 = false ;
18901 PyObject * obj0 = 0 ;
18902 PyObject * obj1 = 0 ;
18903 char * kwnames[] = {
18904 (char *) "self",(char *) "mimeType", NULL
18905 };
18906
18907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18909 if (!SWIG_IsOK(res1)) {
18910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18911 }
18912 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18913 {
18914 arg2 = wxString_in_helper(obj1);
18915 if (arg2 == NULL) SWIG_fail;
18916 temp2 = true;
18917 }
18918 {
18919 PyThreadState* __tstate = wxPyBeginAllowThreads();
18920 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
18921 wxPyEndAllowThreads(__tstate);
18922 if (PyErr_Occurred()) SWIG_fail;
18923 }
18924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18925 {
18926 if (temp2)
18927 delete arg2;
18928 }
18929 return resultobj;
18930 fail:
18931 {
18932 if (temp2)
18933 delete arg2;
18934 }
18935 return NULL;
18936 }
18937
18938
18939 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18940 PyObject *resultobj = 0;
18941 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18942 wxString *arg2 = 0 ;
18943 bool arg3 = (bool) false ;
18944 bool result;
18945 void *argp1 = 0 ;
18946 int res1 = 0 ;
18947 bool temp2 = false ;
18948 bool val3 ;
18949 int ecode3 = 0 ;
18950 PyObject * obj0 = 0 ;
18951 PyObject * obj1 = 0 ;
18952 PyObject * obj2 = 0 ;
18953 char * kwnames[] = {
18954 (char *) "self",(char *) "filename",(char *) "fallback", NULL
18955 };
18956
18957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) 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_ReadMailcap" "', 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 if (obj2) {
18969 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18970 if (!SWIG_IsOK(ecode3)) {
18971 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
18972 }
18973 arg3 = static_cast< bool >(val3);
18974 }
18975 {
18976 PyThreadState* __tstate = wxPyBeginAllowThreads();
18977 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
18978 wxPyEndAllowThreads(__tstate);
18979 if (PyErr_Occurred()) SWIG_fail;
18980 }
18981 {
18982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18983 }
18984 {
18985 if (temp2)
18986 delete arg2;
18987 }
18988 return resultobj;
18989 fail:
18990 {
18991 if (temp2)
18992 delete arg2;
18993 }
18994 return NULL;
18995 }
18996
18997
18998 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18999 PyObject *resultobj = 0;
19000 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19001 wxString *arg2 = 0 ;
19002 bool result;
19003 void *argp1 = 0 ;
19004 int res1 = 0 ;
19005 bool temp2 = false ;
19006 PyObject * obj0 = 0 ;
19007 PyObject * obj1 = 0 ;
19008 char * kwnames[] = {
19009 (char *) "self",(char *) "filename", NULL
19010 };
19011
19012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19014 if (!SWIG_IsOK(res1)) {
19015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19016 }
19017 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19018 {
19019 arg2 = wxString_in_helper(obj1);
19020 if (arg2 == NULL) SWIG_fail;
19021 temp2 = true;
19022 }
19023 {
19024 PyThreadState* __tstate = wxPyBeginAllowThreads();
19025 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19026 wxPyEndAllowThreads(__tstate);
19027 if (PyErr_Occurred()) SWIG_fail;
19028 }
19029 {
19030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19031 }
19032 {
19033 if (temp2)
19034 delete arg2;
19035 }
19036 return resultobj;
19037 fail:
19038 {
19039 if (temp2)
19040 delete arg2;
19041 }
19042 return NULL;
19043 }
19044
19045
19046 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19047 PyObject *resultobj = 0;
19048 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19049 PyObject *result = 0 ;
19050 void *argp1 = 0 ;
19051 int res1 = 0 ;
19052 PyObject *swig_obj[1] ;
19053
19054 if (!args) SWIG_fail;
19055 swig_obj[0] = args;
19056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19057 if (!SWIG_IsOK(res1)) {
19058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19059 }
19060 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19061 {
19062 PyThreadState* __tstate = wxPyBeginAllowThreads();
19063 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19064 wxPyEndAllowThreads(__tstate);
19065 if (PyErr_Occurred()) SWIG_fail;
19066 }
19067 resultobj = result;
19068 return resultobj;
19069 fail:
19070 return NULL;
19071 }
19072
19073
19074 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19075 PyObject *resultobj = 0;
19076 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19077 wxFileTypeInfo *arg2 = 0 ;
19078 void *argp1 = 0 ;
19079 int res1 = 0 ;
19080 void *argp2 = 0 ;
19081 int res2 = 0 ;
19082 PyObject * obj0 = 0 ;
19083 PyObject * obj1 = 0 ;
19084 char * kwnames[] = {
19085 (char *) "self",(char *) "ft", NULL
19086 };
19087
19088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19090 if (!SWIG_IsOK(res1)) {
19091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19092 }
19093 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19094 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19095 if (!SWIG_IsOK(res2)) {
19096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19097 }
19098 if (!argp2) {
19099 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19100 }
19101 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19102 {
19103 PyThreadState* __tstate = wxPyBeginAllowThreads();
19104 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19105 wxPyEndAllowThreads(__tstate);
19106 if (PyErr_Occurred()) SWIG_fail;
19107 }
19108 resultobj = SWIG_Py_Void();
19109 return resultobj;
19110 fail:
19111 return NULL;
19112 }
19113
19114
19115 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19116 PyObject *resultobj = 0;
19117 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19118 wxFileTypeInfo *arg2 = 0 ;
19119 wxFileType *result = 0 ;
19120 void *argp1 = 0 ;
19121 int res1 = 0 ;
19122 void *argp2 = 0 ;
19123 int res2 = 0 ;
19124 PyObject * obj0 = 0 ;
19125 PyObject * obj1 = 0 ;
19126 char * kwnames[] = {
19127 (char *) "self",(char *) "ftInfo", NULL
19128 };
19129
19130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19132 if (!SWIG_IsOK(res1)) {
19133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19134 }
19135 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19136 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19137 if (!SWIG_IsOK(res2)) {
19138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19139 }
19140 if (!argp2) {
19141 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19142 }
19143 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19144 {
19145 PyThreadState* __tstate = wxPyBeginAllowThreads();
19146 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19147 wxPyEndAllowThreads(__tstate);
19148 if (PyErr_Occurred()) SWIG_fail;
19149 }
19150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19151 return resultobj;
19152 fail:
19153 return NULL;
19154 }
19155
19156
19157 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19158 PyObject *resultobj = 0;
19159 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19160 wxFileType *arg2 = (wxFileType *) 0 ;
19161 bool result;
19162 void *argp1 = 0 ;
19163 int res1 = 0 ;
19164 void *argp2 = 0 ;
19165 int res2 = 0 ;
19166 PyObject * obj0 = 0 ;
19167 PyObject * obj1 = 0 ;
19168 char * kwnames[] = {
19169 (char *) "self",(char *) "ft", NULL
19170 };
19171
19172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19174 if (!SWIG_IsOK(res1)) {
19175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19176 }
19177 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19178 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19179 if (!SWIG_IsOK(res2)) {
19180 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19181 }
19182 arg2 = reinterpret_cast< wxFileType * >(argp2);
19183 {
19184 PyThreadState* __tstate = wxPyBeginAllowThreads();
19185 result = (bool)(arg1)->Unassociate(arg2);
19186 wxPyEndAllowThreads(__tstate);
19187 if (PyErr_Occurred()) SWIG_fail;
19188 }
19189 {
19190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19191 }
19192 return resultobj;
19193 fail:
19194 return NULL;
19195 }
19196
19197
19198 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19199 PyObject *resultobj = 0;
19200 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19201 void *argp1 = 0 ;
19202 int res1 = 0 ;
19203 PyObject *swig_obj[1] ;
19204
19205 if (!args) SWIG_fail;
19206 swig_obj[0] = args;
19207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19208 if (!SWIG_IsOK(res1)) {
19209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19210 }
19211 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19212 {
19213 PyThreadState* __tstate = wxPyBeginAllowThreads();
19214 delete arg1;
19215
19216 wxPyEndAllowThreads(__tstate);
19217 if (PyErr_Occurred()) SWIG_fail;
19218 }
19219 resultobj = SWIG_Py_Void();
19220 return resultobj;
19221 fail:
19222 return NULL;
19223 }
19224
19225
19226 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19227 PyObject *obj;
19228 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19229 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19230 return SWIG_Py_Void();
19231 }
19232
19233 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19234 return SWIG_Python_InitShadowInstance(args);
19235 }
19236
19237 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19238 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19239 return 1;
19240 }
19241
19242
19243 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19244 PyObject *pyobj = 0;
19245
19246 {
19247 #if wxUSE_UNICODE
19248 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19249 #else
19250 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19251 #endif
19252 }
19253 return pyobj;
19254 }
19255
19256
19257 SWIGINTERN int ART_MENU_set(PyObject *) {
19258 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19259 return 1;
19260 }
19261
19262
19263 SWIGINTERN PyObject *ART_MENU_get(void) {
19264 PyObject *pyobj = 0;
19265
19266 {
19267 #if wxUSE_UNICODE
19268 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19269 #else
19270 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19271 #endif
19272 }
19273 return pyobj;
19274 }
19275
19276
19277 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19278 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19279 return 1;
19280 }
19281
19282
19283 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19284 PyObject *pyobj = 0;
19285
19286 {
19287 #if wxUSE_UNICODE
19288 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19289 #else
19290 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19291 #endif
19292 }
19293 return pyobj;
19294 }
19295
19296
19297 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19298 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19299 return 1;
19300 }
19301
19302
19303 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19304 PyObject *pyobj = 0;
19305
19306 {
19307 #if wxUSE_UNICODE
19308 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19309 #else
19310 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19311 #endif
19312 }
19313 return pyobj;
19314 }
19315
19316
19317 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19318 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19319 return 1;
19320 }
19321
19322
19323 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19324 PyObject *pyobj = 0;
19325
19326 {
19327 #if wxUSE_UNICODE
19328 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19329 #else
19330 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19331 #endif
19332 }
19333 return pyobj;
19334 }
19335
19336
19337 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19338 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19339 return 1;
19340 }
19341
19342
19343 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19344 PyObject *pyobj = 0;
19345
19346 {
19347 #if wxUSE_UNICODE
19348 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19349 #else
19350 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19351 #endif
19352 }
19353 return pyobj;
19354 }
19355
19356
19357 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19358 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19359 return 1;
19360 }
19361
19362
19363 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19364 PyObject *pyobj = 0;
19365
19366 {
19367 #if wxUSE_UNICODE
19368 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19369 #else
19370 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19371 #endif
19372 }
19373 return pyobj;
19374 }
19375
19376
19377 SWIGINTERN int ART_OTHER_set(PyObject *) {
19378 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19379 return 1;
19380 }
19381
19382
19383 SWIGINTERN PyObject *ART_OTHER_get(void) {
19384 PyObject *pyobj = 0;
19385
19386 {
19387 #if wxUSE_UNICODE
19388 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19389 #else
19390 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19391 #endif
19392 }
19393 return pyobj;
19394 }
19395
19396
19397 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19398 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19399 return 1;
19400 }
19401
19402
19403 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19404 PyObject *pyobj = 0;
19405
19406 {
19407 #if wxUSE_UNICODE
19408 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19409 #else
19410 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19411 #endif
19412 }
19413 return pyobj;
19414 }
19415
19416
19417 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19418 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19419 return 1;
19420 }
19421
19422
19423 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19424 PyObject *pyobj = 0;
19425
19426 {
19427 #if wxUSE_UNICODE
19428 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19429 #else
19430 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19431 #endif
19432 }
19433 return pyobj;
19434 }
19435
19436
19437 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19438 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19439 return 1;
19440 }
19441
19442
19443 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19444 PyObject *pyobj = 0;
19445
19446 {
19447 #if wxUSE_UNICODE
19448 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19449 #else
19450 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19451 #endif
19452 }
19453 return pyobj;
19454 }
19455
19456
19457 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19458 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19459 return 1;
19460 }
19461
19462
19463 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19464 PyObject *pyobj = 0;
19465
19466 {
19467 #if wxUSE_UNICODE
19468 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19469 #else
19470 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19471 #endif
19472 }
19473 return pyobj;
19474 }
19475
19476
19477 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19478 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19479 return 1;
19480 }
19481
19482
19483 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19484 PyObject *pyobj = 0;
19485
19486 {
19487 #if wxUSE_UNICODE
19488 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19489 #else
19490 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19491 #endif
19492 }
19493 return pyobj;
19494 }
19495
19496
19497 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19498 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19499 return 1;
19500 }
19501
19502
19503 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19504 PyObject *pyobj = 0;
19505
19506 {
19507 #if wxUSE_UNICODE
19508 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19509 #else
19510 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19511 #endif
19512 }
19513 return pyobj;
19514 }
19515
19516
19517 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19518 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19519 return 1;
19520 }
19521
19522
19523 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19524 PyObject *pyobj = 0;
19525
19526 {
19527 #if wxUSE_UNICODE
19528 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19529 #else
19530 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19531 #endif
19532 }
19533 return pyobj;
19534 }
19535
19536
19537 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19538 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19539 return 1;
19540 }
19541
19542
19543 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19544 PyObject *pyobj = 0;
19545
19546 {
19547 #if wxUSE_UNICODE
19548 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19549 #else
19550 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19551 #endif
19552 }
19553 return pyobj;
19554 }
19555
19556
19557 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19558 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19559 return 1;
19560 }
19561
19562
19563 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19564 PyObject *pyobj = 0;
19565
19566 {
19567 #if wxUSE_UNICODE
19568 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19569 #else
19570 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19571 #endif
19572 }
19573 return pyobj;
19574 }
19575
19576
19577 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19578 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19579 return 1;
19580 }
19581
19582
19583 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19584 PyObject *pyobj = 0;
19585
19586 {
19587 #if wxUSE_UNICODE
19588 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19589 #else
19590 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19591 #endif
19592 }
19593 return pyobj;
19594 }
19595
19596
19597 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19598 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19599 return 1;
19600 }
19601
19602
19603 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19604 PyObject *pyobj = 0;
19605
19606 {
19607 #if wxUSE_UNICODE
19608 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19609 #else
19610 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19611 #endif
19612 }
19613 return pyobj;
19614 }
19615
19616
19617 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19618 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19619 return 1;
19620 }
19621
19622
19623 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19624 PyObject *pyobj = 0;
19625
19626 {
19627 #if wxUSE_UNICODE
19628 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19629 #else
19630 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19631 #endif
19632 }
19633 return pyobj;
19634 }
19635
19636
19637 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19638 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19639 return 1;
19640 }
19641
19642
19643 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19644 PyObject *pyobj = 0;
19645
19646 {
19647 #if wxUSE_UNICODE
19648 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19649 #else
19650 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19651 #endif
19652 }
19653 return pyobj;
19654 }
19655
19656
19657 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19658 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19659 return 1;
19660 }
19661
19662
19663 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19664 PyObject *pyobj = 0;
19665
19666 {
19667 #if wxUSE_UNICODE
19668 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19669 #else
19670 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19671 #endif
19672 }
19673 return pyobj;
19674 }
19675
19676
19677 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19678 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19679 return 1;
19680 }
19681
19682
19683 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19684 PyObject *pyobj = 0;
19685
19686 {
19687 #if wxUSE_UNICODE
19688 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19689 #else
19690 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19691 #endif
19692 }
19693 return pyobj;
19694 }
19695
19696
19697 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19698 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19699 return 1;
19700 }
19701
19702
19703 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19704 PyObject *pyobj = 0;
19705
19706 {
19707 #if wxUSE_UNICODE
19708 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19709 #else
19710 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19711 #endif
19712 }
19713 return pyobj;
19714 }
19715
19716
19717 SWIGINTERN int ART_PRINT_set(PyObject *) {
19718 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19719 return 1;
19720 }
19721
19722
19723 SWIGINTERN PyObject *ART_PRINT_get(void) {
19724 PyObject *pyobj = 0;
19725
19726 {
19727 #if wxUSE_UNICODE
19728 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19729 #else
19730 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19731 #endif
19732 }
19733 return pyobj;
19734 }
19735
19736
19737 SWIGINTERN int ART_HELP_set(PyObject *) {
19738 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19739 return 1;
19740 }
19741
19742
19743 SWIGINTERN PyObject *ART_HELP_get(void) {
19744 PyObject *pyobj = 0;
19745
19746 {
19747 #if wxUSE_UNICODE
19748 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19749 #else
19750 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19751 #endif
19752 }
19753 return pyobj;
19754 }
19755
19756
19757 SWIGINTERN int ART_TIP_set(PyObject *) {
19758 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19759 return 1;
19760 }
19761
19762
19763 SWIGINTERN PyObject *ART_TIP_get(void) {
19764 PyObject *pyobj = 0;
19765
19766 {
19767 #if wxUSE_UNICODE
19768 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19769 #else
19770 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19771 #endif
19772 }
19773 return pyobj;
19774 }
19775
19776
19777 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19778 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19779 return 1;
19780 }
19781
19782
19783 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19784 PyObject *pyobj = 0;
19785
19786 {
19787 #if wxUSE_UNICODE
19788 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19789 #else
19790 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19791 #endif
19792 }
19793 return pyobj;
19794 }
19795
19796
19797 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19798 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19799 return 1;
19800 }
19801
19802
19803 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19804 PyObject *pyobj = 0;
19805
19806 {
19807 #if wxUSE_UNICODE
19808 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19809 #else
19810 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19811 #endif
19812 }
19813 return pyobj;
19814 }
19815
19816
19817 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19818 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19819 return 1;
19820 }
19821
19822
19823 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19824 PyObject *pyobj = 0;
19825
19826 {
19827 #if wxUSE_UNICODE
19828 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19829 #else
19830 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19831 #endif
19832 }
19833 return pyobj;
19834 }
19835
19836
19837 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19838 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19839 return 1;
19840 }
19841
19842
19843 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19844 PyObject *pyobj = 0;
19845
19846 {
19847 #if wxUSE_UNICODE
19848 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19849 #else
19850 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19851 #endif
19852 }
19853 return pyobj;
19854 }
19855
19856
19857 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19858 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19859 return 1;
19860 }
19861
19862
19863 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19864 PyObject *pyobj = 0;
19865
19866 {
19867 #if wxUSE_UNICODE
19868 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19869 #else
19870 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19871 #endif
19872 }
19873 return pyobj;
19874 }
19875
19876
19877 SWIGINTERN int ART_CDROM_set(PyObject *) {
19878 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19879 return 1;
19880 }
19881
19882
19883 SWIGINTERN PyObject *ART_CDROM_get(void) {
19884 PyObject *pyobj = 0;
19885
19886 {
19887 #if wxUSE_UNICODE
19888 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19889 #else
19890 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19891 #endif
19892 }
19893 return pyobj;
19894 }
19895
19896
19897 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19898 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19899 return 1;
19900 }
19901
19902
19903 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19904 PyObject *pyobj = 0;
19905
19906 {
19907 #if wxUSE_UNICODE
19908 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19909 #else
19910 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19911 #endif
19912 }
19913 return pyobj;
19914 }
19915
19916
19917 SWIGINTERN int ART_FOLDER_set(PyObject *) {
19918 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
19919 return 1;
19920 }
19921
19922
19923 SWIGINTERN PyObject *ART_FOLDER_get(void) {
19924 PyObject *pyobj = 0;
19925
19926 {
19927 #if wxUSE_UNICODE
19928 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19929 #else
19930 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19931 #endif
19932 }
19933 return pyobj;
19934 }
19935
19936
19937 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
19938 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
19939 return 1;
19940 }
19941
19942
19943 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
19944 PyObject *pyobj = 0;
19945
19946 {
19947 #if wxUSE_UNICODE
19948 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19949 #else
19950 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19951 #endif
19952 }
19953 return pyobj;
19954 }
19955
19956
19957 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
19958 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
19959 return 1;
19960 }
19961
19962
19963 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
19964 PyObject *pyobj = 0;
19965
19966 {
19967 #if wxUSE_UNICODE
19968 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19969 #else
19970 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19971 #endif
19972 }
19973 return pyobj;
19974 }
19975
19976
19977 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
19978 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
19979 return 1;
19980 }
19981
19982
19983 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
19984 PyObject *pyobj = 0;
19985
19986 {
19987 #if wxUSE_UNICODE
19988 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19989 #else
19990 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19991 #endif
19992 }
19993 return pyobj;
19994 }
19995
19996
19997 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
19998 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
19999 return 1;
20000 }
20001
20002
20003 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20004 PyObject *pyobj = 0;
20005
20006 {
20007 #if wxUSE_UNICODE
20008 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20009 #else
20010 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20011 #endif
20012 }
20013 return pyobj;
20014 }
20015
20016
20017 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20018 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20019 return 1;
20020 }
20021
20022
20023 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20024 PyObject *pyobj = 0;
20025
20026 {
20027 #if wxUSE_UNICODE
20028 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20029 #else
20030 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20031 #endif
20032 }
20033 return pyobj;
20034 }
20035
20036
20037 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20038 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20039 return 1;
20040 }
20041
20042
20043 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20044 PyObject *pyobj = 0;
20045
20046 {
20047 #if wxUSE_UNICODE
20048 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20049 #else
20050 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20051 #endif
20052 }
20053 return pyobj;
20054 }
20055
20056
20057 SWIGINTERN int ART_ERROR_set(PyObject *) {
20058 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20059 return 1;
20060 }
20061
20062
20063 SWIGINTERN PyObject *ART_ERROR_get(void) {
20064 PyObject *pyobj = 0;
20065
20066 {
20067 #if wxUSE_UNICODE
20068 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20069 #else
20070 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20071 #endif
20072 }
20073 return pyobj;
20074 }
20075
20076
20077 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20078 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20079 return 1;
20080 }
20081
20082
20083 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20084 PyObject *pyobj = 0;
20085
20086 {
20087 #if wxUSE_UNICODE
20088 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20089 #else
20090 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20091 #endif
20092 }
20093 return pyobj;
20094 }
20095
20096
20097 SWIGINTERN int ART_WARNING_set(PyObject *) {
20098 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20099 return 1;
20100 }
20101
20102
20103 SWIGINTERN PyObject *ART_WARNING_get(void) {
20104 PyObject *pyobj = 0;
20105
20106 {
20107 #if wxUSE_UNICODE
20108 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20109 #else
20110 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20111 #endif
20112 }
20113 return pyobj;
20114 }
20115
20116
20117 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20118 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20119 return 1;
20120 }
20121
20122
20123 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20124 PyObject *pyobj = 0;
20125
20126 {
20127 #if wxUSE_UNICODE
20128 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20129 #else
20130 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20131 #endif
20132 }
20133 return pyobj;
20134 }
20135
20136
20137 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20138 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20139 return 1;
20140 }
20141
20142
20143 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20144 PyObject *pyobj = 0;
20145
20146 {
20147 #if wxUSE_UNICODE
20148 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20149 #else
20150 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20151 #endif
20152 }
20153 return pyobj;
20154 }
20155
20156
20157 SWIGINTERN int ART_COPY_set(PyObject *) {
20158 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20159 return 1;
20160 }
20161
20162
20163 SWIGINTERN PyObject *ART_COPY_get(void) {
20164 PyObject *pyobj = 0;
20165
20166 {
20167 #if wxUSE_UNICODE
20168 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20169 #else
20170 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20171 #endif
20172 }
20173 return pyobj;
20174 }
20175
20176
20177 SWIGINTERN int ART_CUT_set(PyObject *) {
20178 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20179 return 1;
20180 }
20181
20182
20183 SWIGINTERN PyObject *ART_CUT_get(void) {
20184 PyObject *pyobj = 0;
20185
20186 {
20187 #if wxUSE_UNICODE
20188 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20189 #else
20190 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20191 #endif
20192 }
20193 return pyobj;
20194 }
20195
20196
20197 SWIGINTERN int ART_PASTE_set(PyObject *) {
20198 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20199 return 1;
20200 }
20201
20202
20203 SWIGINTERN PyObject *ART_PASTE_get(void) {
20204 PyObject *pyobj = 0;
20205
20206 {
20207 #if wxUSE_UNICODE
20208 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20209 #else
20210 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20211 #endif
20212 }
20213 return pyobj;
20214 }
20215
20216
20217 SWIGINTERN int ART_DELETE_set(PyObject *) {
20218 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20219 return 1;
20220 }
20221
20222
20223 SWIGINTERN PyObject *ART_DELETE_get(void) {
20224 PyObject *pyobj = 0;
20225
20226 {
20227 #if wxUSE_UNICODE
20228 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20229 #else
20230 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20231 #endif
20232 }
20233 return pyobj;
20234 }
20235
20236
20237 SWIGINTERN int ART_NEW_set(PyObject *) {
20238 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20239 return 1;
20240 }
20241
20242
20243 SWIGINTERN PyObject *ART_NEW_get(void) {
20244 PyObject *pyobj = 0;
20245
20246 {
20247 #if wxUSE_UNICODE
20248 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20249 #else
20250 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20251 #endif
20252 }
20253 return pyobj;
20254 }
20255
20256
20257 SWIGINTERN int ART_UNDO_set(PyObject *) {
20258 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20259 return 1;
20260 }
20261
20262
20263 SWIGINTERN PyObject *ART_UNDO_get(void) {
20264 PyObject *pyobj = 0;
20265
20266 {
20267 #if wxUSE_UNICODE
20268 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20269 #else
20270 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20271 #endif
20272 }
20273 return pyobj;
20274 }
20275
20276
20277 SWIGINTERN int ART_REDO_set(PyObject *) {
20278 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20279 return 1;
20280 }
20281
20282
20283 SWIGINTERN PyObject *ART_REDO_get(void) {
20284 PyObject *pyobj = 0;
20285
20286 {
20287 #if wxUSE_UNICODE
20288 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20289 #else
20290 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20291 #endif
20292 }
20293 return pyobj;
20294 }
20295
20296
20297 SWIGINTERN int ART_QUIT_set(PyObject *) {
20298 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20299 return 1;
20300 }
20301
20302
20303 SWIGINTERN PyObject *ART_QUIT_get(void) {
20304 PyObject *pyobj = 0;
20305
20306 {
20307 #if wxUSE_UNICODE
20308 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20309 #else
20310 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20311 #endif
20312 }
20313 return pyobj;
20314 }
20315
20316
20317 SWIGINTERN int ART_FIND_set(PyObject *) {
20318 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20319 return 1;
20320 }
20321
20322
20323 SWIGINTERN PyObject *ART_FIND_get(void) {
20324 PyObject *pyobj = 0;
20325
20326 {
20327 #if wxUSE_UNICODE
20328 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20329 #else
20330 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20331 #endif
20332 }
20333 return pyobj;
20334 }
20335
20336
20337 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20338 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20339 return 1;
20340 }
20341
20342
20343 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20344 PyObject *pyobj = 0;
20345
20346 {
20347 #if wxUSE_UNICODE
20348 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20349 #else
20350 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20351 #endif
20352 }
20353 return pyobj;
20354 }
20355
20356
20357 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20358 PyObject *resultobj = 0;
20359 wxPyArtProvider *result = 0 ;
20360
20361 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20362 {
20363 if (!wxPyCheckForApp()) SWIG_fail;
20364 PyThreadState* __tstate = wxPyBeginAllowThreads();
20365 result = (wxPyArtProvider *)new wxPyArtProvider();
20366 wxPyEndAllowThreads(__tstate);
20367 if (PyErr_Occurred()) SWIG_fail;
20368 }
20369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20370 return resultobj;
20371 fail:
20372 return NULL;
20373 }
20374
20375
20376 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20377 PyObject *resultobj = 0;
20378 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20379 void *argp1 = 0 ;
20380 int res1 = 0 ;
20381 PyObject *swig_obj[1] ;
20382
20383 if (!args) SWIG_fail;
20384 swig_obj[0] = args;
20385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20386 if (!SWIG_IsOK(res1)) {
20387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20388 }
20389 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20390 {
20391 PyThreadState* __tstate = wxPyBeginAllowThreads();
20392 delete arg1;
20393
20394 wxPyEndAllowThreads(__tstate);
20395 if (PyErr_Occurred()) SWIG_fail;
20396 }
20397 resultobj = SWIG_Py_Void();
20398 return resultobj;
20399 fail:
20400 return NULL;
20401 }
20402
20403
20404 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20405 PyObject *resultobj = 0;
20406 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20407 PyObject *arg2 = (PyObject *) 0 ;
20408 PyObject *arg3 = (PyObject *) 0 ;
20409 void *argp1 = 0 ;
20410 int res1 = 0 ;
20411 PyObject * obj0 = 0 ;
20412 PyObject * obj1 = 0 ;
20413 PyObject * obj2 = 0 ;
20414 char * kwnames[] = {
20415 (char *) "self",(char *) "self",(char *) "_class", NULL
20416 };
20417
20418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20420 if (!SWIG_IsOK(res1)) {
20421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20422 }
20423 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20424 arg2 = obj1;
20425 arg3 = obj2;
20426 {
20427 PyThreadState* __tstate = wxPyBeginAllowThreads();
20428 (arg1)->_setCallbackInfo(arg2,arg3);
20429 wxPyEndAllowThreads(__tstate);
20430 if (PyErr_Occurred()) SWIG_fail;
20431 }
20432 resultobj = SWIG_Py_Void();
20433 return resultobj;
20434 fail:
20435 return NULL;
20436 }
20437
20438
20439 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20440 PyObject *resultobj = 0;
20441 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20442 int res1 = 0 ;
20443 PyObject * obj0 = 0 ;
20444 char * kwnames[] = {
20445 (char *) "provider", NULL
20446 };
20447
20448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20449 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20450 if (!SWIG_IsOK(res1)) {
20451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20452 }
20453 {
20454 PyThreadState* __tstate = wxPyBeginAllowThreads();
20455 wxPyArtProvider::Push(arg1);
20456 wxPyEndAllowThreads(__tstate);
20457 if (PyErr_Occurred()) SWIG_fail;
20458 }
20459 resultobj = SWIG_Py_Void();
20460 return resultobj;
20461 fail:
20462 return NULL;
20463 }
20464
20465
20466 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20467 PyObject *resultobj = 0;
20468 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20469 int res1 = 0 ;
20470 PyObject * obj0 = 0 ;
20471 char * kwnames[] = {
20472 (char *) "provider", NULL
20473 };
20474
20475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20476 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20477 if (!SWIG_IsOK(res1)) {
20478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20479 }
20480 {
20481 PyThreadState* __tstate = wxPyBeginAllowThreads();
20482 wxPyArtProvider::Insert(arg1);
20483 wxPyEndAllowThreads(__tstate);
20484 if (PyErr_Occurred()) SWIG_fail;
20485 }
20486 resultobj = SWIG_Py_Void();
20487 return resultobj;
20488 fail:
20489 return NULL;
20490 }
20491
20492
20493 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20494 PyObject *resultobj = 0;
20495 bool result;
20496
20497 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20498 {
20499 PyThreadState* __tstate = wxPyBeginAllowThreads();
20500 result = (bool)wxPyArtProvider::Pop();
20501 wxPyEndAllowThreads(__tstate);
20502 if (PyErr_Occurred()) SWIG_fail;
20503 }
20504 {
20505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20506 }
20507 return resultobj;
20508 fail:
20509 return NULL;
20510 }
20511
20512
20513 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20514 PyObject *resultobj = 0;
20515 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20516 bool result;
20517 void *argp1 = 0 ;
20518 int res1 = 0 ;
20519 PyObject * obj0 = 0 ;
20520 char * kwnames[] = {
20521 (char *) "provider", NULL
20522 };
20523
20524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20526 if (!SWIG_IsOK(res1)) {
20527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20528 }
20529 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20530 {
20531 PyThreadState* __tstate = wxPyBeginAllowThreads();
20532 result = (bool)wxPyArtProvider::Delete(arg1);
20533 wxPyEndAllowThreads(__tstate);
20534 if (PyErr_Occurred()) SWIG_fail;
20535 }
20536 {
20537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20538 }
20539 return resultobj;
20540 fail:
20541 return NULL;
20542 }
20543
20544
20545 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20546 PyObject *resultobj = 0;
20547 wxString *arg1 = 0 ;
20548 wxString const &arg2_defvalue = wxPyART_OTHER ;
20549 wxString *arg2 = (wxString *) &arg2_defvalue ;
20550 wxSize const &arg3_defvalue = wxDefaultSize ;
20551 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20552 wxBitmap result;
20553 bool temp1 = false ;
20554 bool temp2 = false ;
20555 wxSize temp3 ;
20556 PyObject * obj0 = 0 ;
20557 PyObject * obj1 = 0 ;
20558 PyObject * obj2 = 0 ;
20559 char * kwnames[] = {
20560 (char *) "id",(char *) "client",(char *) "size", NULL
20561 };
20562
20563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20564 {
20565 arg1 = wxString_in_helper(obj0);
20566 if (arg1 == NULL) SWIG_fail;
20567 temp1 = true;
20568 }
20569 if (obj1) {
20570 {
20571 arg2 = wxString_in_helper(obj1);
20572 if (arg2 == NULL) SWIG_fail;
20573 temp2 = true;
20574 }
20575 }
20576 if (obj2) {
20577 {
20578 arg3 = &temp3;
20579 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20580 }
20581 }
20582 {
20583 if (!wxPyCheckForApp()) SWIG_fail;
20584 PyThreadState* __tstate = wxPyBeginAllowThreads();
20585 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20586 wxPyEndAllowThreads(__tstate);
20587 if (PyErr_Occurred()) SWIG_fail;
20588 }
20589 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20590 {
20591 if (temp1)
20592 delete arg1;
20593 }
20594 {
20595 if (temp2)
20596 delete arg2;
20597 }
20598 return resultobj;
20599 fail:
20600 {
20601 if (temp1)
20602 delete arg1;
20603 }
20604 {
20605 if (temp2)
20606 delete arg2;
20607 }
20608 return NULL;
20609 }
20610
20611
20612 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20613 PyObject *resultobj = 0;
20614 wxString *arg1 = 0 ;
20615 wxString const &arg2_defvalue = wxPyART_OTHER ;
20616 wxString *arg2 = (wxString *) &arg2_defvalue ;
20617 wxSize const &arg3_defvalue = wxDefaultSize ;
20618 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20619 wxIcon result;
20620 bool temp1 = false ;
20621 bool temp2 = false ;
20622 wxSize temp3 ;
20623 PyObject * obj0 = 0 ;
20624 PyObject * obj1 = 0 ;
20625 PyObject * obj2 = 0 ;
20626 char * kwnames[] = {
20627 (char *) "id",(char *) "client",(char *) "size", NULL
20628 };
20629
20630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20631 {
20632 arg1 = wxString_in_helper(obj0);
20633 if (arg1 == NULL) SWIG_fail;
20634 temp1 = true;
20635 }
20636 if (obj1) {
20637 {
20638 arg2 = wxString_in_helper(obj1);
20639 if (arg2 == NULL) SWIG_fail;
20640 temp2 = true;
20641 }
20642 }
20643 if (obj2) {
20644 {
20645 arg3 = &temp3;
20646 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20647 }
20648 }
20649 {
20650 if (!wxPyCheckForApp()) SWIG_fail;
20651 PyThreadState* __tstate = wxPyBeginAllowThreads();
20652 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20653 wxPyEndAllowThreads(__tstate);
20654 if (PyErr_Occurred()) SWIG_fail;
20655 }
20656 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20657 {
20658 if (temp1)
20659 delete arg1;
20660 }
20661 {
20662 if (temp2)
20663 delete arg2;
20664 }
20665 return resultobj;
20666 fail:
20667 {
20668 if (temp1)
20669 delete arg1;
20670 }
20671 {
20672 if (temp2)
20673 delete arg2;
20674 }
20675 return NULL;
20676 }
20677
20678
20679 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20680 PyObject *resultobj = 0;
20681 wxString *arg1 = 0 ;
20682 bool arg2 = (bool) false ;
20683 wxSize result;
20684 bool temp1 = false ;
20685 bool val2 ;
20686 int ecode2 = 0 ;
20687 PyObject * obj0 = 0 ;
20688 PyObject * obj1 = 0 ;
20689 char * kwnames[] = {
20690 (char *) "client",(char *) "platform_dependent", NULL
20691 };
20692
20693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20694 {
20695 arg1 = wxString_in_helper(obj0);
20696 if (arg1 == NULL) SWIG_fail;
20697 temp1 = true;
20698 }
20699 if (obj1) {
20700 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20701 if (!SWIG_IsOK(ecode2)) {
20702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20703 }
20704 arg2 = static_cast< bool >(val2);
20705 }
20706 {
20707 PyThreadState* __tstate = wxPyBeginAllowThreads();
20708 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20709 wxPyEndAllowThreads(__tstate);
20710 if (PyErr_Occurred()) SWIG_fail;
20711 }
20712 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20713 {
20714 if (temp1)
20715 delete arg1;
20716 }
20717 return resultobj;
20718 fail:
20719 {
20720 if (temp1)
20721 delete arg1;
20722 }
20723 return NULL;
20724 }
20725
20726
20727 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20728 PyObject *resultobj = 0;
20729 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20730 void *argp1 = 0 ;
20731 int res1 = 0 ;
20732 PyObject *swig_obj[1] ;
20733
20734 if (!args) SWIG_fail;
20735 swig_obj[0] = args;
20736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20737 if (!SWIG_IsOK(res1)) {
20738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20739 }
20740 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20741 {
20742 PyThreadState* __tstate = wxPyBeginAllowThreads();
20743 wxPyArtProvider_Destroy(arg1);
20744 wxPyEndAllowThreads(__tstate);
20745 if (PyErr_Occurred()) SWIG_fail;
20746 }
20747 resultobj = SWIG_Py_Void();
20748 return resultobj;
20749 fail:
20750 return NULL;
20751 }
20752
20753
20754 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20755 PyObject *obj;
20756 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20757 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20758 return SWIG_Py_Void();
20759 }
20760
20761 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20762 return SWIG_Python_InitShadowInstance(args);
20763 }
20764
20765 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20766 PyObject *resultobj = 0;
20767 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20768 void *argp1 = 0 ;
20769 int res1 = 0 ;
20770 PyObject *swig_obj[1] ;
20771
20772 if (!args) SWIG_fail;
20773 swig_obj[0] = args;
20774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20775 if (!SWIG_IsOK(res1)) {
20776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20777 }
20778 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20779 {
20780 PyThreadState* __tstate = wxPyBeginAllowThreads();
20781 delete arg1;
20782
20783 wxPyEndAllowThreads(__tstate);
20784 if (PyErr_Occurred()) SWIG_fail;
20785 }
20786 resultobj = SWIG_Py_Void();
20787 return resultobj;
20788 fail:
20789 return NULL;
20790 }
20791
20792
20793 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20794 PyObject *resultobj = 0;
20795 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20796 wxConfigBase *result = 0 ;
20797 int res1 = 0 ;
20798 PyObject * obj0 = 0 ;
20799 char * kwnames[] = {
20800 (char *) "config", NULL
20801 };
20802
20803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20804 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20805 if (!SWIG_IsOK(res1)) {
20806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20807 }
20808 {
20809 PyThreadState* __tstate = wxPyBeginAllowThreads();
20810 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20811 wxPyEndAllowThreads(__tstate);
20812 if (PyErr_Occurred()) SWIG_fail;
20813 }
20814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20815 return resultobj;
20816 fail:
20817 return NULL;
20818 }
20819
20820
20821 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20822 PyObject *resultobj = 0;
20823 bool arg1 = (bool) true ;
20824 wxConfigBase *result = 0 ;
20825 bool val1 ;
20826 int ecode1 = 0 ;
20827 PyObject * obj0 = 0 ;
20828 char * kwnames[] = {
20829 (char *) "createOnDemand", NULL
20830 };
20831
20832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20833 if (obj0) {
20834 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20835 if (!SWIG_IsOK(ecode1)) {
20836 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20837 }
20838 arg1 = static_cast< bool >(val1);
20839 }
20840 {
20841 PyThreadState* __tstate = wxPyBeginAllowThreads();
20842 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20843 wxPyEndAllowThreads(__tstate);
20844 if (PyErr_Occurred()) SWIG_fail;
20845 }
20846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20847 return resultobj;
20848 fail:
20849 return NULL;
20850 }
20851
20852
20853 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20854 PyObject *resultobj = 0;
20855 wxConfigBase *result = 0 ;
20856
20857 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20858 {
20859 PyThreadState* __tstate = wxPyBeginAllowThreads();
20860 result = (wxConfigBase *)wxConfigBase::Create();
20861 wxPyEndAllowThreads(__tstate);
20862 if (PyErr_Occurred()) SWIG_fail;
20863 }
20864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20865 return resultobj;
20866 fail:
20867 return NULL;
20868 }
20869
20870
20871 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20872 PyObject *resultobj = 0;
20873
20874 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20875 {
20876 PyThreadState* __tstate = wxPyBeginAllowThreads();
20877 wxConfigBase::DontCreateOnDemand();
20878 wxPyEndAllowThreads(__tstate);
20879 if (PyErr_Occurred()) SWIG_fail;
20880 }
20881 resultobj = SWIG_Py_Void();
20882 return resultobj;
20883 fail:
20884 return NULL;
20885 }
20886
20887
20888 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20889 PyObject *resultobj = 0;
20890 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20891 wxString *arg2 = 0 ;
20892 void *argp1 = 0 ;
20893 int res1 = 0 ;
20894 bool temp2 = false ;
20895 PyObject * obj0 = 0 ;
20896 PyObject * obj1 = 0 ;
20897 char * kwnames[] = {
20898 (char *) "self",(char *) "path", NULL
20899 };
20900
20901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20903 if (!SWIG_IsOK(res1)) {
20904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20905 }
20906 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20907 {
20908 arg2 = wxString_in_helper(obj1);
20909 if (arg2 == NULL) SWIG_fail;
20910 temp2 = true;
20911 }
20912 {
20913 PyThreadState* __tstate = wxPyBeginAllowThreads();
20914 (arg1)->SetPath((wxString const &)*arg2);
20915 wxPyEndAllowThreads(__tstate);
20916 if (PyErr_Occurred()) SWIG_fail;
20917 }
20918 resultobj = SWIG_Py_Void();
20919 {
20920 if (temp2)
20921 delete arg2;
20922 }
20923 return resultobj;
20924 fail:
20925 {
20926 if (temp2)
20927 delete arg2;
20928 }
20929 return NULL;
20930 }
20931
20932
20933 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20934 PyObject *resultobj = 0;
20935 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20936 wxString *result = 0 ;
20937 void *argp1 = 0 ;
20938 int res1 = 0 ;
20939 PyObject *swig_obj[1] ;
20940
20941 if (!args) SWIG_fail;
20942 swig_obj[0] = args;
20943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20944 if (!SWIG_IsOK(res1)) {
20945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20946 }
20947 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20948 {
20949 PyThreadState* __tstate = wxPyBeginAllowThreads();
20950 {
20951 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
20952 result = (wxString *) &_result_ref;
20953 }
20954 wxPyEndAllowThreads(__tstate);
20955 if (PyErr_Occurred()) SWIG_fail;
20956 }
20957 {
20958 #if wxUSE_UNICODE
20959 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
20960 #else
20961 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
20962 #endif
20963 }
20964 return resultobj;
20965 fail:
20966 return NULL;
20967 }
20968
20969
20970 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20971 PyObject *resultobj = 0;
20972 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20973 PyObject *result = 0 ;
20974 void *argp1 = 0 ;
20975 int res1 = 0 ;
20976 PyObject *swig_obj[1] ;
20977
20978 if (!args) SWIG_fail;
20979 swig_obj[0] = args;
20980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20981 if (!SWIG_IsOK(res1)) {
20982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20983 }
20984 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20985 {
20986 PyThreadState* __tstate = wxPyBeginAllowThreads();
20987 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
20988 wxPyEndAllowThreads(__tstate);
20989 if (PyErr_Occurred()) SWIG_fail;
20990 }
20991 resultobj = result;
20992 return resultobj;
20993 fail:
20994 return NULL;
20995 }
20996
20997
20998 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20999 PyObject *resultobj = 0;
21000 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21001 long arg2 ;
21002 PyObject *result = 0 ;
21003 void *argp1 = 0 ;
21004 int res1 = 0 ;
21005 long val2 ;
21006 int ecode2 = 0 ;
21007 PyObject * obj0 = 0 ;
21008 PyObject * obj1 = 0 ;
21009 char * kwnames[] = {
21010 (char *) "self",(char *) "index", NULL
21011 };
21012
21013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21015 if (!SWIG_IsOK(res1)) {
21016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21017 }
21018 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21019 ecode2 = SWIG_AsVal_long(obj1, &val2);
21020 if (!SWIG_IsOK(ecode2)) {
21021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21022 }
21023 arg2 = static_cast< long >(val2);
21024 {
21025 PyThreadState* __tstate = wxPyBeginAllowThreads();
21026 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21027 wxPyEndAllowThreads(__tstate);
21028 if (PyErr_Occurred()) SWIG_fail;
21029 }
21030 resultobj = result;
21031 return resultobj;
21032 fail:
21033 return NULL;
21034 }
21035
21036
21037 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21038 PyObject *resultobj = 0;
21039 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21040 PyObject *result = 0 ;
21041 void *argp1 = 0 ;
21042 int res1 = 0 ;
21043 PyObject *swig_obj[1] ;
21044
21045 if (!args) SWIG_fail;
21046 swig_obj[0] = args;
21047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21048 if (!SWIG_IsOK(res1)) {
21049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21050 }
21051 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21052 {
21053 PyThreadState* __tstate = wxPyBeginAllowThreads();
21054 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21055 wxPyEndAllowThreads(__tstate);
21056 if (PyErr_Occurred()) SWIG_fail;
21057 }
21058 resultobj = result;
21059 return resultobj;
21060 fail:
21061 return NULL;
21062 }
21063
21064
21065 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21066 PyObject *resultobj = 0;
21067 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21068 long arg2 ;
21069 PyObject *result = 0 ;
21070 void *argp1 = 0 ;
21071 int res1 = 0 ;
21072 long val2 ;
21073 int ecode2 = 0 ;
21074 PyObject * obj0 = 0 ;
21075 PyObject * obj1 = 0 ;
21076 char * kwnames[] = {
21077 (char *) "self",(char *) "index", NULL
21078 };
21079
21080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21082 if (!SWIG_IsOK(res1)) {
21083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21084 }
21085 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21086 ecode2 = SWIG_AsVal_long(obj1, &val2);
21087 if (!SWIG_IsOK(ecode2)) {
21088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21089 }
21090 arg2 = static_cast< long >(val2);
21091 {
21092 PyThreadState* __tstate = wxPyBeginAllowThreads();
21093 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21094 wxPyEndAllowThreads(__tstate);
21095 if (PyErr_Occurred()) SWIG_fail;
21096 }
21097 resultobj = result;
21098 return resultobj;
21099 fail:
21100 return NULL;
21101 }
21102
21103
21104 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21105 PyObject *resultobj = 0;
21106 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21107 bool arg2 = (bool) false ;
21108 size_t result;
21109 void *argp1 = 0 ;
21110 int res1 = 0 ;
21111 bool val2 ;
21112 int ecode2 = 0 ;
21113 PyObject * obj0 = 0 ;
21114 PyObject * obj1 = 0 ;
21115 char * kwnames[] = {
21116 (char *) "self",(char *) "recursive", NULL
21117 };
21118
21119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21121 if (!SWIG_IsOK(res1)) {
21122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21123 }
21124 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21125 if (obj1) {
21126 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21127 if (!SWIG_IsOK(ecode2)) {
21128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21129 }
21130 arg2 = static_cast< bool >(val2);
21131 }
21132 {
21133 PyThreadState* __tstate = wxPyBeginAllowThreads();
21134 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21135 wxPyEndAllowThreads(__tstate);
21136 if (PyErr_Occurred()) SWIG_fail;
21137 }
21138 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21139 return resultobj;
21140 fail:
21141 return NULL;
21142 }
21143
21144
21145 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21146 PyObject *resultobj = 0;
21147 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21148 bool arg2 = (bool) false ;
21149 size_t result;
21150 void *argp1 = 0 ;
21151 int res1 = 0 ;
21152 bool val2 ;
21153 int ecode2 = 0 ;
21154 PyObject * obj0 = 0 ;
21155 PyObject * obj1 = 0 ;
21156 char * kwnames[] = {
21157 (char *) "self",(char *) "recursive", NULL
21158 };
21159
21160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21162 if (!SWIG_IsOK(res1)) {
21163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21164 }
21165 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21166 if (obj1) {
21167 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21168 if (!SWIG_IsOK(ecode2)) {
21169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21170 }
21171 arg2 = static_cast< bool >(val2);
21172 }
21173 {
21174 PyThreadState* __tstate = wxPyBeginAllowThreads();
21175 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21176 wxPyEndAllowThreads(__tstate);
21177 if (PyErr_Occurred()) SWIG_fail;
21178 }
21179 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21180 return resultobj;
21181 fail:
21182 return NULL;
21183 }
21184
21185
21186 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21187 PyObject *resultobj = 0;
21188 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21189 wxString *arg2 = 0 ;
21190 bool result;
21191 void *argp1 = 0 ;
21192 int res1 = 0 ;
21193 bool temp2 = false ;
21194 PyObject * obj0 = 0 ;
21195 PyObject * obj1 = 0 ;
21196 char * kwnames[] = {
21197 (char *) "self",(char *) "name", NULL
21198 };
21199
21200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21202 if (!SWIG_IsOK(res1)) {
21203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21204 }
21205 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21206 {
21207 arg2 = wxString_in_helper(obj1);
21208 if (arg2 == NULL) SWIG_fail;
21209 temp2 = true;
21210 }
21211 {
21212 PyThreadState* __tstate = wxPyBeginAllowThreads();
21213 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21214 wxPyEndAllowThreads(__tstate);
21215 if (PyErr_Occurred()) SWIG_fail;
21216 }
21217 {
21218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21219 }
21220 {
21221 if (temp2)
21222 delete arg2;
21223 }
21224 return resultobj;
21225 fail:
21226 {
21227 if (temp2)
21228 delete arg2;
21229 }
21230 return NULL;
21231 }
21232
21233
21234 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21235 PyObject *resultobj = 0;
21236 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21237 wxString *arg2 = 0 ;
21238 bool result;
21239 void *argp1 = 0 ;
21240 int res1 = 0 ;
21241 bool temp2 = false ;
21242 PyObject * obj0 = 0 ;
21243 PyObject * obj1 = 0 ;
21244 char * kwnames[] = {
21245 (char *) "self",(char *) "name", NULL
21246 };
21247
21248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21250 if (!SWIG_IsOK(res1)) {
21251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21252 }
21253 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21254 {
21255 arg2 = wxString_in_helper(obj1);
21256 if (arg2 == NULL) SWIG_fail;
21257 temp2 = true;
21258 }
21259 {
21260 PyThreadState* __tstate = wxPyBeginAllowThreads();
21261 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21262 wxPyEndAllowThreads(__tstate);
21263 if (PyErr_Occurred()) SWIG_fail;
21264 }
21265 {
21266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21267 }
21268 {
21269 if (temp2)
21270 delete arg2;
21271 }
21272 return resultobj;
21273 fail:
21274 {
21275 if (temp2)
21276 delete arg2;
21277 }
21278 return NULL;
21279 }
21280
21281
21282 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(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_Exists",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_Exists" "', 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)->Exists((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_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21331 PyObject *resultobj = 0;
21332 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21333 wxString *arg2 = 0 ;
21334 wxConfigBase::EntryType 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_GetEntryType",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_GetEntryType" "', 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 = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21358 wxPyEndAllowThreads(__tstate);
21359 if (PyErr_Occurred()) SWIG_fail;
21360 }
21361 resultobj = SWIG_From_int(static_cast< int >(result));
21362 {
21363 if (temp2)
21364 delete arg2;
21365 }
21366 return resultobj;
21367 fail:
21368 {
21369 if (temp2)
21370 delete arg2;
21371 }
21372 return NULL;
21373 }
21374
21375
21376 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21377 PyObject *resultobj = 0;
21378 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21379 wxString *arg2 = 0 ;
21380 wxString const &arg3_defvalue = wxPyEmptyString ;
21381 wxString *arg3 = (wxString *) &arg3_defvalue ;
21382 wxString result;
21383 void *argp1 = 0 ;
21384 int res1 = 0 ;
21385 bool temp2 = false ;
21386 bool temp3 = false ;
21387 PyObject * obj0 = 0 ;
21388 PyObject * obj1 = 0 ;
21389 PyObject * obj2 = 0 ;
21390 char * kwnames[] = {
21391 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21392 };
21393
21394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21396 if (!SWIG_IsOK(res1)) {
21397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21398 }
21399 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21400 {
21401 arg2 = wxString_in_helper(obj1);
21402 if (arg2 == NULL) SWIG_fail;
21403 temp2 = true;
21404 }
21405 if (obj2) {
21406 {
21407 arg3 = wxString_in_helper(obj2);
21408 if (arg3 == NULL) SWIG_fail;
21409 temp3 = true;
21410 }
21411 }
21412 {
21413 PyThreadState* __tstate = wxPyBeginAllowThreads();
21414 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21415 wxPyEndAllowThreads(__tstate);
21416 if (PyErr_Occurred()) SWIG_fail;
21417 }
21418 {
21419 #if wxUSE_UNICODE
21420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21421 #else
21422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21423 #endif
21424 }
21425 {
21426 if (temp2)
21427 delete arg2;
21428 }
21429 {
21430 if (temp3)
21431 delete arg3;
21432 }
21433 return resultobj;
21434 fail:
21435 {
21436 if (temp2)
21437 delete arg2;
21438 }
21439 {
21440 if (temp3)
21441 delete arg3;
21442 }
21443 return NULL;
21444 }
21445
21446
21447 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21448 PyObject *resultobj = 0;
21449 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21450 wxString *arg2 = 0 ;
21451 long arg3 = (long) 0 ;
21452 long result;
21453 void *argp1 = 0 ;
21454 int res1 = 0 ;
21455 bool temp2 = false ;
21456 long val3 ;
21457 int ecode3 = 0 ;
21458 PyObject * obj0 = 0 ;
21459 PyObject * obj1 = 0 ;
21460 PyObject * obj2 = 0 ;
21461 char * kwnames[] = {
21462 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21463 };
21464
21465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21467 if (!SWIG_IsOK(res1)) {
21468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21469 }
21470 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21471 {
21472 arg2 = wxString_in_helper(obj1);
21473 if (arg2 == NULL) SWIG_fail;
21474 temp2 = true;
21475 }
21476 if (obj2) {
21477 ecode3 = SWIG_AsVal_long(obj2, &val3);
21478 if (!SWIG_IsOK(ecode3)) {
21479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21480 }
21481 arg3 = static_cast< long >(val3);
21482 }
21483 {
21484 PyThreadState* __tstate = wxPyBeginAllowThreads();
21485 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21486 wxPyEndAllowThreads(__tstate);
21487 if (PyErr_Occurred()) SWIG_fail;
21488 }
21489 resultobj = SWIG_From_long(static_cast< long >(result));
21490 {
21491 if (temp2)
21492 delete arg2;
21493 }
21494 return resultobj;
21495 fail:
21496 {
21497 if (temp2)
21498 delete arg2;
21499 }
21500 return NULL;
21501 }
21502
21503
21504 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21505 PyObject *resultobj = 0;
21506 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21507 wxString *arg2 = 0 ;
21508 double arg3 = (double) 0.0 ;
21509 double result;
21510 void *argp1 = 0 ;
21511 int res1 = 0 ;
21512 bool temp2 = false ;
21513 double val3 ;
21514 int ecode3 = 0 ;
21515 PyObject * obj0 = 0 ;
21516 PyObject * obj1 = 0 ;
21517 PyObject * obj2 = 0 ;
21518 char * kwnames[] = {
21519 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21520 };
21521
21522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21524 if (!SWIG_IsOK(res1)) {
21525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21526 }
21527 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21528 {
21529 arg2 = wxString_in_helper(obj1);
21530 if (arg2 == NULL) SWIG_fail;
21531 temp2 = true;
21532 }
21533 if (obj2) {
21534 ecode3 = SWIG_AsVal_double(obj2, &val3);
21535 if (!SWIG_IsOK(ecode3)) {
21536 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21537 }
21538 arg3 = static_cast< double >(val3);
21539 }
21540 {
21541 PyThreadState* __tstate = wxPyBeginAllowThreads();
21542 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21543 wxPyEndAllowThreads(__tstate);
21544 if (PyErr_Occurred()) SWIG_fail;
21545 }
21546 resultobj = SWIG_From_double(static_cast< double >(result));
21547 {
21548 if (temp2)
21549 delete arg2;
21550 }
21551 return resultobj;
21552 fail:
21553 {
21554 if (temp2)
21555 delete arg2;
21556 }
21557 return NULL;
21558 }
21559
21560
21561 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21562 PyObject *resultobj = 0;
21563 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21564 wxString *arg2 = 0 ;
21565 bool arg3 = (bool) false ;
21566 bool result;
21567 void *argp1 = 0 ;
21568 int res1 = 0 ;
21569 bool temp2 = false ;
21570 bool val3 ;
21571 int ecode3 = 0 ;
21572 PyObject * obj0 = 0 ;
21573 PyObject * obj1 = 0 ;
21574 PyObject * obj2 = 0 ;
21575 char * kwnames[] = {
21576 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21577 };
21578
21579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21581 if (!SWIG_IsOK(res1)) {
21582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21583 }
21584 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21585 {
21586 arg2 = wxString_in_helper(obj1);
21587 if (arg2 == NULL) SWIG_fail;
21588 temp2 = true;
21589 }
21590 if (obj2) {
21591 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21592 if (!SWIG_IsOK(ecode3)) {
21593 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21594 }
21595 arg3 = static_cast< bool >(val3);
21596 }
21597 {
21598 PyThreadState* __tstate = wxPyBeginAllowThreads();
21599 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21600 wxPyEndAllowThreads(__tstate);
21601 if (PyErr_Occurred()) SWIG_fail;
21602 }
21603 {
21604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21605 }
21606 {
21607 if (temp2)
21608 delete arg2;
21609 }
21610 return resultobj;
21611 fail:
21612 {
21613 if (temp2)
21614 delete arg2;
21615 }
21616 return NULL;
21617 }
21618
21619
21620 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21621 PyObject *resultobj = 0;
21622 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21623 wxString *arg2 = 0 ;
21624 wxString *arg3 = 0 ;
21625 bool result;
21626 void *argp1 = 0 ;
21627 int res1 = 0 ;
21628 bool temp2 = false ;
21629 bool temp3 = false ;
21630 PyObject * obj0 = 0 ;
21631 PyObject * obj1 = 0 ;
21632 PyObject * obj2 = 0 ;
21633 char * kwnames[] = {
21634 (char *) "self",(char *) "key",(char *) "value", NULL
21635 };
21636
21637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21639 if (!SWIG_IsOK(res1)) {
21640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21641 }
21642 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21643 {
21644 arg2 = wxString_in_helper(obj1);
21645 if (arg2 == NULL) SWIG_fail;
21646 temp2 = true;
21647 }
21648 {
21649 arg3 = wxString_in_helper(obj2);
21650 if (arg3 == NULL) SWIG_fail;
21651 temp3 = true;
21652 }
21653 {
21654 PyThreadState* __tstate = wxPyBeginAllowThreads();
21655 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21656 wxPyEndAllowThreads(__tstate);
21657 if (PyErr_Occurred()) SWIG_fail;
21658 }
21659 {
21660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21661 }
21662 {
21663 if (temp2)
21664 delete arg2;
21665 }
21666 {
21667 if (temp3)
21668 delete arg3;
21669 }
21670 return resultobj;
21671 fail:
21672 {
21673 if (temp2)
21674 delete arg2;
21675 }
21676 {
21677 if (temp3)
21678 delete arg3;
21679 }
21680 return NULL;
21681 }
21682
21683
21684 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21685 PyObject *resultobj = 0;
21686 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21687 wxString *arg2 = 0 ;
21688 long arg3 ;
21689 bool result;
21690 void *argp1 = 0 ;
21691 int res1 = 0 ;
21692 bool temp2 = false ;
21693 long val3 ;
21694 int ecode3 = 0 ;
21695 PyObject * obj0 = 0 ;
21696 PyObject * obj1 = 0 ;
21697 PyObject * obj2 = 0 ;
21698 char * kwnames[] = {
21699 (char *) "self",(char *) "key",(char *) "value", NULL
21700 };
21701
21702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21704 if (!SWIG_IsOK(res1)) {
21705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21706 }
21707 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21708 {
21709 arg2 = wxString_in_helper(obj1);
21710 if (arg2 == NULL) SWIG_fail;
21711 temp2 = true;
21712 }
21713 ecode3 = SWIG_AsVal_long(obj2, &val3);
21714 if (!SWIG_IsOK(ecode3)) {
21715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21716 }
21717 arg3 = static_cast< long >(val3);
21718 {
21719 PyThreadState* __tstate = wxPyBeginAllowThreads();
21720 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21721 wxPyEndAllowThreads(__tstate);
21722 if (PyErr_Occurred()) SWIG_fail;
21723 }
21724 {
21725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21726 }
21727 {
21728 if (temp2)
21729 delete arg2;
21730 }
21731 return resultobj;
21732 fail:
21733 {
21734 if (temp2)
21735 delete arg2;
21736 }
21737 return NULL;
21738 }
21739
21740
21741 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21742 PyObject *resultobj = 0;
21743 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21744 wxString *arg2 = 0 ;
21745 double arg3 ;
21746 bool result;
21747 void *argp1 = 0 ;
21748 int res1 = 0 ;
21749 bool temp2 = false ;
21750 double val3 ;
21751 int ecode3 = 0 ;
21752 PyObject * obj0 = 0 ;
21753 PyObject * obj1 = 0 ;
21754 PyObject * obj2 = 0 ;
21755 char * kwnames[] = {
21756 (char *) "self",(char *) "key",(char *) "value", NULL
21757 };
21758
21759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21761 if (!SWIG_IsOK(res1)) {
21762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21763 }
21764 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21765 {
21766 arg2 = wxString_in_helper(obj1);
21767 if (arg2 == NULL) SWIG_fail;
21768 temp2 = true;
21769 }
21770 ecode3 = SWIG_AsVal_double(obj2, &val3);
21771 if (!SWIG_IsOK(ecode3)) {
21772 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21773 }
21774 arg3 = static_cast< double >(val3);
21775 {
21776 PyThreadState* __tstate = wxPyBeginAllowThreads();
21777 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21778 wxPyEndAllowThreads(__tstate);
21779 if (PyErr_Occurred()) SWIG_fail;
21780 }
21781 {
21782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21783 }
21784 {
21785 if (temp2)
21786 delete arg2;
21787 }
21788 return resultobj;
21789 fail:
21790 {
21791 if (temp2)
21792 delete arg2;
21793 }
21794 return NULL;
21795 }
21796
21797
21798 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21799 PyObject *resultobj = 0;
21800 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21801 wxString *arg2 = 0 ;
21802 bool arg3 ;
21803 bool result;
21804 void *argp1 = 0 ;
21805 int res1 = 0 ;
21806 bool temp2 = false ;
21807 bool val3 ;
21808 int ecode3 = 0 ;
21809 PyObject * obj0 = 0 ;
21810 PyObject * obj1 = 0 ;
21811 PyObject * obj2 = 0 ;
21812 char * kwnames[] = {
21813 (char *) "self",(char *) "key",(char *) "value", NULL
21814 };
21815
21816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21818 if (!SWIG_IsOK(res1)) {
21819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21820 }
21821 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21822 {
21823 arg2 = wxString_in_helper(obj1);
21824 if (arg2 == NULL) SWIG_fail;
21825 temp2 = true;
21826 }
21827 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21828 if (!SWIG_IsOK(ecode3)) {
21829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21830 }
21831 arg3 = static_cast< bool >(val3);
21832 {
21833 PyThreadState* __tstate = wxPyBeginAllowThreads();
21834 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21835 wxPyEndAllowThreads(__tstate);
21836 if (PyErr_Occurred()) SWIG_fail;
21837 }
21838 {
21839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21840 }
21841 {
21842 if (temp2)
21843 delete arg2;
21844 }
21845 return resultobj;
21846 fail:
21847 {
21848 if (temp2)
21849 delete arg2;
21850 }
21851 return NULL;
21852 }
21853
21854
21855 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21856 PyObject *resultobj = 0;
21857 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21858 bool arg2 = (bool) false ;
21859 bool result;
21860 void *argp1 = 0 ;
21861 int res1 = 0 ;
21862 bool val2 ;
21863 int ecode2 = 0 ;
21864 PyObject * obj0 = 0 ;
21865 PyObject * obj1 = 0 ;
21866 char * kwnames[] = {
21867 (char *) "self",(char *) "currentOnly", NULL
21868 };
21869
21870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21872 if (!SWIG_IsOK(res1)) {
21873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21874 }
21875 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21876 if (obj1) {
21877 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21878 if (!SWIG_IsOK(ecode2)) {
21879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21880 }
21881 arg2 = static_cast< bool >(val2);
21882 }
21883 {
21884 PyThreadState* __tstate = wxPyBeginAllowThreads();
21885 result = (bool)(arg1)->Flush(arg2);
21886 wxPyEndAllowThreads(__tstate);
21887 if (PyErr_Occurred()) SWIG_fail;
21888 }
21889 {
21890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21891 }
21892 return resultobj;
21893 fail:
21894 return NULL;
21895 }
21896
21897
21898 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21899 PyObject *resultobj = 0;
21900 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21901 wxString *arg2 = 0 ;
21902 wxString *arg3 = 0 ;
21903 bool result;
21904 void *argp1 = 0 ;
21905 int res1 = 0 ;
21906 bool temp2 = false ;
21907 bool temp3 = false ;
21908 PyObject * obj0 = 0 ;
21909 PyObject * obj1 = 0 ;
21910 PyObject * obj2 = 0 ;
21911 char * kwnames[] = {
21912 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21913 };
21914
21915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21917 if (!SWIG_IsOK(res1)) {
21918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21919 }
21920 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21921 {
21922 arg2 = wxString_in_helper(obj1);
21923 if (arg2 == NULL) SWIG_fail;
21924 temp2 = true;
21925 }
21926 {
21927 arg3 = wxString_in_helper(obj2);
21928 if (arg3 == NULL) SWIG_fail;
21929 temp3 = true;
21930 }
21931 {
21932 PyThreadState* __tstate = wxPyBeginAllowThreads();
21933 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
21934 wxPyEndAllowThreads(__tstate);
21935 if (PyErr_Occurred()) SWIG_fail;
21936 }
21937 {
21938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21939 }
21940 {
21941 if (temp2)
21942 delete arg2;
21943 }
21944 {
21945 if (temp3)
21946 delete arg3;
21947 }
21948 return resultobj;
21949 fail:
21950 {
21951 if (temp2)
21952 delete arg2;
21953 }
21954 {
21955 if (temp3)
21956 delete arg3;
21957 }
21958 return NULL;
21959 }
21960
21961
21962 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21963 PyObject *resultobj = 0;
21964 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21965 wxString *arg2 = 0 ;
21966 wxString *arg3 = 0 ;
21967 bool result;
21968 void *argp1 = 0 ;
21969 int res1 = 0 ;
21970 bool temp2 = false ;
21971 bool temp3 = false ;
21972 PyObject * obj0 = 0 ;
21973 PyObject * obj1 = 0 ;
21974 PyObject * obj2 = 0 ;
21975 char * kwnames[] = {
21976 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21977 };
21978
21979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21981 if (!SWIG_IsOK(res1)) {
21982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21983 }
21984 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21985 {
21986 arg2 = wxString_in_helper(obj1);
21987 if (arg2 == NULL) SWIG_fail;
21988 temp2 = true;
21989 }
21990 {
21991 arg3 = wxString_in_helper(obj2);
21992 if (arg3 == NULL) SWIG_fail;
21993 temp3 = true;
21994 }
21995 {
21996 PyThreadState* __tstate = wxPyBeginAllowThreads();
21997 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
21998 wxPyEndAllowThreads(__tstate);
21999 if (PyErr_Occurred()) SWIG_fail;
22000 }
22001 {
22002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22003 }
22004 {
22005 if (temp2)
22006 delete arg2;
22007 }
22008 {
22009 if (temp3)
22010 delete arg3;
22011 }
22012 return resultobj;
22013 fail:
22014 {
22015 if (temp2)
22016 delete arg2;
22017 }
22018 {
22019 if (temp3)
22020 delete arg3;
22021 }
22022 return NULL;
22023 }
22024
22025
22026 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22027 PyObject *resultobj = 0;
22028 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22029 wxString *arg2 = 0 ;
22030 bool arg3 = (bool) true ;
22031 bool result;
22032 void *argp1 = 0 ;
22033 int res1 = 0 ;
22034 bool temp2 = false ;
22035 bool val3 ;
22036 int ecode3 = 0 ;
22037 PyObject * obj0 = 0 ;
22038 PyObject * obj1 = 0 ;
22039 PyObject * obj2 = 0 ;
22040 char * kwnames[] = {
22041 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22042 };
22043
22044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22046 if (!SWIG_IsOK(res1)) {
22047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22048 }
22049 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22050 {
22051 arg2 = wxString_in_helper(obj1);
22052 if (arg2 == NULL) SWIG_fail;
22053 temp2 = true;
22054 }
22055 if (obj2) {
22056 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22057 if (!SWIG_IsOK(ecode3)) {
22058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22059 }
22060 arg3 = static_cast< bool >(val3);
22061 }
22062 {
22063 PyThreadState* __tstate = wxPyBeginAllowThreads();
22064 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22065 wxPyEndAllowThreads(__tstate);
22066 if (PyErr_Occurred()) SWIG_fail;
22067 }
22068 {
22069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22070 }
22071 {
22072 if (temp2)
22073 delete arg2;
22074 }
22075 return resultobj;
22076 fail:
22077 {
22078 if (temp2)
22079 delete arg2;
22080 }
22081 return NULL;
22082 }
22083
22084
22085 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22086 PyObject *resultobj = 0;
22087 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22088 wxString *arg2 = 0 ;
22089 bool result;
22090 void *argp1 = 0 ;
22091 int res1 = 0 ;
22092 bool temp2 = false ;
22093 PyObject * obj0 = 0 ;
22094 PyObject * obj1 = 0 ;
22095 char * kwnames[] = {
22096 (char *) "self",(char *) "key", NULL
22097 };
22098
22099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22101 if (!SWIG_IsOK(res1)) {
22102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22103 }
22104 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22105 {
22106 arg2 = wxString_in_helper(obj1);
22107 if (arg2 == NULL) SWIG_fail;
22108 temp2 = true;
22109 }
22110 {
22111 PyThreadState* __tstate = wxPyBeginAllowThreads();
22112 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22113 wxPyEndAllowThreads(__tstate);
22114 if (PyErr_Occurred()) SWIG_fail;
22115 }
22116 {
22117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22118 }
22119 {
22120 if (temp2)
22121 delete arg2;
22122 }
22123 return resultobj;
22124 fail:
22125 {
22126 if (temp2)
22127 delete arg2;
22128 }
22129 return NULL;
22130 }
22131
22132
22133 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22134 PyObject *resultobj = 0;
22135 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22136 bool result;
22137 void *argp1 = 0 ;
22138 int res1 = 0 ;
22139 PyObject *swig_obj[1] ;
22140
22141 if (!args) SWIG_fail;
22142 swig_obj[0] = args;
22143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22144 if (!SWIG_IsOK(res1)) {
22145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22146 }
22147 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22148 {
22149 PyThreadState* __tstate = wxPyBeginAllowThreads();
22150 result = (bool)(arg1)->DeleteAll();
22151 wxPyEndAllowThreads(__tstate);
22152 if (PyErr_Occurred()) SWIG_fail;
22153 }
22154 {
22155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22156 }
22157 return resultobj;
22158 fail:
22159 return NULL;
22160 }
22161
22162
22163 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22164 PyObject *resultobj = 0;
22165 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22166 bool arg2 = (bool) true ;
22167 void *argp1 = 0 ;
22168 int res1 = 0 ;
22169 bool val2 ;
22170 int ecode2 = 0 ;
22171 PyObject * obj0 = 0 ;
22172 PyObject * obj1 = 0 ;
22173 char * kwnames[] = {
22174 (char *) "self",(char *) "doIt", NULL
22175 };
22176
22177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22179 if (!SWIG_IsOK(res1)) {
22180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22181 }
22182 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22183 if (obj1) {
22184 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22185 if (!SWIG_IsOK(ecode2)) {
22186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22187 }
22188 arg2 = static_cast< bool >(val2);
22189 }
22190 {
22191 PyThreadState* __tstate = wxPyBeginAllowThreads();
22192 (arg1)->SetExpandEnvVars(arg2);
22193 wxPyEndAllowThreads(__tstate);
22194 if (PyErr_Occurred()) SWIG_fail;
22195 }
22196 resultobj = SWIG_Py_Void();
22197 return resultobj;
22198 fail:
22199 return NULL;
22200 }
22201
22202
22203 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22204 PyObject *resultobj = 0;
22205 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22206 bool result;
22207 void *argp1 = 0 ;
22208 int res1 = 0 ;
22209 PyObject *swig_obj[1] ;
22210
22211 if (!args) SWIG_fail;
22212 swig_obj[0] = args;
22213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22214 if (!SWIG_IsOK(res1)) {
22215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22216 }
22217 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22218 {
22219 PyThreadState* __tstate = wxPyBeginAllowThreads();
22220 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22221 wxPyEndAllowThreads(__tstate);
22222 if (PyErr_Occurred()) SWIG_fail;
22223 }
22224 {
22225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22226 }
22227 return resultobj;
22228 fail:
22229 return NULL;
22230 }
22231
22232
22233 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22234 PyObject *resultobj = 0;
22235 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22236 bool arg2 = (bool) true ;
22237 void *argp1 = 0 ;
22238 int res1 = 0 ;
22239 bool val2 ;
22240 int ecode2 = 0 ;
22241 PyObject * obj0 = 0 ;
22242 PyObject * obj1 = 0 ;
22243 char * kwnames[] = {
22244 (char *) "self",(char *) "doIt", NULL
22245 };
22246
22247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22249 if (!SWIG_IsOK(res1)) {
22250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22251 }
22252 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22253 if (obj1) {
22254 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22255 if (!SWIG_IsOK(ecode2)) {
22256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22257 }
22258 arg2 = static_cast< bool >(val2);
22259 }
22260 {
22261 PyThreadState* __tstate = wxPyBeginAllowThreads();
22262 (arg1)->SetRecordDefaults(arg2);
22263 wxPyEndAllowThreads(__tstate);
22264 if (PyErr_Occurred()) SWIG_fail;
22265 }
22266 resultobj = SWIG_Py_Void();
22267 return resultobj;
22268 fail:
22269 return NULL;
22270 }
22271
22272
22273 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22274 PyObject *resultobj = 0;
22275 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22276 bool result;
22277 void *argp1 = 0 ;
22278 int res1 = 0 ;
22279 PyObject *swig_obj[1] ;
22280
22281 if (!args) SWIG_fail;
22282 swig_obj[0] = args;
22283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22284 if (!SWIG_IsOK(res1)) {
22285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22286 }
22287 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22288 {
22289 PyThreadState* __tstate = wxPyBeginAllowThreads();
22290 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22291 wxPyEndAllowThreads(__tstate);
22292 if (PyErr_Occurred()) SWIG_fail;
22293 }
22294 {
22295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22296 }
22297 return resultobj;
22298 fail:
22299 return NULL;
22300 }
22301
22302
22303 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22304 PyObject *resultobj = 0;
22305 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22306 wxString *arg2 = 0 ;
22307 wxString result;
22308 void *argp1 = 0 ;
22309 int res1 = 0 ;
22310 bool temp2 = false ;
22311 PyObject * obj0 = 0 ;
22312 PyObject * obj1 = 0 ;
22313 char * kwnames[] = {
22314 (char *) "self",(char *) "str", NULL
22315 };
22316
22317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22319 if (!SWIG_IsOK(res1)) {
22320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22321 }
22322 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22323 {
22324 arg2 = wxString_in_helper(obj1);
22325 if (arg2 == NULL) SWIG_fail;
22326 temp2 = true;
22327 }
22328 {
22329 PyThreadState* __tstate = wxPyBeginAllowThreads();
22330 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22331 wxPyEndAllowThreads(__tstate);
22332 if (PyErr_Occurred()) SWIG_fail;
22333 }
22334 {
22335 #if wxUSE_UNICODE
22336 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22337 #else
22338 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22339 #endif
22340 }
22341 {
22342 if (temp2)
22343 delete arg2;
22344 }
22345 return resultobj;
22346 fail:
22347 {
22348 if (temp2)
22349 delete arg2;
22350 }
22351 return NULL;
22352 }
22353
22354
22355 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22356 PyObject *resultobj = 0;
22357 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22358 wxString result;
22359 void *argp1 = 0 ;
22360 int res1 = 0 ;
22361 PyObject *swig_obj[1] ;
22362
22363 if (!args) SWIG_fail;
22364 swig_obj[0] = args;
22365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22366 if (!SWIG_IsOK(res1)) {
22367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22368 }
22369 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22370 {
22371 PyThreadState* __tstate = wxPyBeginAllowThreads();
22372 result = ((wxConfigBase const *)arg1)->GetAppName();
22373 wxPyEndAllowThreads(__tstate);
22374 if (PyErr_Occurred()) SWIG_fail;
22375 }
22376 {
22377 #if wxUSE_UNICODE
22378 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22379 #else
22380 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22381 #endif
22382 }
22383 return resultobj;
22384 fail:
22385 return NULL;
22386 }
22387
22388
22389 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22390 PyObject *resultobj = 0;
22391 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22392 wxString result;
22393 void *argp1 = 0 ;
22394 int res1 = 0 ;
22395 PyObject *swig_obj[1] ;
22396
22397 if (!args) SWIG_fail;
22398 swig_obj[0] = args;
22399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22400 if (!SWIG_IsOK(res1)) {
22401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22402 }
22403 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22404 {
22405 PyThreadState* __tstate = wxPyBeginAllowThreads();
22406 result = ((wxConfigBase const *)arg1)->GetVendorName();
22407 wxPyEndAllowThreads(__tstate);
22408 if (PyErr_Occurred()) SWIG_fail;
22409 }
22410 {
22411 #if wxUSE_UNICODE
22412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22413 #else
22414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22415 #endif
22416 }
22417 return resultobj;
22418 fail:
22419 return NULL;
22420 }
22421
22422
22423 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22424 PyObject *resultobj = 0;
22425 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22426 wxString *arg2 = 0 ;
22427 void *argp1 = 0 ;
22428 int res1 = 0 ;
22429 bool temp2 = false ;
22430 PyObject * obj0 = 0 ;
22431 PyObject * obj1 = 0 ;
22432 char * kwnames[] = {
22433 (char *) "self",(char *) "appName", NULL
22434 };
22435
22436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22438 if (!SWIG_IsOK(res1)) {
22439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22440 }
22441 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22442 {
22443 arg2 = wxString_in_helper(obj1);
22444 if (arg2 == NULL) SWIG_fail;
22445 temp2 = true;
22446 }
22447 {
22448 PyThreadState* __tstate = wxPyBeginAllowThreads();
22449 (arg1)->SetAppName((wxString const &)*arg2);
22450 wxPyEndAllowThreads(__tstate);
22451 if (PyErr_Occurred()) SWIG_fail;
22452 }
22453 resultobj = SWIG_Py_Void();
22454 {
22455 if (temp2)
22456 delete arg2;
22457 }
22458 return resultobj;
22459 fail:
22460 {
22461 if (temp2)
22462 delete arg2;
22463 }
22464 return NULL;
22465 }
22466
22467
22468 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22469 PyObject *resultobj = 0;
22470 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22471 wxString *arg2 = 0 ;
22472 void *argp1 = 0 ;
22473 int res1 = 0 ;
22474 bool temp2 = false ;
22475 PyObject * obj0 = 0 ;
22476 PyObject * obj1 = 0 ;
22477 char * kwnames[] = {
22478 (char *) "self",(char *) "vendorName", NULL
22479 };
22480
22481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22483 if (!SWIG_IsOK(res1)) {
22484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22485 }
22486 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22487 {
22488 arg2 = wxString_in_helper(obj1);
22489 if (arg2 == NULL) SWIG_fail;
22490 temp2 = true;
22491 }
22492 {
22493 PyThreadState* __tstate = wxPyBeginAllowThreads();
22494 (arg1)->SetVendorName((wxString const &)*arg2);
22495 wxPyEndAllowThreads(__tstate);
22496 if (PyErr_Occurred()) SWIG_fail;
22497 }
22498 resultobj = SWIG_Py_Void();
22499 {
22500 if (temp2)
22501 delete arg2;
22502 }
22503 return resultobj;
22504 fail:
22505 {
22506 if (temp2)
22507 delete arg2;
22508 }
22509 return NULL;
22510 }
22511
22512
22513 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22514 PyObject *resultobj = 0;
22515 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22516 long arg2 ;
22517 void *argp1 = 0 ;
22518 int res1 = 0 ;
22519 long val2 ;
22520 int ecode2 = 0 ;
22521 PyObject * obj0 = 0 ;
22522 PyObject * obj1 = 0 ;
22523 char * kwnames[] = {
22524 (char *) "self",(char *) "style", NULL
22525 };
22526
22527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22529 if (!SWIG_IsOK(res1)) {
22530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22531 }
22532 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22533 ecode2 = SWIG_AsVal_long(obj1, &val2);
22534 if (!SWIG_IsOK(ecode2)) {
22535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22536 }
22537 arg2 = static_cast< long >(val2);
22538 {
22539 PyThreadState* __tstate = wxPyBeginAllowThreads();
22540 (arg1)->SetStyle(arg2);
22541 wxPyEndAllowThreads(__tstate);
22542 if (PyErr_Occurred()) SWIG_fail;
22543 }
22544 resultobj = SWIG_Py_Void();
22545 return resultobj;
22546 fail:
22547 return NULL;
22548 }
22549
22550
22551 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22552 PyObject *resultobj = 0;
22553 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22554 long result;
22555 void *argp1 = 0 ;
22556 int res1 = 0 ;
22557 PyObject *swig_obj[1] ;
22558
22559 if (!args) SWIG_fail;
22560 swig_obj[0] = args;
22561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22562 if (!SWIG_IsOK(res1)) {
22563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22564 }
22565 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22566 {
22567 PyThreadState* __tstate = wxPyBeginAllowThreads();
22568 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22569 wxPyEndAllowThreads(__tstate);
22570 if (PyErr_Occurred()) SWIG_fail;
22571 }
22572 resultobj = SWIG_From_long(static_cast< long >(result));
22573 return resultobj;
22574 fail:
22575 return NULL;
22576 }
22577
22578
22579 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22580 PyObject *obj;
22581 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22582 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22583 return SWIG_Py_Void();
22584 }
22585
22586 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22587 PyObject *resultobj = 0;
22588 wxString const &arg1_defvalue = wxPyEmptyString ;
22589 wxString *arg1 = (wxString *) &arg1_defvalue ;
22590 wxString const &arg2_defvalue = wxPyEmptyString ;
22591 wxString *arg2 = (wxString *) &arg2_defvalue ;
22592 wxString const &arg3_defvalue = wxPyEmptyString ;
22593 wxString *arg3 = (wxString *) &arg3_defvalue ;
22594 wxString const &arg4_defvalue = wxPyEmptyString ;
22595 wxString *arg4 = (wxString *) &arg4_defvalue ;
22596 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22597 wxConfig *result = 0 ;
22598 bool temp1 = false ;
22599 bool temp2 = false ;
22600 bool temp3 = false ;
22601 bool temp4 = false ;
22602 long val5 ;
22603 int ecode5 = 0 ;
22604 PyObject * obj0 = 0 ;
22605 PyObject * obj1 = 0 ;
22606 PyObject * obj2 = 0 ;
22607 PyObject * obj3 = 0 ;
22608 PyObject * obj4 = 0 ;
22609 char * kwnames[] = {
22610 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22611 };
22612
22613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22614 if (obj0) {
22615 {
22616 arg1 = wxString_in_helper(obj0);
22617 if (arg1 == NULL) SWIG_fail;
22618 temp1 = true;
22619 }
22620 }
22621 if (obj1) {
22622 {
22623 arg2 = wxString_in_helper(obj1);
22624 if (arg2 == NULL) SWIG_fail;
22625 temp2 = true;
22626 }
22627 }
22628 if (obj2) {
22629 {
22630 arg3 = wxString_in_helper(obj2);
22631 if (arg3 == NULL) SWIG_fail;
22632 temp3 = true;
22633 }
22634 }
22635 if (obj3) {
22636 {
22637 arg4 = wxString_in_helper(obj3);
22638 if (arg4 == NULL) SWIG_fail;
22639 temp4 = true;
22640 }
22641 }
22642 if (obj4) {
22643 ecode5 = SWIG_AsVal_long(obj4, &val5);
22644 if (!SWIG_IsOK(ecode5)) {
22645 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22646 }
22647 arg5 = static_cast< long >(val5);
22648 }
22649 {
22650 PyThreadState* __tstate = wxPyBeginAllowThreads();
22651 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22652 wxPyEndAllowThreads(__tstate);
22653 if (PyErr_Occurred()) SWIG_fail;
22654 }
22655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22656 {
22657 if (temp1)
22658 delete arg1;
22659 }
22660 {
22661 if (temp2)
22662 delete arg2;
22663 }
22664 {
22665 if (temp3)
22666 delete arg3;
22667 }
22668 {
22669 if (temp4)
22670 delete arg4;
22671 }
22672 return resultobj;
22673 fail:
22674 {
22675 if (temp1)
22676 delete arg1;
22677 }
22678 {
22679 if (temp2)
22680 delete arg2;
22681 }
22682 {
22683 if (temp3)
22684 delete arg3;
22685 }
22686 {
22687 if (temp4)
22688 delete arg4;
22689 }
22690 return NULL;
22691 }
22692
22693
22694 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22695 PyObject *resultobj = 0;
22696 wxConfig *arg1 = (wxConfig *) 0 ;
22697 void *argp1 = 0 ;
22698 int res1 = 0 ;
22699 PyObject *swig_obj[1] ;
22700
22701 if (!args) SWIG_fail;
22702 swig_obj[0] = args;
22703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22704 if (!SWIG_IsOK(res1)) {
22705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22706 }
22707 arg1 = reinterpret_cast< wxConfig * >(argp1);
22708 {
22709 PyThreadState* __tstate = wxPyBeginAllowThreads();
22710 delete arg1;
22711
22712 wxPyEndAllowThreads(__tstate);
22713 if (PyErr_Occurred()) SWIG_fail;
22714 }
22715 resultobj = SWIG_Py_Void();
22716 return resultobj;
22717 fail:
22718 return NULL;
22719 }
22720
22721
22722 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22723 PyObject *obj;
22724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22725 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22726 return SWIG_Py_Void();
22727 }
22728
22729 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22730 return SWIG_Python_InitShadowInstance(args);
22731 }
22732
22733 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22734 PyObject *resultobj = 0;
22735 wxString const &arg1_defvalue = wxPyEmptyString ;
22736 wxString *arg1 = (wxString *) &arg1_defvalue ;
22737 wxString const &arg2_defvalue = wxPyEmptyString ;
22738 wxString *arg2 = (wxString *) &arg2_defvalue ;
22739 wxString const &arg3_defvalue = wxPyEmptyString ;
22740 wxString *arg3 = (wxString *) &arg3_defvalue ;
22741 wxString const &arg4_defvalue = wxPyEmptyString ;
22742 wxString *arg4 = (wxString *) &arg4_defvalue ;
22743 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22744 wxFileConfig *result = 0 ;
22745 bool temp1 = false ;
22746 bool temp2 = false ;
22747 bool temp3 = false ;
22748 bool temp4 = false ;
22749 long val5 ;
22750 int ecode5 = 0 ;
22751 PyObject * obj0 = 0 ;
22752 PyObject * obj1 = 0 ;
22753 PyObject * obj2 = 0 ;
22754 PyObject * obj3 = 0 ;
22755 PyObject * obj4 = 0 ;
22756 char * kwnames[] = {
22757 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22758 };
22759
22760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22761 if (obj0) {
22762 {
22763 arg1 = wxString_in_helper(obj0);
22764 if (arg1 == NULL) SWIG_fail;
22765 temp1 = true;
22766 }
22767 }
22768 if (obj1) {
22769 {
22770 arg2 = wxString_in_helper(obj1);
22771 if (arg2 == NULL) SWIG_fail;
22772 temp2 = true;
22773 }
22774 }
22775 if (obj2) {
22776 {
22777 arg3 = wxString_in_helper(obj2);
22778 if (arg3 == NULL) SWIG_fail;
22779 temp3 = true;
22780 }
22781 }
22782 if (obj3) {
22783 {
22784 arg4 = wxString_in_helper(obj3);
22785 if (arg4 == NULL) SWIG_fail;
22786 temp4 = true;
22787 }
22788 }
22789 if (obj4) {
22790 ecode5 = SWIG_AsVal_long(obj4, &val5);
22791 if (!SWIG_IsOK(ecode5)) {
22792 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22793 }
22794 arg5 = static_cast< long >(val5);
22795 }
22796 {
22797 PyThreadState* __tstate = wxPyBeginAllowThreads();
22798 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22799 wxPyEndAllowThreads(__tstate);
22800 if (PyErr_Occurred()) SWIG_fail;
22801 }
22802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22803 {
22804 if (temp1)
22805 delete arg1;
22806 }
22807 {
22808 if (temp2)
22809 delete arg2;
22810 }
22811 {
22812 if (temp3)
22813 delete arg3;
22814 }
22815 {
22816 if (temp4)
22817 delete arg4;
22818 }
22819 return resultobj;
22820 fail:
22821 {
22822 if (temp1)
22823 delete arg1;
22824 }
22825 {
22826 if (temp2)
22827 delete arg2;
22828 }
22829 {
22830 if (temp3)
22831 delete arg3;
22832 }
22833 {
22834 if (temp4)
22835 delete arg4;
22836 }
22837 return NULL;
22838 }
22839
22840
22841 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22842 PyObject *resultobj = 0;
22843 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22844 void *argp1 = 0 ;
22845 int res1 = 0 ;
22846 PyObject *swig_obj[1] ;
22847
22848 if (!args) SWIG_fail;
22849 swig_obj[0] = args;
22850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22851 if (!SWIG_IsOK(res1)) {
22852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22853 }
22854 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22855 {
22856 PyThreadState* __tstate = wxPyBeginAllowThreads();
22857 delete arg1;
22858
22859 wxPyEndAllowThreads(__tstate);
22860 if (PyErr_Occurred()) SWIG_fail;
22861 }
22862 resultobj = SWIG_Py_Void();
22863 return resultobj;
22864 fail:
22865 return NULL;
22866 }
22867
22868
22869 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22870 PyObject *obj;
22871 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22872 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22873 return SWIG_Py_Void();
22874 }
22875
22876 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22877 return SWIG_Python_InitShadowInstance(args);
22878 }
22879
22880 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22881 PyObject *resultobj = 0;
22882 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22883 wxString *arg2 = 0 ;
22884 wxConfigPathChanger *result = 0 ;
22885 void *argp1 = 0 ;
22886 int res1 = 0 ;
22887 bool temp2 = false ;
22888 PyObject * obj0 = 0 ;
22889 PyObject * obj1 = 0 ;
22890 char * kwnames[] = {
22891 (char *) "config",(char *) "entry", NULL
22892 };
22893
22894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22896 if (!SWIG_IsOK(res1)) {
22897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22898 }
22899 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22900 {
22901 arg2 = wxString_in_helper(obj1);
22902 if (arg2 == NULL) SWIG_fail;
22903 temp2 = true;
22904 }
22905 {
22906 PyThreadState* __tstate = wxPyBeginAllowThreads();
22907 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22908 wxPyEndAllowThreads(__tstate);
22909 if (PyErr_Occurred()) SWIG_fail;
22910 }
22911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
22912 {
22913 if (temp2)
22914 delete arg2;
22915 }
22916 return resultobj;
22917 fail:
22918 {
22919 if (temp2)
22920 delete arg2;
22921 }
22922 return NULL;
22923 }
22924
22925
22926 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22927 PyObject *resultobj = 0;
22928 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22929 void *argp1 = 0 ;
22930 int res1 = 0 ;
22931 PyObject *swig_obj[1] ;
22932
22933 if (!args) SWIG_fail;
22934 swig_obj[0] = args;
22935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
22936 if (!SWIG_IsOK(res1)) {
22937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
22938 }
22939 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22940 {
22941 PyThreadState* __tstate = wxPyBeginAllowThreads();
22942 delete arg1;
22943
22944 wxPyEndAllowThreads(__tstate);
22945 if (PyErr_Occurred()) SWIG_fail;
22946 }
22947 resultobj = SWIG_Py_Void();
22948 return resultobj;
22949 fail:
22950 return NULL;
22951 }
22952
22953
22954 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22955 PyObject *resultobj = 0;
22956 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22957 wxString *result = 0 ;
22958 void *argp1 = 0 ;
22959 int res1 = 0 ;
22960 PyObject *swig_obj[1] ;
22961
22962 if (!args) SWIG_fail;
22963 swig_obj[0] = args;
22964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
22965 if (!SWIG_IsOK(res1)) {
22966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
22967 }
22968 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22969 {
22970 PyThreadState* __tstate = wxPyBeginAllowThreads();
22971 {
22972 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
22973 result = (wxString *) &_result_ref;
22974 }
22975 wxPyEndAllowThreads(__tstate);
22976 if (PyErr_Occurred()) SWIG_fail;
22977 }
22978 {
22979 #if wxUSE_UNICODE
22980 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22981 #else
22982 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22983 #endif
22984 }
22985 return resultobj;
22986 fail:
22987 return NULL;
22988 }
22989
22990
22991 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22992 PyObject *obj;
22993 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22994 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
22995 return SWIG_Py_Void();
22996 }
22997
22998 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22999 return SWIG_Python_InitShadowInstance(args);
23000 }
23001
23002 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23003 PyObject *resultobj = 0;
23004 wxString *arg1 = 0 ;
23005 wxString result;
23006 bool temp1 = false ;
23007 PyObject * obj0 = 0 ;
23008 char * kwnames[] = {
23009 (char *) "sz", NULL
23010 };
23011
23012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23013 {
23014 arg1 = wxString_in_helper(obj0);
23015 if (arg1 == NULL) SWIG_fail;
23016 temp1 = true;
23017 }
23018 {
23019 PyThreadState* __tstate = wxPyBeginAllowThreads();
23020 result = wxExpandEnvVars((wxString const &)*arg1);
23021 wxPyEndAllowThreads(__tstate);
23022 if (PyErr_Occurred()) SWIG_fail;
23023 }
23024 {
23025 #if wxUSE_UNICODE
23026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23027 #else
23028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23029 #endif
23030 }
23031 {
23032 if (temp1)
23033 delete arg1;
23034 }
23035 return resultobj;
23036 fail:
23037 {
23038 if (temp1)
23039 delete arg1;
23040 }
23041 return NULL;
23042 }
23043
23044
23045 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23046 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23047 return 1;
23048 }
23049
23050
23051 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23052 PyObject *pyobj = 0;
23053
23054 {
23055 #if wxUSE_UNICODE
23056 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23057 #else
23058 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23059 #endif
23060 }
23061 return pyobj;
23062 }
23063
23064
23065 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23066 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23067 return 1;
23068 }
23069
23070
23071 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23072 PyObject *pyobj = 0;
23073
23074 {
23075 #if wxUSE_UNICODE
23076 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23077 #else
23078 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23079 #endif
23080 }
23081 return pyobj;
23082 }
23083
23084
23085 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23086 PyObject *resultobj = 0;
23087 wxDateTime::Country arg1 ;
23088 int val1 ;
23089 int ecode1 = 0 ;
23090 PyObject * obj0 = 0 ;
23091 char * kwnames[] = {
23092 (char *) "country", NULL
23093 };
23094
23095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23096 ecode1 = SWIG_AsVal_int(obj0, &val1);
23097 if (!SWIG_IsOK(ecode1)) {
23098 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23099 }
23100 arg1 = static_cast< wxDateTime::Country >(val1);
23101 {
23102 PyThreadState* __tstate = wxPyBeginAllowThreads();
23103 wxDateTime::SetCountry(arg1);
23104 wxPyEndAllowThreads(__tstate);
23105 if (PyErr_Occurred()) SWIG_fail;
23106 }
23107 resultobj = SWIG_Py_Void();
23108 return resultobj;
23109 fail:
23110 return NULL;
23111 }
23112
23113
23114 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23115 PyObject *resultobj = 0;
23116 wxDateTime::Country result;
23117
23118 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23119 {
23120 PyThreadState* __tstate = wxPyBeginAllowThreads();
23121 result = (wxDateTime::Country)wxDateTime::GetCountry();
23122 wxPyEndAllowThreads(__tstate);
23123 if (PyErr_Occurred()) SWIG_fail;
23124 }
23125 resultobj = SWIG_From_int(static_cast< int >(result));
23126 return resultobj;
23127 fail:
23128 return NULL;
23129 }
23130
23131
23132 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23133 PyObject *resultobj = 0;
23134 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23135 bool result;
23136 int val1 ;
23137 int ecode1 = 0 ;
23138 PyObject * obj0 = 0 ;
23139 char * kwnames[] = {
23140 (char *) "country", NULL
23141 };
23142
23143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23144 if (obj0) {
23145 ecode1 = SWIG_AsVal_int(obj0, &val1);
23146 if (!SWIG_IsOK(ecode1)) {
23147 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23148 }
23149 arg1 = static_cast< wxDateTime::Country >(val1);
23150 }
23151 {
23152 PyThreadState* __tstate = wxPyBeginAllowThreads();
23153 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23154 wxPyEndAllowThreads(__tstate);
23155 if (PyErr_Occurred()) SWIG_fail;
23156 }
23157 {
23158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23159 }
23160 return resultobj;
23161 fail:
23162 return NULL;
23163 }
23164
23165
23166 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23167 PyObject *resultobj = 0;
23168 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23169 int result;
23170 int val1 ;
23171 int ecode1 = 0 ;
23172 PyObject * obj0 = 0 ;
23173 char * kwnames[] = {
23174 (char *) "cal", NULL
23175 };
23176
23177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23178 if (obj0) {
23179 ecode1 = SWIG_AsVal_int(obj0, &val1);
23180 if (!SWIG_IsOK(ecode1)) {
23181 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23182 }
23183 arg1 = static_cast< wxDateTime::Calendar >(val1);
23184 }
23185 {
23186 PyThreadState* __tstate = wxPyBeginAllowThreads();
23187 result = (int)wxDateTime::GetCurrentYear(arg1);
23188 wxPyEndAllowThreads(__tstate);
23189 if (PyErr_Occurred()) SWIG_fail;
23190 }
23191 resultobj = SWIG_From_int(static_cast< int >(result));
23192 return resultobj;
23193 fail:
23194 return NULL;
23195 }
23196
23197
23198 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23199 PyObject *resultobj = 0;
23200 int arg1 ;
23201 int result;
23202 int val1 ;
23203 int ecode1 = 0 ;
23204 PyObject * obj0 = 0 ;
23205 char * kwnames[] = {
23206 (char *) "year", NULL
23207 };
23208
23209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23210 ecode1 = SWIG_AsVal_int(obj0, &val1);
23211 if (!SWIG_IsOK(ecode1)) {
23212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23213 }
23214 arg1 = static_cast< int >(val1);
23215 {
23216 PyThreadState* __tstate = wxPyBeginAllowThreads();
23217 result = (int)wxDateTime::ConvertYearToBC(arg1);
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_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23229 PyObject *resultobj = 0;
23230 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23231 wxDateTime::Month result;
23232 int val1 ;
23233 int ecode1 = 0 ;
23234 PyObject * obj0 = 0 ;
23235 char * kwnames[] = {
23236 (char *) "cal", NULL
23237 };
23238
23239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",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_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23244 }
23245 arg1 = static_cast< wxDateTime::Calendar >(val1);
23246 }
23247 {
23248 PyThreadState* __tstate = wxPyBeginAllowThreads();
23249 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23250 wxPyEndAllowThreads(__tstate);
23251 if (PyErr_Occurred()) SWIG_fail;
23252 }
23253 resultobj = SWIG_From_int(static_cast< int >(result));
23254 return resultobj;
23255 fail:
23256 return NULL;
23257 }
23258
23259
23260 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23261 PyObject *resultobj = 0;
23262 int arg1 = (int) wxDateTime::Inv_Year ;
23263 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23264 bool result;
23265 int val1 ;
23266 int ecode1 = 0 ;
23267 int val2 ;
23268 int ecode2 = 0 ;
23269 PyObject * obj0 = 0 ;
23270 PyObject * obj1 = 0 ;
23271 char * kwnames[] = {
23272 (char *) "year",(char *) "cal", NULL
23273 };
23274
23275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23276 if (obj0) {
23277 ecode1 = SWIG_AsVal_int(obj0, &val1);
23278 if (!SWIG_IsOK(ecode1)) {
23279 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23280 }
23281 arg1 = static_cast< int >(val1);
23282 }
23283 if (obj1) {
23284 ecode2 = SWIG_AsVal_int(obj1, &val2);
23285 if (!SWIG_IsOK(ecode2)) {
23286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23287 }
23288 arg2 = static_cast< wxDateTime::Calendar >(val2);
23289 }
23290 {
23291 PyThreadState* __tstate = wxPyBeginAllowThreads();
23292 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23293 wxPyEndAllowThreads(__tstate);
23294 if (PyErr_Occurred()) SWIG_fail;
23295 }
23296 {
23297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23298 }
23299 return resultobj;
23300 fail:
23301 return NULL;
23302 }
23303
23304
23305 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23306 PyObject *resultobj = 0;
23307 int arg1 = (int) wxDateTime::Inv_Year ;
23308 int result;
23309 int val1 ;
23310 int ecode1 = 0 ;
23311 PyObject * obj0 = 0 ;
23312 char * kwnames[] = {
23313 (char *) "year", NULL
23314 };
23315
23316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23317 if (obj0) {
23318 ecode1 = SWIG_AsVal_int(obj0, &val1);
23319 if (!SWIG_IsOK(ecode1)) {
23320 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23321 }
23322 arg1 = static_cast< int >(val1);
23323 }
23324 {
23325 PyThreadState* __tstate = wxPyBeginAllowThreads();
23326 result = (int)wxDateTime::GetCentury(arg1);
23327 wxPyEndAllowThreads(__tstate);
23328 if (PyErr_Occurred()) SWIG_fail;
23329 }
23330 resultobj = SWIG_From_int(static_cast< int >(result));
23331 return resultobj;
23332 fail:
23333 return NULL;
23334 }
23335
23336
23337 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23338 PyObject *resultobj = 0;
23339 int arg1 ;
23340 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23341 int result;
23342 int val1 ;
23343 int ecode1 = 0 ;
23344 int val2 ;
23345 int ecode2 = 0 ;
23346 PyObject * obj0 = 0 ;
23347 PyObject * obj1 = 0 ;
23348 char * kwnames[] = {
23349 (char *) "year",(char *) "cal", NULL
23350 };
23351
23352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23353 ecode1 = SWIG_AsVal_int(obj0, &val1);
23354 if (!SWIG_IsOK(ecode1)) {
23355 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23356 }
23357 arg1 = static_cast< int >(val1);
23358 if (obj1) {
23359 ecode2 = SWIG_AsVal_int(obj1, &val2);
23360 if (!SWIG_IsOK(ecode2)) {
23361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23362 }
23363 arg2 = static_cast< wxDateTime::Calendar >(val2);
23364 }
23365 {
23366 PyThreadState* __tstate = wxPyBeginAllowThreads();
23367 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23368 wxPyEndAllowThreads(__tstate);
23369 if (PyErr_Occurred()) SWIG_fail;
23370 }
23371 resultobj = SWIG_From_int(static_cast< int >(result));
23372 return resultobj;
23373 fail:
23374 return NULL;
23375 }
23376
23377
23378 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23379 PyObject *resultobj = 0;
23380 wxDateTime::Month arg1 ;
23381 int arg2 = (int) wxDateTime::Inv_Year ;
23382 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23383 int result;
23384 int val1 ;
23385 int ecode1 = 0 ;
23386 int val2 ;
23387 int ecode2 = 0 ;
23388 int val3 ;
23389 int ecode3 = 0 ;
23390 PyObject * obj0 = 0 ;
23391 PyObject * obj1 = 0 ;
23392 PyObject * obj2 = 0 ;
23393 char * kwnames[] = {
23394 (char *) "month",(char *) "year",(char *) "cal", NULL
23395 };
23396
23397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23398 ecode1 = SWIG_AsVal_int(obj0, &val1);
23399 if (!SWIG_IsOK(ecode1)) {
23400 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23401 }
23402 arg1 = static_cast< wxDateTime::Month >(val1);
23403 if (obj1) {
23404 ecode2 = SWIG_AsVal_int(obj1, &val2);
23405 if (!SWIG_IsOK(ecode2)) {
23406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23407 }
23408 arg2 = static_cast< int >(val2);
23409 }
23410 if (obj2) {
23411 ecode3 = SWIG_AsVal_int(obj2, &val3);
23412 if (!SWIG_IsOK(ecode3)) {
23413 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23414 }
23415 arg3 = static_cast< wxDateTime::Calendar >(val3);
23416 }
23417 {
23418 PyThreadState* __tstate = wxPyBeginAllowThreads();
23419 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23420 wxPyEndAllowThreads(__tstate);
23421 if (PyErr_Occurred()) SWIG_fail;
23422 }
23423 resultobj = SWIG_From_int(static_cast< int >(result));
23424 return resultobj;
23425 fail:
23426 return NULL;
23427 }
23428
23429
23430 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23431 PyObject *resultobj = 0;
23432 wxDateTime::Month arg1 ;
23433 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23434 wxString result;
23435 int val1 ;
23436 int ecode1 = 0 ;
23437 int val2 ;
23438 int ecode2 = 0 ;
23439 PyObject * obj0 = 0 ;
23440 PyObject * obj1 = 0 ;
23441 char * kwnames[] = {
23442 (char *) "month",(char *) "flags", NULL
23443 };
23444
23445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23446 ecode1 = SWIG_AsVal_int(obj0, &val1);
23447 if (!SWIG_IsOK(ecode1)) {
23448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23449 }
23450 arg1 = static_cast< wxDateTime::Month >(val1);
23451 if (obj1) {
23452 ecode2 = SWIG_AsVal_int(obj1, &val2);
23453 if (!SWIG_IsOK(ecode2)) {
23454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23455 }
23456 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23457 }
23458 {
23459 PyThreadState* __tstate = wxPyBeginAllowThreads();
23460 result = wxDateTime::GetMonthName(arg1,arg2);
23461 wxPyEndAllowThreads(__tstate);
23462 if (PyErr_Occurred()) SWIG_fail;
23463 }
23464 {
23465 #if wxUSE_UNICODE
23466 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23467 #else
23468 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23469 #endif
23470 }
23471 return resultobj;
23472 fail:
23473 return NULL;
23474 }
23475
23476
23477 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23478 PyObject *resultobj = 0;
23479 wxDateTime::WeekDay arg1 ;
23480 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23481 wxString result;
23482 int val1 ;
23483 int ecode1 = 0 ;
23484 int val2 ;
23485 int ecode2 = 0 ;
23486 PyObject * obj0 = 0 ;
23487 PyObject * obj1 = 0 ;
23488 char * kwnames[] = {
23489 (char *) "weekday",(char *) "flags", NULL
23490 };
23491
23492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23493 ecode1 = SWIG_AsVal_int(obj0, &val1);
23494 if (!SWIG_IsOK(ecode1)) {
23495 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23496 }
23497 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23498 if (obj1) {
23499 ecode2 = SWIG_AsVal_int(obj1, &val2);
23500 if (!SWIG_IsOK(ecode2)) {
23501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23502 }
23503 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23504 }
23505 {
23506 PyThreadState* __tstate = wxPyBeginAllowThreads();
23507 result = wxDateTime::GetWeekDayName(arg1,arg2);
23508 wxPyEndAllowThreads(__tstate);
23509 if (PyErr_Occurred()) SWIG_fail;
23510 }
23511 {
23512 #if wxUSE_UNICODE
23513 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23514 #else
23515 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23516 #endif
23517 }
23518 return resultobj;
23519 fail:
23520 return NULL;
23521 }
23522
23523
23524 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23525 PyObject *resultobj = 0;
23526 PyObject *result = 0 ;
23527
23528 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23529 {
23530 PyThreadState* __tstate = wxPyBeginAllowThreads();
23531 result = (PyObject *)wxDateTime_GetAmPmStrings();
23532 wxPyEndAllowThreads(__tstate);
23533 if (PyErr_Occurred()) SWIG_fail;
23534 }
23535 resultobj = result;
23536 return resultobj;
23537 fail:
23538 return NULL;
23539 }
23540
23541
23542 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23543 PyObject *resultobj = 0;
23544 int arg1 = (int) wxDateTime::Inv_Year ;
23545 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23546 bool result;
23547 int val1 ;
23548 int ecode1 = 0 ;
23549 int val2 ;
23550 int ecode2 = 0 ;
23551 PyObject * obj0 = 0 ;
23552 PyObject * obj1 = 0 ;
23553 char * kwnames[] = {
23554 (char *) "year",(char *) "country", NULL
23555 };
23556
23557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23558 if (obj0) {
23559 ecode1 = SWIG_AsVal_int(obj0, &val1);
23560 if (!SWIG_IsOK(ecode1)) {
23561 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23562 }
23563 arg1 = static_cast< int >(val1);
23564 }
23565 if (obj1) {
23566 ecode2 = SWIG_AsVal_int(obj1, &val2);
23567 if (!SWIG_IsOK(ecode2)) {
23568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23569 }
23570 arg2 = static_cast< wxDateTime::Country >(val2);
23571 }
23572 {
23573 PyThreadState* __tstate = wxPyBeginAllowThreads();
23574 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23575 wxPyEndAllowThreads(__tstate);
23576 if (PyErr_Occurred()) SWIG_fail;
23577 }
23578 {
23579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23580 }
23581 return resultobj;
23582 fail:
23583 return NULL;
23584 }
23585
23586
23587 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23588 PyObject *resultobj = 0;
23589 int arg1 = (int) wxDateTime::Inv_Year ;
23590 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23591 wxDateTime result;
23592 int val1 ;
23593 int ecode1 = 0 ;
23594 int val2 ;
23595 int ecode2 = 0 ;
23596 PyObject * obj0 = 0 ;
23597 PyObject * obj1 = 0 ;
23598 char * kwnames[] = {
23599 (char *) "year",(char *) "country", NULL
23600 };
23601
23602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23603 if (obj0) {
23604 ecode1 = SWIG_AsVal_int(obj0, &val1);
23605 if (!SWIG_IsOK(ecode1)) {
23606 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23607 }
23608 arg1 = static_cast< int >(val1);
23609 }
23610 if (obj1) {
23611 ecode2 = SWIG_AsVal_int(obj1, &val2);
23612 if (!SWIG_IsOK(ecode2)) {
23613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23614 }
23615 arg2 = static_cast< wxDateTime::Country >(val2);
23616 }
23617 {
23618 PyThreadState* __tstate = wxPyBeginAllowThreads();
23619 result = wxDateTime::GetBeginDST(arg1,arg2);
23620 wxPyEndAllowThreads(__tstate);
23621 if (PyErr_Occurred()) SWIG_fail;
23622 }
23623 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23624 return resultobj;
23625 fail:
23626 return NULL;
23627 }
23628
23629
23630 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23631 PyObject *resultobj = 0;
23632 int arg1 = (int) wxDateTime::Inv_Year ;
23633 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23634 wxDateTime result;
23635 int val1 ;
23636 int ecode1 = 0 ;
23637 int val2 ;
23638 int ecode2 = 0 ;
23639 PyObject * obj0 = 0 ;
23640 PyObject * obj1 = 0 ;
23641 char * kwnames[] = {
23642 (char *) "year",(char *) "country", NULL
23643 };
23644
23645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23646 if (obj0) {
23647 ecode1 = SWIG_AsVal_int(obj0, &val1);
23648 if (!SWIG_IsOK(ecode1)) {
23649 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23650 }
23651 arg1 = static_cast< int >(val1);
23652 }
23653 if (obj1) {
23654 ecode2 = SWIG_AsVal_int(obj1, &val2);
23655 if (!SWIG_IsOK(ecode2)) {
23656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23657 }
23658 arg2 = static_cast< wxDateTime::Country >(val2);
23659 }
23660 {
23661 PyThreadState* __tstate = wxPyBeginAllowThreads();
23662 result = wxDateTime::GetEndDST(arg1,arg2);
23663 wxPyEndAllowThreads(__tstate);
23664 if (PyErr_Occurred()) SWIG_fail;
23665 }
23666 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23667 return resultobj;
23668 fail:
23669 return NULL;
23670 }
23671
23672
23673 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23674 PyObject *resultobj = 0;
23675 wxDateTime result;
23676
23677 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23678 {
23679 PyThreadState* __tstate = wxPyBeginAllowThreads();
23680 result = wxDateTime::Now();
23681 wxPyEndAllowThreads(__tstate);
23682 if (PyErr_Occurred()) SWIG_fail;
23683 }
23684 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23685 return resultobj;
23686 fail:
23687 return NULL;
23688 }
23689
23690
23691 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23692 PyObject *resultobj = 0;
23693 wxDateTime result;
23694
23695 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23696 {
23697 PyThreadState* __tstate = wxPyBeginAllowThreads();
23698 result = wxDateTime::UNow();
23699 wxPyEndAllowThreads(__tstate);
23700 if (PyErr_Occurred()) SWIG_fail;
23701 }
23702 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23703 return resultobj;
23704 fail:
23705 return NULL;
23706 }
23707
23708
23709 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23710 PyObject *resultobj = 0;
23711 wxDateTime result;
23712
23713 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23714 {
23715 PyThreadState* __tstate = wxPyBeginAllowThreads();
23716 result = wxDateTime::Today();
23717 wxPyEndAllowThreads(__tstate);
23718 if (PyErr_Occurred()) SWIG_fail;
23719 }
23720 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23721 return resultobj;
23722 fail:
23723 return NULL;
23724 }
23725
23726
23727 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23728 PyObject *resultobj = 0;
23729 wxDateTime *result = 0 ;
23730
23731 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23732 {
23733 PyThreadState* __tstate = wxPyBeginAllowThreads();
23734 result = (wxDateTime *)new wxDateTime();
23735 wxPyEndAllowThreads(__tstate);
23736 if (PyErr_Occurred()) SWIG_fail;
23737 }
23738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23739 return resultobj;
23740 fail:
23741 return NULL;
23742 }
23743
23744
23745 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23746 PyObject *resultobj = 0;
23747 time_t arg1 ;
23748 wxDateTime *result = 0 ;
23749 unsigned int val1 ;
23750 int ecode1 = 0 ;
23751 PyObject * obj0 = 0 ;
23752 char * kwnames[] = {
23753 (char *) "timet", NULL
23754 };
23755
23756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23757 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23758 if (!SWIG_IsOK(ecode1)) {
23759 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23760 }
23761 arg1 = static_cast< time_t >(val1);
23762 {
23763 PyThreadState* __tstate = wxPyBeginAllowThreads();
23764 result = (wxDateTime *)new wxDateTime(arg1);
23765 wxPyEndAllowThreads(__tstate);
23766 if (PyErr_Occurred()) SWIG_fail;
23767 }
23768 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23769 return resultobj;
23770 fail:
23771 return NULL;
23772 }
23773
23774
23775 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23776 PyObject *resultobj = 0;
23777 double arg1 ;
23778 wxDateTime *result = 0 ;
23779 double val1 ;
23780 int ecode1 = 0 ;
23781 PyObject * obj0 = 0 ;
23782 char * kwnames[] = {
23783 (char *) "jdn", NULL
23784 };
23785
23786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23787 ecode1 = SWIG_AsVal_double(obj0, &val1);
23788 if (!SWIG_IsOK(ecode1)) {
23789 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23790 }
23791 arg1 = static_cast< double >(val1);
23792 {
23793 PyThreadState* __tstate = wxPyBeginAllowThreads();
23794 result = (wxDateTime *)new wxDateTime(arg1);
23795 wxPyEndAllowThreads(__tstate);
23796 if (PyErr_Occurred()) SWIG_fail;
23797 }
23798 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23799 return resultobj;
23800 fail:
23801 return NULL;
23802 }
23803
23804
23805 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23806 PyObject *resultobj = 0;
23807 int arg1 ;
23808 int arg2 = (int) 0 ;
23809 int arg3 = (int) 0 ;
23810 int arg4 = (int) 0 ;
23811 wxDateTime *result = 0 ;
23812 int val1 ;
23813 int ecode1 = 0 ;
23814 int val2 ;
23815 int ecode2 = 0 ;
23816 int val3 ;
23817 int ecode3 = 0 ;
23818 int val4 ;
23819 int ecode4 = 0 ;
23820 PyObject * obj0 = 0 ;
23821 PyObject * obj1 = 0 ;
23822 PyObject * obj2 = 0 ;
23823 PyObject * obj3 = 0 ;
23824 char * kwnames[] = {
23825 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23826 };
23827
23828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23829 ecode1 = SWIG_AsVal_int(obj0, &val1);
23830 if (!SWIG_IsOK(ecode1)) {
23831 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23832 }
23833 arg1 = static_cast< int >(val1);
23834 if (obj1) {
23835 ecode2 = SWIG_AsVal_int(obj1, &val2);
23836 if (!SWIG_IsOK(ecode2)) {
23837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23838 }
23839 arg2 = static_cast< int >(val2);
23840 }
23841 if (obj2) {
23842 ecode3 = SWIG_AsVal_int(obj2, &val3);
23843 if (!SWIG_IsOK(ecode3)) {
23844 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23845 }
23846 arg3 = static_cast< int >(val3);
23847 }
23848 if (obj3) {
23849 ecode4 = SWIG_AsVal_int(obj3, &val4);
23850 if (!SWIG_IsOK(ecode4)) {
23851 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23852 }
23853 arg4 = static_cast< int >(val4);
23854 }
23855 {
23856 PyThreadState* __tstate = wxPyBeginAllowThreads();
23857 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23858 wxPyEndAllowThreads(__tstate);
23859 if (PyErr_Occurred()) SWIG_fail;
23860 }
23861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23862 return resultobj;
23863 fail:
23864 return NULL;
23865 }
23866
23867
23868 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23869 PyObject *resultobj = 0;
23870 int arg1 ;
23871 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23872 int arg3 = (int) wxDateTime::Inv_Year ;
23873 int arg4 = (int) 0 ;
23874 int arg5 = (int) 0 ;
23875 int arg6 = (int) 0 ;
23876 int arg7 = (int) 0 ;
23877 wxDateTime *result = 0 ;
23878 int val1 ;
23879 int ecode1 = 0 ;
23880 int val2 ;
23881 int ecode2 = 0 ;
23882 int val3 ;
23883 int ecode3 = 0 ;
23884 int val4 ;
23885 int ecode4 = 0 ;
23886 int val5 ;
23887 int ecode5 = 0 ;
23888 int val6 ;
23889 int ecode6 = 0 ;
23890 int val7 ;
23891 int ecode7 = 0 ;
23892 PyObject * obj0 = 0 ;
23893 PyObject * obj1 = 0 ;
23894 PyObject * obj2 = 0 ;
23895 PyObject * obj3 = 0 ;
23896 PyObject * obj4 = 0 ;
23897 PyObject * obj5 = 0 ;
23898 PyObject * obj6 = 0 ;
23899 char * kwnames[] = {
23900 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23901 };
23902
23903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23904 ecode1 = SWIG_AsVal_int(obj0, &val1);
23905 if (!SWIG_IsOK(ecode1)) {
23906 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23907 }
23908 arg1 = static_cast< int >(val1);
23909 if (obj1) {
23910 ecode2 = SWIG_AsVal_int(obj1, &val2);
23911 if (!SWIG_IsOK(ecode2)) {
23912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23913 }
23914 arg2 = static_cast< wxDateTime::Month >(val2);
23915 }
23916 if (obj2) {
23917 ecode3 = SWIG_AsVal_int(obj2, &val3);
23918 if (!SWIG_IsOK(ecode3)) {
23919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
23920 }
23921 arg3 = static_cast< int >(val3);
23922 }
23923 if (obj3) {
23924 ecode4 = SWIG_AsVal_int(obj3, &val4);
23925 if (!SWIG_IsOK(ecode4)) {
23926 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
23927 }
23928 arg4 = static_cast< int >(val4);
23929 }
23930 if (obj4) {
23931 ecode5 = SWIG_AsVal_int(obj4, &val5);
23932 if (!SWIG_IsOK(ecode5)) {
23933 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
23934 }
23935 arg5 = static_cast< int >(val5);
23936 }
23937 if (obj5) {
23938 ecode6 = SWIG_AsVal_int(obj5, &val6);
23939 if (!SWIG_IsOK(ecode6)) {
23940 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
23941 }
23942 arg6 = static_cast< int >(val6);
23943 }
23944 if (obj6) {
23945 ecode7 = SWIG_AsVal_int(obj6, &val7);
23946 if (!SWIG_IsOK(ecode7)) {
23947 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
23948 }
23949 arg7 = static_cast< int >(val7);
23950 }
23951 {
23952 PyThreadState* __tstate = wxPyBeginAllowThreads();
23953 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
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_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23965 PyObject *resultobj = 0;
23966 wxDateTime *arg1 = 0 ;
23967 wxDateTime *result = 0 ;
23968 void *argp1 = 0 ;
23969 int res1 = 0 ;
23970 PyObject * obj0 = 0 ;
23971 char * kwnames[] = {
23972 (char *) "date", NULL
23973 };
23974
23975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
23976 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
23977 if (!SWIG_IsOK(res1)) {
23978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23979 }
23980 if (!argp1) {
23981 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23982 }
23983 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23984 {
23985 PyThreadState* __tstate = wxPyBeginAllowThreads();
23986 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
23987 wxPyEndAllowThreads(__tstate);
23988 if (PyErr_Occurred()) SWIG_fail;
23989 }
23990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23991 return resultobj;
23992 fail:
23993 return NULL;
23994 }
23995
23996
23997 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23998 PyObject *resultobj = 0;
23999 wxDateTime *arg1 = (wxDateTime *) 0 ;
24000 void *argp1 = 0 ;
24001 int res1 = 0 ;
24002 PyObject *swig_obj[1] ;
24003
24004 if (!args) SWIG_fail;
24005 swig_obj[0] = args;
24006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24007 if (!SWIG_IsOK(res1)) {
24008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24009 }
24010 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24011 {
24012 PyThreadState* __tstate = wxPyBeginAllowThreads();
24013 delete arg1;
24014
24015 wxPyEndAllowThreads(__tstate);
24016 if (PyErr_Occurred()) SWIG_fail;
24017 }
24018 resultobj = SWIG_Py_Void();
24019 return resultobj;
24020 fail:
24021 return NULL;
24022 }
24023
24024
24025 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24026 PyObject *resultobj = 0;
24027 wxDateTime *arg1 = (wxDateTime *) 0 ;
24028 wxDateTime *result = 0 ;
24029 void *argp1 = 0 ;
24030 int res1 = 0 ;
24031 PyObject *swig_obj[1] ;
24032
24033 if (!args) SWIG_fail;
24034 swig_obj[0] = args;
24035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24036 if (!SWIG_IsOK(res1)) {
24037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24038 }
24039 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24040 {
24041 PyThreadState* __tstate = wxPyBeginAllowThreads();
24042 {
24043 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24044 result = (wxDateTime *) &_result_ref;
24045 }
24046 wxPyEndAllowThreads(__tstate);
24047 if (PyErr_Occurred()) SWIG_fail;
24048 }
24049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24050 return resultobj;
24051 fail:
24052 return NULL;
24053 }
24054
24055
24056 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24057 PyObject *resultobj = 0;
24058 wxDateTime *arg1 = (wxDateTime *) 0 ;
24059 time_t arg2 ;
24060 wxDateTime *result = 0 ;
24061 void *argp1 = 0 ;
24062 int res1 = 0 ;
24063 unsigned int val2 ;
24064 int ecode2 = 0 ;
24065 PyObject * obj0 = 0 ;
24066 PyObject * obj1 = 0 ;
24067 char * kwnames[] = {
24068 (char *) "self",(char *) "timet", NULL
24069 };
24070
24071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) 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 '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24075 }
24076 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24077 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24078 if (!SWIG_IsOK(ecode2)) {
24079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24080 }
24081 arg2 = static_cast< time_t >(val2);
24082 {
24083 PyThreadState* __tstate = wxPyBeginAllowThreads();
24084 {
24085 wxDateTime &_result_ref = (arg1)->Set(arg2);
24086 result = (wxDateTime *) &_result_ref;
24087 }
24088 wxPyEndAllowThreads(__tstate);
24089 if (PyErr_Occurred()) SWIG_fail;
24090 }
24091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24092 return resultobj;
24093 fail:
24094 return NULL;
24095 }
24096
24097
24098 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24099 PyObject *resultobj = 0;
24100 wxDateTime *arg1 = (wxDateTime *) 0 ;
24101 double arg2 ;
24102 wxDateTime *result = 0 ;
24103 void *argp1 = 0 ;
24104 int res1 = 0 ;
24105 double val2 ;
24106 int ecode2 = 0 ;
24107 PyObject * obj0 = 0 ;
24108 PyObject * obj1 = 0 ;
24109 char * kwnames[] = {
24110 (char *) "self",(char *) "jdn", NULL
24111 };
24112
24113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24115 if (!SWIG_IsOK(res1)) {
24116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24117 }
24118 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24119 ecode2 = SWIG_AsVal_double(obj1, &val2);
24120 if (!SWIG_IsOK(ecode2)) {
24121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24122 }
24123 arg2 = static_cast< double >(val2);
24124 {
24125 PyThreadState* __tstate = wxPyBeginAllowThreads();
24126 {
24127 wxDateTime &_result_ref = (arg1)->Set(arg2);
24128 result = (wxDateTime *) &_result_ref;
24129 }
24130 wxPyEndAllowThreads(__tstate);
24131 if (PyErr_Occurred()) SWIG_fail;
24132 }
24133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24134 return resultobj;
24135 fail:
24136 return NULL;
24137 }
24138
24139
24140 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24141 PyObject *resultobj = 0;
24142 wxDateTime *arg1 = (wxDateTime *) 0 ;
24143 int arg2 ;
24144 int arg3 = (int) 0 ;
24145 int arg4 = (int) 0 ;
24146 int arg5 = (int) 0 ;
24147 wxDateTime *result = 0 ;
24148 void *argp1 = 0 ;
24149 int res1 = 0 ;
24150 int val2 ;
24151 int ecode2 = 0 ;
24152 int val3 ;
24153 int ecode3 = 0 ;
24154 int val4 ;
24155 int ecode4 = 0 ;
24156 int val5 ;
24157 int ecode5 = 0 ;
24158 PyObject * obj0 = 0 ;
24159 PyObject * obj1 = 0 ;
24160 PyObject * obj2 = 0 ;
24161 PyObject * obj3 = 0 ;
24162 PyObject * obj4 = 0 ;
24163 char * kwnames[] = {
24164 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24165 };
24166
24167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24171 }
24172 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24173 ecode2 = SWIG_AsVal_int(obj1, &val2);
24174 if (!SWIG_IsOK(ecode2)) {
24175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24176 }
24177 arg2 = static_cast< int >(val2);
24178 if (obj2) {
24179 ecode3 = SWIG_AsVal_int(obj2, &val3);
24180 if (!SWIG_IsOK(ecode3)) {
24181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24182 }
24183 arg3 = static_cast< int >(val3);
24184 }
24185 if (obj3) {
24186 ecode4 = SWIG_AsVal_int(obj3, &val4);
24187 if (!SWIG_IsOK(ecode4)) {
24188 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24189 }
24190 arg4 = static_cast< int >(val4);
24191 }
24192 if (obj4) {
24193 ecode5 = SWIG_AsVal_int(obj4, &val5);
24194 if (!SWIG_IsOK(ecode5)) {
24195 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24196 }
24197 arg5 = static_cast< int >(val5);
24198 }
24199 {
24200 PyThreadState* __tstate = wxPyBeginAllowThreads();
24201 {
24202 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24203 result = (wxDateTime *) &_result_ref;
24204 }
24205 wxPyEndAllowThreads(__tstate);
24206 if (PyErr_Occurred()) SWIG_fail;
24207 }
24208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24209 return resultobj;
24210 fail:
24211 return NULL;
24212 }
24213
24214
24215 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24216 PyObject *resultobj = 0;
24217 wxDateTime *arg1 = (wxDateTime *) 0 ;
24218 int arg2 ;
24219 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24220 int arg4 = (int) wxDateTime::Inv_Year ;
24221 int arg5 = (int) 0 ;
24222 int arg6 = (int) 0 ;
24223 int arg7 = (int) 0 ;
24224 int arg8 = (int) 0 ;
24225 wxDateTime *result = 0 ;
24226 void *argp1 = 0 ;
24227 int res1 = 0 ;
24228 int val2 ;
24229 int ecode2 = 0 ;
24230 int val3 ;
24231 int ecode3 = 0 ;
24232 int val4 ;
24233 int ecode4 = 0 ;
24234 int val5 ;
24235 int ecode5 = 0 ;
24236 int val6 ;
24237 int ecode6 = 0 ;
24238 int val7 ;
24239 int ecode7 = 0 ;
24240 int val8 ;
24241 int ecode8 = 0 ;
24242 PyObject * obj0 = 0 ;
24243 PyObject * obj1 = 0 ;
24244 PyObject * obj2 = 0 ;
24245 PyObject * obj3 = 0 ;
24246 PyObject * obj4 = 0 ;
24247 PyObject * obj5 = 0 ;
24248 PyObject * obj6 = 0 ;
24249 PyObject * obj7 = 0 ;
24250 char * kwnames[] = {
24251 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24252 };
24253
24254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24256 if (!SWIG_IsOK(res1)) {
24257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24258 }
24259 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24260 ecode2 = SWIG_AsVal_int(obj1, &val2);
24261 if (!SWIG_IsOK(ecode2)) {
24262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24263 }
24264 arg2 = static_cast< int >(val2);
24265 if (obj2) {
24266 ecode3 = SWIG_AsVal_int(obj2, &val3);
24267 if (!SWIG_IsOK(ecode3)) {
24268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24269 }
24270 arg3 = static_cast< wxDateTime::Month >(val3);
24271 }
24272 if (obj3) {
24273 ecode4 = SWIG_AsVal_int(obj3, &val4);
24274 if (!SWIG_IsOK(ecode4)) {
24275 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24276 }
24277 arg4 = static_cast< int >(val4);
24278 }
24279 if (obj4) {
24280 ecode5 = SWIG_AsVal_int(obj4, &val5);
24281 if (!SWIG_IsOK(ecode5)) {
24282 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24283 }
24284 arg5 = static_cast< int >(val5);
24285 }
24286 if (obj5) {
24287 ecode6 = SWIG_AsVal_int(obj5, &val6);
24288 if (!SWIG_IsOK(ecode6)) {
24289 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24290 }
24291 arg6 = static_cast< int >(val6);
24292 }
24293 if (obj6) {
24294 ecode7 = SWIG_AsVal_int(obj6, &val7);
24295 if (!SWIG_IsOK(ecode7)) {
24296 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24297 }
24298 arg7 = static_cast< int >(val7);
24299 }
24300 if (obj7) {
24301 ecode8 = SWIG_AsVal_int(obj7, &val8);
24302 if (!SWIG_IsOK(ecode8)) {
24303 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24304 }
24305 arg8 = static_cast< int >(val8);
24306 }
24307 {
24308 PyThreadState* __tstate = wxPyBeginAllowThreads();
24309 {
24310 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24311 result = (wxDateTime *) &_result_ref;
24312 }
24313 wxPyEndAllowThreads(__tstate);
24314 if (PyErr_Occurred()) SWIG_fail;
24315 }
24316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24317 return resultobj;
24318 fail:
24319 return NULL;
24320 }
24321
24322
24323 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24324 PyObject *resultobj = 0;
24325 wxDateTime *arg1 = (wxDateTime *) 0 ;
24326 wxDateTime *result = 0 ;
24327 void *argp1 = 0 ;
24328 int res1 = 0 ;
24329 PyObject *swig_obj[1] ;
24330
24331 if (!args) SWIG_fail;
24332 swig_obj[0] = args;
24333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24334 if (!SWIG_IsOK(res1)) {
24335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24336 }
24337 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24338 {
24339 PyThreadState* __tstate = wxPyBeginAllowThreads();
24340 {
24341 wxDateTime &_result_ref = (arg1)->ResetTime();
24342 result = (wxDateTime *) &_result_ref;
24343 }
24344 wxPyEndAllowThreads(__tstate);
24345 if (PyErr_Occurred()) SWIG_fail;
24346 }
24347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24348 return resultobj;
24349 fail:
24350 return NULL;
24351 }
24352
24353
24354 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24355 PyObject *resultobj = 0;
24356 wxDateTime *arg1 = (wxDateTime *) 0 ;
24357 int arg2 ;
24358 wxDateTime *result = 0 ;
24359 void *argp1 = 0 ;
24360 int res1 = 0 ;
24361 int val2 ;
24362 int ecode2 = 0 ;
24363 PyObject * obj0 = 0 ;
24364 PyObject * obj1 = 0 ;
24365 char * kwnames[] = {
24366 (char *) "self",(char *) "year", NULL
24367 };
24368
24369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24371 if (!SWIG_IsOK(res1)) {
24372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24373 }
24374 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24375 ecode2 = SWIG_AsVal_int(obj1, &val2);
24376 if (!SWIG_IsOK(ecode2)) {
24377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24378 }
24379 arg2 = static_cast< int >(val2);
24380 {
24381 PyThreadState* __tstate = wxPyBeginAllowThreads();
24382 {
24383 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24384 result = (wxDateTime *) &_result_ref;
24385 }
24386 wxPyEndAllowThreads(__tstate);
24387 if (PyErr_Occurred()) SWIG_fail;
24388 }
24389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24390 return resultobj;
24391 fail:
24392 return NULL;
24393 }
24394
24395
24396 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24397 PyObject *resultobj = 0;
24398 wxDateTime *arg1 = (wxDateTime *) 0 ;
24399 wxDateTime::Month arg2 ;
24400 wxDateTime *result = 0 ;
24401 void *argp1 = 0 ;
24402 int res1 = 0 ;
24403 int val2 ;
24404 int ecode2 = 0 ;
24405 PyObject * obj0 = 0 ;
24406 PyObject * obj1 = 0 ;
24407 char * kwnames[] = {
24408 (char *) "self",(char *) "month", NULL
24409 };
24410
24411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24413 if (!SWIG_IsOK(res1)) {
24414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24415 }
24416 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24417 ecode2 = SWIG_AsVal_int(obj1, &val2);
24418 if (!SWIG_IsOK(ecode2)) {
24419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24420 }
24421 arg2 = static_cast< wxDateTime::Month >(val2);
24422 {
24423 PyThreadState* __tstate = wxPyBeginAllowThreads();
24424 {
24425 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24426 result = (wxDateTime *) &_result_ref;
24427 }
24428 wxPyEndAllowThreads(__tstate);
24429 if (PyErr_Occurred()) SWIG_fail;
24430 }
24431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24432 return resultobj;
24433 fail:
24434 return NULL;
24435 }
24436
24437
24438 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24439 PyObject *resultobj = 0;
24440 wxDateTime *arg1 = (wxDateTime *) 0 ;
24441 int arg2 ;
24442 wxDateTime *result = 0 ;
24443 void *argp1 = 0 ;
24444 int res1 = 0 ;
24445 int val2 ;
24446 int ecode2 = 0 ;
24447 PyObject * obj0 = 0 ;
24448 PyObject * obj1 = 0 ;
24449 char * kwnames[] = {
24450 (char *) "self",(char *) "day", NULL
24451 };
24452
24453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24455 if (!SWIG_IsOK(res1)) {
24456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24457 }
24458 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24459 ecode2 = SWIG_AsVal_int(obj1, &val2);
24460 if (!SWIG_IsOK(ecode2)) {
24461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24462 }
24463 arg2 = static_cast< int >(val2);
24464 {
24465 PyThreadState* __tstate = wxPyBeginAllowThreads();
24466 {
24467 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24468 result = (wxDateTime *) &_result_ref;
24469 }
24470 wxPyEndAllowThreads(__tstate);
24471 if (PyErr_Occurred()) SWIG_fail;
24472 }
24473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24474 return resultobj;
24475 fail:
24476 return NULL;
24477 }
24478
24479
24480 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24481 PyObject *resultobj = 0;
24482 wxDateTime *arg1 = (wxDateTime *) 0 ;
24483 int arg2 ;
24484 wxDateTime *result = 0 ;
24485 void *argp1 = 0 ;
24486 int res1 = 0 ;
24487 int val2 ;
24488 int ecode2 = 0 ;
24489 PyObject * obj0 = 0 ;
24490 PyObject * obj1 = 0 ;
24491 char * kwnames[] = {
24492 (char *) "self",(char *) "hour", NULL
24493 };
24494
24495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24497 if (!SWIG_IsOK(res1)) {
24498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24499 }
24500 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24501 ecode2 = SWIG_AsVal_int(obj1, &val2);
24502 if (!SWIG_IsOK(ecode2)) {
24503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24504 }
24505 arg2 = static_cast< int >(val2);
24506 {
24507 PyThreadState* __tstate = wxPyBeginAllowThreads();
24508 {
24509 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24510 result = (wxDateTime *) &_result_ref;
24511 }
24512 wxPyEndAllowThreads(__tstate);
24513 if (PyErr_Occurred()) SWIG_fail;
24514 }
24515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24516 return resultobj;
24517 fail:
24518 return NULL;
24519 }
24520
24521
24522 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24523 PyObject *resultobj = 0;
24524 wxDateTime *arg1 = (wxDateTime *) 0 ;
24525 int arg2 ;
24526 wxDateTime *result = 0 ;
24527 void *argp1 = 0 ;
24528 int res1 = 0 ;
24529 int val2 ;
24530 int ecode2 = 0 ;
24531 PyObject * obj0 = 0 ;
24532 PyObject * obj1 = 0 ;
24533 char * kwnames[] = {
24534 (char *) "self",(char *) "minute", NULL
24535 };
24536
24537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24539 if (!SWIG_IsOK(res1)) {
24540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24541 }
24542 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24543 ecode2 = SWIG_AsVal_int(obj1, &val2);
24544 if (!SWIG_IsOK(ecode2)) {
24545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24546 }
24547 arg2 = static_cast< int >(val2);
24548 {
24549 PyThreadState* __tstate = wxPyBeginAllowThreads();
24550 {
24551 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24552 result = (wxDateTime *) &_result_ref;
24553 }
24554 wxPyEndAllowThreads(__tstate);
24555 if (PyErr_Occurred()) SWIG_fail;
24556 }
24557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24558 return resultobj;
24559 fail:
24560 return NULL;
24561 }
24562
24563
24564 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24565 PyObject *resultobj = 0;
24566 wxDateTime *arg1 = (wxDateTime *) 0 ;
24567 int arg2 ;
24568 wxDateTime *result = 0 ;
24569 void *argp1 = 0 ;
24570 int res1 = 0 ;
24571 int val2 ;
24572 int ecode2 = 0 ;
24573 PyObject * obj0 = 0 ;
24574 PyObject * obj1 = 0 ;
24575 char * kwnames[] = {
24576 (char *) "self",(char *) "second", NULL
24577 };
24578
24579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24581 if (!SWIG_IsOK(res1)) {
24582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24583 }
24584 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24585 ecode2 = SWIG_AsVal_int(obj1, &val2);
24586 if (!SWIG_IsOK(ecode2)) {
24587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24588 }
24589 arg2 = static_cast< int >(val2);
24590 {
24591 PyThreadState* __tstate = wxPyBeginAllowThreads();
24592 {
24593 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24594 result = (wxDateTime *) &_result_ref;
24595 }
24596 wxPyEndAllowThreads(__tstate);
24597 if (PyErr_Occurred()) SWIG_fail;
24598 }
24599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24600 return resultobj;
24601 fail:
24602 return NULL;
24603 }
24604
24605
24606 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24607 PyObject *resultobj = 0;
24608 wxDateTime *arg1 = (wxDateTime *) 0 ;
24609 int arg2 ;
24610 wxDateTime *result = 0 ;
24611 void *argp1 = 0 ;
24612 int res1 = 0 ;
24613 int val2 ;
24614 int ecode2 = 0 ;
24615 PyObject * obj0 = 0 ;
24616 PyObject * obj1 = 0 ;
24617 char * kwnames[] = {
24618 (char *) "self",(char *) "millisecond", NULL
24619 };
24620
24621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24623 if (!SWIG_IsOK(res1)) {
24624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24625 }
24626 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24627 ecode2 = SWIG_AsVal_int(obj1, &val2);
24628 if (!SWIG_IsOK(ecode2)) {
24629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24630 }
24631 arg2 = static_cast< int >(val2);
24632 {
24633 PyThreadState* __tstate = wxPyBeginAllowThreads();
24634 {
24635 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24636 result = (wxDateTime *) &_result_ref;
24637 }
24638 wxPyEndAllowThreads(__tstate);
24639 if (PyErr_Occurred()) SWIG_fail;
24640 }
24641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24642 return resultobj;
24643 fail:
24644 return NULL;
24645 }
24646
24647
24648 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24649 PyObject *resultobj = 0;
24650 wxDateTime *arg1 = (wxDateTime *) 0 ;
24651 wxDateTime::WeekDay arg2 ;
24652 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24653 wxDateTime *result = 0 ;
24654 void *argp1 = 0 ;
24655 int res1 = 0 ;
24656 int val2 ;
24657 int ecode2 = 0 ;
24658 int val3 ;
24659 int ecode3 = 0 ;
24660 PyObject * obj0 = 0 ;
24661 PyObject * obj1 = 0 ;
24662 PyObject * obj2 = 0 ;
24663 char * kwnames[] = {
24664 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24665 };
24666
24667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24669 if (!SWIG_IsOK(res1)) {
24670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24671 }
24672 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24673 ecode2 = SWIG_AsVal_int(obj1, &val2);
24674 if (!SWIG_IsOK(ecode2)) {
24675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24676 }
24677 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24678 if (obj2) {
24679 ecode3 = SWIG_AsVal_int(obj2, &val3);
24680 if (!SWIG_IsOK(ecode3)) {
24681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24682 }
24683 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24684 }
24685 {
24686 PyThreadState* __tstate = wxPyBeginAllowThreads();
24687 {
24688 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24689 result = (wxDateTime *) &_result_ref;
24690 }
24691 wxPyEndAllowThreads(__tstate);
24692 if (PyErr_Occurred()) SWIG_fail;
24693 }
24694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24695 return resultobj;
24696 fail:
24697 return NULL;
24698 }
24699
24700
24701 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24702 PyObject *resultobj = 0;
24703 wxDateTime *arg1 = (wxDateTime *) 0 ;
24704 wxDateTime::WeekDay arg2 ;
24705 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24706 wxDateTime result;
24707 void *argp1 = 0 ;
24708 int res1 = 0 ;
24709 int val2 ;
24710 int ecode2 = 0 ;
24711 int val3 ;
24712 int ecode3 = 0 ;
24713 PyObject * obj0 = 0 ;
24714 PyObject * obj1 = 0 ;
24715 PyObject * obj2 = 0 ;
24716 char * kwnames[] = {
24717 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24718 };
24719
24720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24722 if (!SWIG_IsOK(res1)) {
24723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24724 }
24725 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24726 ecode2 = SWIG_AsVal_int(obj1, &val2);
24727 if (!SWIG_IsOK(ecode2)) {
24728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24729 }
24730 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24731 if (obj2) {
24732 ecode3 = SWIG_AsVal_int(obj2, &val3);
24733 if (!SWIG_IsOK(ecode3)) {
24734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24735 }
24736 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24737 }
24738 {
24739 PyThreadState* __tstate = wxPyBeginAllowThreads();
24740 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24741 wxPyEndAllowThreads(__tstate);
24742 if (PyErr_Occurred()) SWIG_fail;
24743 }
24744 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24745 return resultobj;
24746 fail:
24747 return NULL;
24748 }
24749
24750
24751 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24752 PyObject *resultobj = 0;
24753 wxDateTime *arg1 = (wxDateTime *) 0 ;
24754 wxDateTime::WeekDay arg2 ;
24755 wxDateTime *result = 0 ;
24756 void *argp1 = 0 ;
24757 int res1 = 0 ;
24758 int val2 ;
24759 int ecode2 = 0 ;
24760 PyObject * obj0 = 0 ;
24761 PyObject * obj1 = 0 ;
24762 char * kwnames[] = {
24763 (char *) "self",(char *) "weekday", NULL
24764 };
24765
24766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24768 if (!SWIG_IsOK(res1)) {
24769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24770 }
24771 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24772 ecode2 = SWIG_AsVal_int(obj1, &val2);
24773 if (!SWIG_IsOK(ecode2)) {
24774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24775 }
24776 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24777 {
24778 PyThreadState* __tstate = wxPyBeginAllowThreads();
24779 {
24780 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24781 result = (wxDateTime *) &_result_ref;
24782 }
24783 wxPyEndAllowThreads(__tstate);
24784 if (PyErr_Occurred()) SWIG_fail;
24785 }
24786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24787 return resultobj;
24788 fail:
24789 return NULL;
24790 }
24791
24792
24793 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24794 PyObject *resultobj = 0;
24795 wxDateTime *arg1 = (wxDateTime *) 0 ;
24796 wxDateTime::WeekDay arg2 ;
24797 wxDateTime result;
24798 void *argp1 = 0 ;
24799 int res1 = 0 ;
24800 int val2 ;
24801 int ecode2 = 0 ;
24802 PyObject * obj0 = 0 ;
24803 PyObject * obj1 = 0 ;
24804 char * kwnames[] = {
24805 (char *) "self",(char *) "weekday", NULL
24806 };
24807
24808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24810 if (!SWIG_IsOK(res1)) {
24811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24812 }
24813 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24814 ecode2 = SWIG_AsVal_int(obj1, &val2);
24815 if (!SWIG_IsOK(ecode2)) {
24816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24817 }
24818 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24819 {
24820 PyThreadState* __tstate = wxPyBeginAllowThreads();
24821 result = (arg1)->GetNextWeekDay(arg2);
24822 wxPyEndAllowThreads(__tstate);
24823 if (PyErr_Occurred()) SWIG_fail;
24824 }
24825 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24826 return resultobj;
24827 fail:
24828 return NULL;
24829 }
24830
24831
24832 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24833 PyObject *resultobj = 0;
24834 wxDateTime *arg1 = (wxDateTime *) 0 ;
24835 wxDateTime::WeekDay arg2 ;
24836 wxDateTime *result = 0 ;
24837 void *argp1 = 0 ;
24838 int res1 = 0 ;
24839 int val2 ;
24840 int ecode2 = 0 ;
24841 PyObject * obj0 = 0 ;
24842 PyObject * obj1 = 0 ;
24843 char * kwnames[] = {
24844 (char *) "self",(char *) "weekday", NULL
24845 };
24846
24847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24849 if (!SWIG_IsOK(res1)) {
24850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24851 }
24852 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24853 ecode2 = SWIG_AsVal_int(obj1, &val2);
24854 if (!SWIG_IsOK(ecode2)) {
24855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24856 }
24857 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24858 {
24859 PyThreadState* __tstate = wxPyBeginAllowThreads();
24860 {
24861 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24862 result = (wxDateTime *) &_result_ref;
24863 }
24864 wxPyEndAllowThreads(__tstate);
24865 if (PyErr_Occurred()) SWIG_fail;
24866 }
24867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24868 return resultobj;
24869 fail:
24870 return NULL;
24871 }
24872
24873
24874 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24875 PyObject *resultobj = 0;
24876 wxDateTime *arg1 = (wxDateTime *) 0 ;
24877 wxDateTime::WeekDay arg2 ;
24878 wxDateTime result;
24879 void *argp1 = 0 ;
24880 int res1 = 0 ;
24881 int val2 ;
24882 int ecode2 = 0 ;
24883 PyObject * obj0 = 0 ;
24884 PyObject * obj1 = 0 ;
24885 char * kwnames[] = {
24886 (char *) "self",(char *) "weekday", NULL
24887 };
24888
24889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24891 if (!SWIG_IsOK(res1)) {
24892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24893 }
24894 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24895 ecode2 = SWIG_AsVal_int(obj1, &val2);
24896 if (!SWIG_IsOK(ecode2)) {
24897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24898 }
24899 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24900 {
24901 PyThreadState* __tstate = wxPyBeginAllowThreads();
24902 result = (arg1)->GetPrevWeekDay(arg2);
24903 wxPyEndAllowThreads(__tstate);
24904 if (PyErr_Occurred()) SWIG_fail;
24905 }
24906 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24907 return resultobj;
24908 fail:
24909 return NULL;
24910 }
24911
24912
24913 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24914 PyObject *resultobj = 0;
24915 wxDateTime *arg1 = (wxDateTime *) 0 ;
24916 wxDateTime::WeekDay arg2 ;
24917 int arg3 = (int) 1 ;
24918 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24919 int arg5 = (int) wxDateTime::Inv_Year ;
24920 bool result;
24921 void *argp1 = 0 ;
24922 int res1 = 0 ;
24923 int val2 ;
24924 int ecode2 = 0 ;
24925 int val3 ;
24926 int ecode3 = 0 ;
24927 int val4 ;
24928 int ecode4 = 0 ;
24929 int val5 ;
24930 int ecode5 = 0 ;
24931 PyObject * obj0 = 0 ;
24932 PyObject * obj1 = 0 ;
24933 PyObject * obj2 = 0 ;
24934 PyObject * obj3 = 0 ;
24935 PyObject * obj4 = 0 ;
24936 char * kwnames[] = {
24937 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
24938 };
24939
24940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24942 if (!SWIG_IsOK(res1)) {
24943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24944 }
24945 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24946 ecode2 = SWIG_AsVal_int(obj1, &val2);
24947 if (!SWIG_IsOK(ecode2)) {
24948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24949 }
24950 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24951 if (obj2) {
24952 ecode3 = SWIG_AsVal_int(obj2, &val3);
24953 if (!SWIG_IsOK(ecode3)) {
24954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
24955 }
24956 arg3 = static_cast< int >(val3);
24957 }
24958 if (obj3) {
24959 ecode4 = SWIG_AsVal_int(obj3, &val4);
24960 if (!SWIG_IsOK(ecode4)) {
24961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
24962 }
24963 arg4 = static_cast< wxDateTime::Month >(val4);
24964 }
24965 if (obj4) {
24966 ecode5 = SWIG_AsVal_int(obj4, &val5);
24967 if (!SWIG_IsOK(ecode5)) {
24968 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
24969 }
24970 arg5 = static_cast< int >(val5);
24971 }
24972 {
24973 PyThreadState* __tstate = wxPyBeginAllowThreads();
24974 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
24975 wxPyEndAllowThreads(__tstate);
24976 if (PyErr_Occurred()) SWIG_fail;
24977 }
24978 {
24979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24980 }
24981 return resultobj;
24982 fail:
24983 return NULL;
24984 }
24985
24986
24987 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24988 PyObject *resultobj = 0;
24989 wxDateTime *arg1 = (wxDateTime *) 0 ;
24990 wxDateTime::WeekDay arg2 ;
24991 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24992 int arg4 = (int) wxDateTime::Inv_Year ;
24993 bool result;
24994 void *argp1 = 0 ;
24995 int res1 = 0 ;
24996 int val2 ;
24997 int ecode2 = 0 ;
24998 int val3 ;
24999 int ecode3 = 0 ;
25000 int val4 ;
25001 int ecode4 = 0 ;
25002 PyObject * obj0 = 0 ;
25003 PyObject * obj1 = 0 ;
25004 PyObject * obj2 = 0 ;
25005 PyObject * obj3 = 0 ;
25006 char * kwnames[] = {
25007 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25008 };
25009
25010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25012 if (!SWIG_IsOK(res1)) {
25013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25014 }
25015 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25016 ecode2 = SWIG_AsVal_int(obj1, &val2);
25017 if (!SWIG_IsOK(ecode2)) {
25018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25019 }
25020 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25021 if (obj2) {
25022 ecode3 = SWIG_AsVal_int(obj2, &val3);
25023 if (!SWIG_IsOK(ecode3)) {
25024 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25025 }
25026 arg3 = static_cast< wxDateTime::Month >(val3);
25027 }
25028 if (obj3) {
25029 ecode4 = SWIG_AsVal_int(obj3, &val4);
25030 if (!SWIG_IsOK(ecode4)) {
25031 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25032 }
25033 arg4 = static_cast< int >(val4);
25034 }
25035 {
25036 PyThreadState* __tstate = wxPyBeginAllowThreads();
25037 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25038 wxPyEndAllowThreads(__tstate);
25039 if (PyErr_Occurred()) SWIG_fail;
25040 }
25041 {
25042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25043 }
25044 return resultobj;
25045 fail:
25046 return NULL;
25047 }
25048
25049
25050 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25051 PyObject *resultobj = 0;
25052 wxDateTime *arg1 = (wxDateTime *) 0 ;
25053 wxDateTime::WeekDay arg2 ;
25054 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25055 int arg4 = (int) wxDateTime::Inv_Year ;
25056 wxDateTime result;
25057 void *argp1 = 0 ;
25058 int res1 = 0 ;
25059 int val2 ;
25060 int ecode2 = 0 ;
25061 int val3 ;
25062 int ecode3 = 0 ;
25063 int val4 ;
25064 int ecode4 = 0 ;
25065 PyObject * obj0 = 0 ;
25066 PyObject * obj1 = 0 ;
25067 PyObject * obj2 = 0 ;
25068 PyObject * obj3 = 0 ;
25069 char * kwnames[] = {
25070 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25071 };
25072
25073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25075 if (!SWIG_IsOK(res1)) {
25076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25077 }
25078 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25079 ecode2 = SWIG_AsVal_int(obj1, &val2);
25080 if (!SWIG_IsOK(ecode2)) {
25081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25082 }
25083 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25084 if (obj2) {
25085 ecode3 = SWIG_AsVal_int(obj2, &val3);
25086 if (!SWIG_IsOK(ecode3)) {
25087 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25088 }
25089 arg3 = static_cast< wxDateTime::Month >(val3);
25090 }
25091 if (obj3) {
25092 ecode4 = SWIG_AsVal_int(obj3, &val4);
25093 if (!SWIG_IsOK(ecode4)) {
25094 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25095 }
25096 arg4 = static_cast< int >(val4);
25097 }
25098 {
25099 PyThreadState* __tstate = wxPyBeginAllowThreads();
25100 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25101 wxPyEndAllowThreads(__tstate);
25102 if (PyErr_Occurred()) SWIG_fail;
25103 }
25104 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25105 return resultobj;
25106 fail:
25107 return NULL;
25108 }
25109
25110
25111 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25112 PyObject *resultobj = 0;
25113 wxDateTime *arg1 = (wxDateTime *) 0 ;
25114 int arg2 ;
25115 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25116 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25117 bool result;
25118 void *argp1 = 0 ;
25119 int res1 = 0 ;
25120 int val2 ;
25121 int ecode2 = 0 ;
25122 int val3 ;
25123 int ecode3 = 0 ;
25124 int val4 ;
25125 int ecode4 = 0 ;
25126 PyObject * obj0 = 0 ;
25127 PyObject * obj1 = 0 ;
25128 PyObject * obj2 = 0 ;
25129 PyObject * obj3 = 0 ;
25130 char * kwnames[] = {
25131 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25132 };
25133
25134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25136 if (!SWIG_IsOK(res1)) {
25137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25138 }
25139 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25140 ecode2 = SWIG_AsVal_int(obj1, &val2);
25141 if (!SWIG_IsOK(ecode2)) {
25142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25143 }
25144 arg2 = static_cast< int >(val2);
25145 if (obj2) {
25146 ecode3 = SWIG_AsVal_int(obj2, &val3);
25147 if (!SWIG_IsOK(ecode3)) {
25148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25149 }
25150 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25151 }
25152 if (obj3) {
25153 ecode4 = SWIG_AsVal_int(obj3, &val4);
25154 if (!SWIG_IsOK(ecode4)) {
25155 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25156 }
25157 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25158 }
25159 {
25160 PyThreadState* __tstate = wxPyBeginAllowThreads();
25161 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25162 wxPyEndAllowThreads(__tstate);
25163 if (PyErr_Occurred()) SWIG_fail;
25164 }
25165 {
25166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25167 }
25168 return resultobj;
25169 fail:
25170 return NULL;
25171 }
25172
25173
25174 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25175 PyObject *resultobj = 0;
25176 wxDateTime *arg1 = (wxDateTime *) 0 ;
25177 int arg2 ;
25178 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25179 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25180 wxDateTime result;
25181 void *argp1 = 0 ;
25182 int res1 = 0 ;
25183 int val2 ;
25184 int ecode2 = 0 ;
25185 int val3 ;
25186 int ecode3 = 0 ;
25187 int val4 ;
25188 int ecode4 = 0 ;
25189 PyObject * obj0 = 0 ;
25190 PyObject * obj1 = 0 ;
25191 PyObject * obj2 = 0 ;
25192 PyObject * obj3 = 0 ;
25193 char * kwnames[] = {
25194 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25195 };
25196
25197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25199 if (!SWIG_IsOK(res1)) {
25200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25201 }
25202 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25203 ecode2 = SWIG_AsVal_int(obj1, &val2);
25204 if (!SWIG_IsOK(ecode2)) {
25205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25206 }
25207 arg2 = static_cast< int >(val2);
25208 if (obj2) {
25209 ecode3 = SWIG_AsVal_int(obj2, &val3);
25210 if (!SWIG_IsOK(ecode3)) {
25211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25212 }
25213 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25214 }
25215 if (obj3) {
25216 ecode4 = SWIG_AsVal_int(obj3, &val4);
25217 if (!SWIG_IsOK(ecode4)) {
25218 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25219 }
25220 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25221 }
25222 {
25223 PyThreadState* __tstate = wxPyBeginAllowThreads();
25224 result = (arg1)->GetWeek(arg2,arg3,arg4);
25225 wxPyEndAllowThreads(__tstate);
25226 if (PyErr_Occurred()) SWIG_fail;
25227 }
25228 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25229 return resultobj;
25230 fail:
25231 return NULL;
25232 }
25233
25234
25235 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25236 PyObject *resultobj = 0;
25237 int arg1 ;
25238 int arg2 ;
25239 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25240 wxDateTime result;
25241 int val1 ;
25242 int ecode1 = 0 ;
25243 int val2 ;
25244 int ecode2 = 0 ;
25245 int val3 ;
25246 int ecode3 = 0 ;
25247 PyObject * obj0 = 0 ;
25248 PyObject * obj1 = 0 ;
25249 PyObject * obj2 = 0 ;
25250 char * kwnames[] = {
25251 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25252 };
25253
25254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25255 ecode1 = SWIG_AsVal_int(obj0, &val1);
25256 if (!SWIG_IsOK(ecode1)) {
25257 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25258 }
25259 arg1 = static_cast< int >(val1);
25260 ecode2 = SWIG_AsVal_int(obj1, &val2);
25261 if (!SWIG_IsOK(ecode2)) {
25262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25263 }
25264 arg2 = static_cast< int >(val2);
25265 if (obj2) {
25266 ecode3 = SWIG_AsVal_int(obj2, &val3);
25267 if (!SWIG_IsOK(ecode3)) {
25268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25269 }
25270 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25271 }
25272 {
25273 PyThreadState* __tstate = wxPyBeginAllowThreads();
25274 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25275 wxPyEndAllowThreads(__tstate);
25276 if (PyErr_Occurred()) SWIG_fail;
25277 }
25278 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25279 return resultobj;
25280 fail:
25281 return NULL;
25282 }
25283
25284
25285 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25286 PyObject *resultobj = 0;
25287 wxDateTime *arg1 = (wxDateTime *) 0 ;
25288 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25289 int arg3 = (int) wxDateTime::Inv_Year ;
25290 wxDateTime *result = 0 ;
25291 void *argp1 = 0 ;
25292 int res1 = 0 ;
25293 int val2 ;
25294 int ecode2 = 0 ;
25295 int val3 ;
25296 int ecode3 = 0 ;
25297 PyObject * obj0 = 0 ;
25298 PyObject * obj1 = 0 ;
25299 PyObject * obj2 = 0 ;
25300 char * kwnames[] = {
25301 (char *) "self",(char *) "month",(char *) "year", NULL
25302 };
25303
25304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25306 if (!SWIG_IsOK(res1)) {
25307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25308 }
25309 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25310 if (obj1) {
25311 ecode2 = SWIG_AsVal_int(obj1, &val2);
25312 if (!SWIG_IsOK(ecode2)) {
25313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25314 }
25315 arg2 = static_cast< wxDateTime::Month >(val2);
25316 }
25317 if (obj2) {
25318 ecode3 = SWIG_AsVal_int(obj2, &val3);
25319 if (!SWIG_IsOK(ecode3)) {
25320 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25321 }
25322 arg3 = static_cast< int >(val3);
25323 }
25324 {
25325 PyThreadState* __tstate = wxPyBeginAllowThreads();
25326 {
25327 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25328 result = (wxDateTime *) &_result_ref;
25329 }
25330 wxPyEndAllowThreads(__tstate);
25331 if (PyErr_Occurred()) SWIG_fail;
25332 }
25333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25334 return resultobj;
25335 fail:
25336 return NULL;
25337 }
25338
25339
25340 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25341 PyObject *resultobj = 0;
25342 wxDateTime *arg1 = (wxDateTime *) 0 ;
25343 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25344 int arg3 = (int) wxDateTime::Inv_Year ;
25345 wxDateTime result;
25346 void *argp1 = 0 ;
25347 int res1 = 0 ;
25348 int val2 ;
25349 int ecode2 = 0 ;
25350 int val3 ;
25351 int ecode3 = 0 ;
25352 PyObject * obj0 = 0 ;
25353 PyObject * obj1 = 0 ;
25354 PyObject * obj2 = 0 ;
25355 char * kwnames[] = {
25356 (char *) "self",(char *) "month",(char *) "year", NULL
25357 };
25358
25359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25361 if (!SWIG_IsOK(res1)) {
25362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25363 }
25364 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25365 if (obj1) {
25366 ecode2 = SWIG_AsVal_int(obj1, &val2);
25367 if (!SWIG_IsOK(ecode2)) {
25368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25369 }
25370 arg2 = static_cast< wxDateTime::Month >(val2);
25371 }
25372 if (obj2) {
25373 ecode3 = SWIG_AsVal_int(obj2, &val3);
25374 if (!SWIG_IsOK(ecode3)) {
25375 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25376 }
25377 arg3 = static_cast< int >(val3);
25378 }
25379 {
25380 PyThreadState* __tstate = wxPyBeginAllowThreads();
25381 result = (arg1)->GetLastMonthDay(arg2,arg3);
25382 wxPyEndAllowThreads(__tstate);
25383 if (PyErr_Occurred()) SWIG_fail;
25384 }
25385 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25386 return resultobj;
25387 fail:
25388 return NULL;
25389 }
25390
25391
25392 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25393 PyObject *resultobj = 0;
25394 wxDateTime *arg1 = (wxDateTime *) 0 ;
25395 int arg2 ;
25396 wxDateTime *result = 0 ;
25397 void *argp1 = 0 ;
25398 int res1 = 0 ;
25399 int val2 ;
25400 int ecode2 = 0 ;
25401 PyObject * obj0 = 0 ;
25402 PyObject * obj1 = 0 ;
25403 char * kwnames[] = {
25404 (char *) "self",(char *) "yday", NULL
25405 };
25406
25407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25409 if (!SWIG_IsOK(res1)) {
25410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25411 }
25412 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25413 ecode2 = SWIG_AsVal_int(obj1, &val2);
25414 if (!SWIG_IsOK(ecode2)) {
25415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25416 }
25417 arg2 = static_cast< int >(val2);
25418 {
25419 PyThreadState* __tstate = wxPyBeginAllowThreads();
25420 {
25421 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25422 result = (wxDateTime *) &_result_ref;
25423 }
25424 wxPyEndAllowThreads(__tstate);
25425 if (PyErr_Occurred()) SWIG_fail;
25426 }
25427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25428 return resultobj;
25429 fail:
25430 return NULL;
25431 }
25432
25433
25434 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25435 PyObject *resultobj = 0;
25436 wxDateTime *arg1 = (wxDateTime *) 0 ;
25437 int arg2 ;
25438 wxDateTime result;
25439 void *argp1 = 0 ;
25440 int res1 = 0 ;
25441 int val2 ;
25442 int ecode2 = 0 ;
25443 PyObject * obj0 = 0 ;
25444 PyObject * obj1 = 0 ;
25445 char * kwnames[] = {
25446 (char *) "self",(char *) "yday", NULL
25447 };
25448
25449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25451 if (!SWIG_IsOK(res1)) {
25452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25453 }
25454 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25455 ecode2 = SWIG_AsVal_int(obj1, &val2);
25456 if (!SWIG_IsOK(ecode2)) {
25457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25458 }
25459 arg2 = static_cast< int >(val2);
25460 {
25461 PyThreadState* __tstate = wxPyBeginAllowThreads();
25462 result = (arg1)->GetYearDay(arg2);
25463 wxPyEndAllowThreads(__tstate);
25464 if (PyErr_Occurred()) SWIG_fail;
25465 }
25466 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25467 return resultobj;
25468 fail:
25469 return NULL;
25470 }
25471
25472
25473 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25474 PyObject *resultobj = 0;
25475 wxDateTime *arg1 = (wxDateTime *) 0 ;
25476 double result;
25477 void *argp1 = 0 ;
25478 int res1 = 0 ;
25479 PyObject *swig_obj[1] ;
25480
25481 if (!args) SWIG_fail;
25482 swig_obj[0] = args;
25483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25484 if (!SWIG_IsOK(res1)) {
25485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25486 }
25487 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25488 {
25489 PyThreadState* __tstate = wxPyBeginAllowThreads();
25490 result = (double)(arg1)->GetJulianDayNumber();
25491 wxPyEndAllowThreads(__tstate);
25492 if (PyErr_Occurred()) SWIG_fail;
25493 }
25494 resultobj = SWIG_From_double(static_cast< double >(result));
25495 return resultobj;
25496 fail:
25497 return NULL;
25498 }
25499
25500
25501 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25502 PyObject *resultobj = 0;
25503 wxDateTime *arg1 = (wxDateTime *) 0 ;
25504 double result;
25505 void *argp1 = 0 ;
25506 int res1 = 0 ;
25507 PyObject *swig_obj[1] ;
25508
25509 if (!args) SWIG_fail;
25510 swig_obj[0] = args;
25511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25512 if (!SWIG_IsOK(res1)) {
25513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25514 }
25515 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25516 {
25517 PyThreadState* __tstate = wxPyBeginAllowThreads();
25518 result = (double)(arg1)->GetJDN();
25519 wxPyEndAllowThreads(__tstate);
25520 if (PyErr_Occurred()) SWIG_fail;
25521 }
25522 resultobj = SWIG_From_double(static_cast< double >(result));
25523 return resultobj;
25524 fail:
25525 return NULL;
25526 }
25527
25528
25529 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25530 PyObject *resultobj = 0;
25531 wxDateTime *arg1 = (wxDateTime *) 0 ;
25532 double result;
25533 void *argp1 = 0 ;
25534 int res1 = 0 ;
25535 PyObject *swig_obj[1] ;
25536
25537 if (!args) SWIG_fail;
25538 swig_obj[0] = args;
25539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25540 if (!SWIG_IsOK(res1)) {
25541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25542 }
25543 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25544 {
25545 PyThreadState* __tstate = wxPyBeginAllowThreads();
25546 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25547 wxPyEndAllowThreads(__tstate);
25548 if (PyErr_Occurred()) SWIG_fail;
25549 }
25550 resultobj = SWIG_From_double(static_cast< double >(result));
25551 return resultobj;
25552 fail:
25553 return NULL;
25554 }
25555
25556
25557 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25558 PyObject *resultobj = 0;
25559 wxDateTime *arg1 = (wxDateTime *) 0 ;
25560 double result;
25561 void *argp1 = 0 ;
25562 int res1 = 0 ;
25563 PyObject *swig_obj[1] ;
25564
25565 if (!args) SWIG_fail;
25566 swig_obj[0] = args;
25567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25568 if (!SWIG_IsOK(res1)) {
25569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25570 }
25571 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25572 {
25573 PyThreadState* __tstate = wxPyBeginAllowThreads();
25574 result = (double)(arg1)->GetMJD();
25575 wxPyEndAllowThreads(__tstate);
25576 if (PyErr_Occurred()) SWIG_fail;
25577 }
25578 resultobj = SWIG_From_double(static_cast< double >(result));
25579 return resultobj;
25580 fail:
25581 return NULL;
25582 }
25583
25584
25585 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25586 PyObject *resultobj = 0;
25587 wxDateTime *arg1 = (wxDateTime *) 0 ;
25588 double result;
25589 void *argp1 = 0 ;
25590 int res1 = 0 ;
25591 PyObject *swig_obj[1] ;
25592
25593 if (!args) SWIG_fail;
25594 swig_obj[0] = args;
25595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25596 if (!SWIG_IsOK(res1)) {
25597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25598 }
25599 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25600 {
25601 PyThreadState* __tstate = wxPyBeginAllowThreads();
25602 result = (double)(arg1)->GetRataDie();
25603 wxPyEndAllowThreads(__tstate);
25604 if (PyErr_Occurred()) SWIG_fail;
25605 }
25606 resultobj = SWIG_From_double(static_cast< double >(result));
25607 return resultobj;
25608 fail:
25609 return NULL;
25610 }
25611
25612
25613 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25614 PyObject *resultobj = 0;
25615 wxDateTime *arg1 = (wxDateTime *) 0 ;
25616 wxDateTime::TimeZone *arg2 = 0 ;
25617 bool arg3 = (bool) false ;
25618 wxDateTime result;
25619 void *argp1 = 0 ;
25620 int res1 = 0 ;
25621 bool temp2 = false ;
25622 bool val3 ;
25623 int ecode3 = 0 ;
25624 PyObject * obj0 = 0 ;
25625 PyObject * obj1 = 0 ;
25626 PyObject * obj2 = 0 ;
25627 char * kwnames[] = {
25628 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25629 };
25630
25631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25633 if (!SWIG_IsOK(res1)) {
25634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25635 }
25636 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25637 {
25638 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25639 temp2 = true;
25640 }
25641 if (obj2) {
25642 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25643 if (!SWIG_IsOK(ecode3)) {
25644 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25645 }
25646 arg3 = static_cast< bool >(val3);
25647 }
25648 {
25649 PyThreadState* __tstate = wxPyBeginAllowThreads();
25650 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25651 wxPyEndAllowThreads(__tstate);
25652 if (PyErr_Occurred()) SWIG_fail;
25653 }
25654 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25655 {
25656 if (temp2) delete arg2;
25657 }
25658 return resultobj;
25659 fail:
25660 {
25661 if (temp2) delete arg2;
25662 }
25663 return NULL;
25664 }
25665
25666
25667 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25668 PyObject *resultobj = 0;
25669 wxDateTime *arg1 = (wxDateTime *) 0 ;
25670 wxDateTime::TimeZone *arg2 = 0 ;
25671 bool arg3 = (bool) false ;
25672 wxDateTime *result = 0 ;
25673 void *argp1 = 0 ;
25674 int res1 = 0 ;
25675 bool temp2 = false ;
25676 bool val3 ;
25677 int ecode3 = 0 ;
25678 PyObject * obj0 = 0 ;
25679 PyObject * obj1 = 0 ;
25680 PyObject * obj2 = 0 ;
25681 char * kwnames[] = {
25682 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25683 };
25684
25685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25687 if (!SWIG_IsOK(res1)) {
25688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25689 }
25690 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25691 {
25692 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25693 temp2 = true;
25694 }
25695 if (obj2) {
25696 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25697 if (!SWIG_IsOK(ecode3)) {
25698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25699 }
25700 arg3 = static_cast< bool >(val3);
25701 }
25702 {
25703 PyThreadState* __tstate = wxPyBeginAllowThreads();
25704 {
25705 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25706 result = (wxDateTime *) &_result_ref;
25707 }
25708 wxPyEndAllowThreads(__tstate);
25709 if (PyErr_Occurred()) SWIG_fail;
25710 }
25711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25712 {
25713 if (temp2) delete arg2;
25714 }
25715 return resultobj;
25716 fail:
25717 {
25718 if (temp2) delete arg2;
25719 }
25720 return NULL;
25721 }
25722
25723
25724 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25725 PyObject *resultobj = 0;
25726 wxDateTime *arg1 = (wxDateTime *) 0 ;
25727 wxDateTime::TimeZone *arg2 = 0 ;
25728 bool arg3 = (bool) false ;
25729 wxDateTime result;
25730 void *argp1 = 0 ;
25731 int res1 = 0 ;
25732 bool temp2 = false ;
25733 bool val3 ;
25734 int ecode3 = 0 ;
25735 PyObject * obj0 = 0 ;
25736 PyObject * obj1 = 0 ;
25737 PyObject * obj2 = 0 ;
25738 char * kwnames[] = {
25739 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25740 };
25741
25742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25744 if (!SWIG_IsOK(res1)) {
25745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25746 }
25747 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25748 {
25749 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25750 temp2 = true;
25751 }
25752 if (obj2) {
25753 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25754 if (!SWIG_IsOK(ecode3)) {
25755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25756 }
25757 arg3 = static_cast< bool >(val3);
25758 }
25759 {
25760 PyThreadState* __tstate = wxPyBeginAllowThreads();
25761 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25762 wxPyEndAllowThreads(__tstate);
25763 if (PyErr_Occurred()) SWIG_fail;
25764 }
25765 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25766 {
25767 if (temp2) delete arg2;
25768 }
25769 return resultobj;
25770 fail:
25771 {
25772 if (temp2) delete arg2;
25773 }
25774 return NULL;
25775 }
25776
25777
25778 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25779 PyObject *resultobj = 0;
25780 wxDateTime *arg1 = (wxDateTime *) 0 ;
25781 wxDateTime::TimeZone *arg2 = 0 ;
25782 bool arg3 = (bool) false ;
25783 wxDateTime *result = 0 ;
25784 void *argp1 = 0 ;
25785 int res1 = 0 ;
25786 bool temp2 = false ;
25787 bool val3 ;
25788 int ecode3 = 0 ;
25789 PyObject * obj0 = 0 ;
25790 PyObject * obj1 = 0 ;
25791 PyObject * obj2 = 0 ;
25792 char * kwnames[] = {
25793 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25794 };
25795
25796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25798 if (!SWIG_IsOK(res1)) {
25799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25800 }
25801 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25802 {
25803 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25804 temp2 = true;
25805 }
25806 if (obj2) {
25807 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25808 if (!SWIG_IsOK(ecode3)) {
25809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25810 }
25811 arg3 = static_cast< bool >(val3);
25812 }
25813 {
25814 PyThreadState* __tstate = wxPyBeginAllowThreads();
25815 {
25816 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25817 result = (wxDateTime *) &_result_ref;
25818 }
25819 wxPyEndAllowThreads(__tstate);
25820 if (PyErr_Occurred()) SWIG_fail;
25821 }
25822 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25823 {
25824 if (temp2) delete arg2;
25825 }
25826 return resultobj;
25827 fail:
25828 {
25829 if (temp2) delete arg2;
25830 }
25831 return NULL;
25832 }
25833
25834
25835 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25836 PyObject *resultobj = 0;
25837 wxDateTime *arg1 = (wxDateTime *) 0 ;
25838 bool arg2 = (bool) false ;
25839 wxDateTime result;
25840 void *argp1 = 0 ;
25841 int res1 = 0 ;
25842 bool val2 ;
25843 int ecode2 = 0 ;
25844 PyObject * obj0 = 0 ;
25845 PyObject * obj1 = 0 ;
25846 char * kwnames[] = {
25847 (char *) "self",(char *) "noDST", NULL
25848 };
25849
25850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25852 if (!SWIG_IsOK(res1)) {
25853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25854 }
25855 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25856 if (obj1) {
25857 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25858 if (!SWIG_IsOK(ecode2)) {
25859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25860 }
25861 arg2 = static_cast< bool >(val2);
25862 }
25863 {
25864 PyThreadState* __tstate = wxPyBeginAllowThreads();
25865 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25866 wxPyEndAllowThreads(__tstate);
25867 if (PyErr_Occurred()) SWIG_fail;
25868 }
25869 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25870 return resultobj;
25871 fail:
25872 return NULL;
25873 }
25874
25875
25876 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25877 PyObject *resultobj = 0;
25878 wxDateTime *arg1 = (wxDateTime *) 0 ;
25879 bool arg2 = (bool) false ;
25880 wxDateTime *result = 0 ;
25881 void *argp1 = 0 ;
25882 int res1 = 0 ;
25883 bool val2 ;
25884 int ecode2 = 0 ;
25885 PyObject * obj0 = 0 ;
25886 PyObject * obj1 = 0 ;
25887 char * kwnames[] = {
25888 (char *) "self",(char *) "noDST", NULL
25889 };
25890
25891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25893 if (!SWIG_IsOK(res1)) {
25894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25895 }
25896 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25897 if (obj1) {
25898 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25899 if (!SWIG_IsOK(ecode2)) {
25900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25901 }
25902 arg2 = static_cast< bool >(val2);
25903 }
25904 {
25905 PyThreadState* __tstate = wxPyBeginAllowThreads();
25906 {
25907 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25908 result = (wxDateTime *) &_result_ref;
25909 }
25910 wxPyEndAllowThreads(__tstate);
25911 if (PyErr_Occurred()) SWIG_fail;
25912 }
25913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25914 return resultobj;
25915 fail:
25916 return NULL;
25917 }
25918
25919
25920 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25921 PyObject *resultobj = 0;
25922 wxDateTime *arg1 = (wxDateTime *) 0 ;
25923 bool arg2 = (bool) false ;
25924 wxDateTime result;
25925 void *argp1 = 0 ;
25926 int res1 = 0 ;
25927 bool val2 ;
25928 int ecode2 = 0 ;
25929 PyObject * obj0 = 0 ;
25930 PyObject * obj1 = 0 ;
25931 char * kwnames[] = {
25932 (char *) "self",(char *) "noDST", NULL
25933 };
25934
25935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25937 if (!SWIG_IsOK(res1)) {
25938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25939 }
25940 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25941 if (obj1) {
25942 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25943 if (!SWIG_IsOK(ecode2)) {
25944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
25945 }
25946 arg2 = static_cast< bool >(val2);
25947 }
25948 {
25949 PyThreadState* __tstate = wxPyBeginAllowThreads();
25950 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
25951 wxPyEndAllowThreads(__tstate);
25952 if (PyErr_Occurred()) SWIG_fail;
25953 }
25954 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25955 return resultobj;
25956 fail:
25957 return NULL;
25958 }
25959
25960
25961 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25962 PyObject *resultobj = 0;
25963 wxDateTime *arg1 = (wxDateTime *) 0 ;
25964 bool arg2 = (bool) false ;
25965 wxDateTime *result = 0 ;
25966 void *argp1 = 0 ;
25967 int res1 = 0 ;
25968 bool val2 ;
25969 int ecode2 = 0 ;
25970 PyObject * obj0 = 0 ;
25971 PyObject * obj1 = 0 ;
25972 char * kwnames[] = {
25973 (char *) "self",(char *) "noDST", NULL
25974 };
25975
25976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25978 if (!SWIG_IsOK(res1)) {
25979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
25980 }
25981 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25982 if (obj1) {
25983 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25984 if (!SWIG_IsOK(ecode2)) {
25985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
25986 }
25987 arg2 = static_cast< bool >(val2);
25988 }
25989 {
25990 PyThreadState* __tstate = wxPyBeginAllowThreads();
25991 {
25992 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
25993 result = (wxDateTime *) &_result_ref;
25994 }
25995 wxPyEndAllowThreads(__tstate);
25996 if (PyErr_Occurred()) SWIG_fail;
25997 }
25998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25999 return resultobj;
26000 fail:
26001 return NULL;
26002 }
26003
26004
26005 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26006 PyObject *resultobj = 0;
26007 wxDateTime *arg1 = (wxDateTime *) 0 ;
26008 bool arg2 = (bool) false ;
26009 wxDateTime result;
26010 void *argp1 = 0 ;
26011 int res1 = 0 ;
26012 bool val2 ;
26013 int ecode2 = 0 ;
26014 PyObject * obj0 = 0 ;
26015 PyObject * obj1 = 0 ;
26016 char * kwnames[] = {
26017 (char *) "self",(char *) "noDST", NULL
26018 };
26019
26020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26022 if (!SWIG_IsOK(res1)) {
26023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26024 }
26025 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26026 if (obj1) {
26027 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26028 if (!SWIG_IsOK(ecode2)) {
26029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26030 }
26031 arg2 = static_cast< bool >(val2);
26032 }
26033 {
26034 PyThreadState* __tstate = wxPyBeginAllowThreads();
26035 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26036 wxPyEndAllowThreads(__tstate);
26037 if (PyErr_Occurred()) SWIG_fail;
26038 }
26039 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26040 return resultobj;
26041 fail:
26042 return NULL;
26043 }
26044
26045
26046 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26047 PyObject *resultobj = 0;
26048 wxDateTime *arg1 = (wxDateTime *) 0 ;
26049 bool arg2 = (bool) false ;
26050 wxDateTime *result = 0 ;
26051 void *argp1 = 0 ;
26052 int res1 = 0 ;
26053 bool val2 ;
26054 int ecode2 = 0 ;
26055 PyObject * obj0 = 0 ;
26056 PyObject * obj1 = 0 ;
26057 char * kwnames[] = {
26058 (char *) "self",(char *) "noDST", NULL
26059 };
26060
26061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26063 if (!SWIG_IsOK(res1)) {
26064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26065 }
26066 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26067 if (obj1) {
26068 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26069 if (!SWIG_IsOK(ecode2)) {
26070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26071 }
26072 arg2 = static_cast< bool >(val2);
26073 }
26074 {
26075 PyThreadState* __tstate = wxPyBeginAllowThreads();
26076 {
26077 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26078 result = (wxDateTime *) &_result_ref;
26079 }
26080 wxPyEndAllowThreads(__tstate);
26081 if (PyErr_Occurred()) SWIG_fail;
26082 }
26083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26084 return resultobj;
26085 fail:
26086 return NULL;
26087 }
26088
26089
26090 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26091 PyObject *resultobj = 0;
26092 wxDateTime *arg1 = (wxDateTime *) 0 ;
26093 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26094 int result;
26095 void *argp1 = 0 ;
26096 int res1 = 0 ;
26097 int val2 ;
26098 int ecode2 = 0 ;
26099 PyObject * obj0 = 0 ;
26100 PyObject * obj1 = 0 ;
26101 char * kwnames[] = {
26102 (char *) "self",(char *) "country", NULL
26103 };
26104
26105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26107 if (!SWIG_IsOK(res1)) {
26108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26109 }
26110 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26111 if (obj1) {
26112 ecode2 = SWIG_AsVal_int(obj1, &val2);
26113 if (!SWIG_IsOK(ecode2)) {
26114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26115 }
26116 arg2 = static_cast< wxDateTime::Country >(val2);
26117 }
26118 {
26119 PyThreadState* __tstate = wxPyBeginAllowThreads();
26120 result = (int)(arg1)->IsDST(arg2);
26121 wxPyEndAllowThreads(__tstate);
26122 if (PyErr_Occurred()) SWIG_fail;
26123 }
26124 resultobj = SWIG_From_int(static_cast< int >(result));
26125 return resultobj;
26126 fail:
26127 return NULL;
26128 }
26129
26130
26131 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26132 PyObject *resultobj = 0;
26133 wxDateTime *arg1 = (wxDateTime *) 0 ;
26134 bool result;
26135 void *argp1 = 0 ;
26136 int res1 = 0 ;
26137 PyObject *swig_obj[1] ;
26138
26139 if (!args) SWIG_fail;
26140 swig_obj[0] = args;
26141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26142 if (!SWIG_IsOK(res1)) {
26143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26144 }
26145 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26146 {
26147 PyThreadState* __tstate = wxPyBeginAllowThreads();
26148 result = (bool)((wxDateTime const *)arg1)->IsValid();
26149 wxPyEndAllowThreads(__tstate);
26150 if (PyErr_Occurred()) SWIG_fail;
26151 }
26152 {
26153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26154 }
26155 return resultobj;
26156 fail:
26157 return NULL;
26158 }
26159
26160
26161 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26162 PyObject *resultobj = 0;
26163 wxDateTime *arg1 = (wxDateTime *) 0 ;
26164 time_t result;
26165 void *argp1 = 0 ;
26166 int res1 = 0 ;
26167 PyObject *swig_obj[1] ;
26168
26169 if (!args) SWIG_fail;
26170 swig_obj[0] = args;
26171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26172 if (!SWIG_IsOK(res1)) {
26173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26174 }
26175 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26176 {
26177 PyThreadState* __tstate = wxPyBeginAllowThreads();
26178 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26179 wxPyEndAllowThreads(__tstate);
26180 if (PyErr_Occurred()) SWIG_fail;
26181 }
26182 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26183 return resultobj;
26184 fail:
26185 return NULL;
26186 }
26187
26188
26189 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26190 PyObject *resultobj = 0;
26191 wxDateTime *arg1 = (wxDateTime *) 0 ;
26192 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26193 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26194 int result;
26195 void *argp1 = 0 ;
26196 int res1 = 0 ;
26197 bool temp2 = false ;
26198 PyObject * obj0 = 0 ;
26199 PyObject * obj1 = 0 ;
26200 char * kwnames[] = {
26201 (char *) "self",(char *) "tz", NULL
26202 };
26203
26204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26206 if (!SWIG_IsOK(res1)) {
26207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26208 }
26209 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26210 if (obj1) {
26211 {
26212 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26213 temp2 = true;
26214 }
26215 }
26216 {
26217 PyThreadState* __tstate = wxPyBeginAllowThreads();
26218 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26219 wxPyEndAllowThreads(__tstate);
26220 if (PyErr_Occurred()) SWIG_fail;
26221 }
26222 resultobj = SWIG_From_int(static_cast< int >(result));
26223 {
26224 if (temp2) delete arg2;
26225 }
26226 return resultobj;
26227 fail:
26228 {
26229 if (temp2) delete arg2;
26230 }
26231 return NULL;
26232 }
26233
26234
26235 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26236 PyObject *resultobj = 0;
26237 wxDateTime *arg1 = (wxDateTime *) 0 ;
26238 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26239 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26240 wxDateTime::Month result;
26241 void *argp1 = 0 ;
26242 int res1 = 0 ;
26243 bool temp2 = false ;
26244 PyObject * obj0 = 0 ;
26245 PyObject * obj1 = 0 ;
26246 char * kwnames[] = {
26247 (char *) "self",(char *) "tz", NULL
26248 };
26249
26250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26252 if (!SWIG_IsOK(res1)) {
26253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26254 }
26255 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26256 if (obj1) {
26257 {
26258 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26259 temp2 = true;
26260 }
26261 }
26262 {
26263 PyThreadState* __tstate = wxPyBeginAllowThreads();
26264 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26265 wxPyEndAllowThreads(__tstate);
26266 if (PyErr_Occurred()) SWIG_fail;
26267 }
26268 resultobj = SWIG_From_int(static_cast< int >(result));
26269 {
26270 if (temp2) delete arg2;
26271 }
26272 return resultobj;
26273 fail:
26274 {
26275 if (temp2) delete arg2;
26276 }
26277 return NULL;
26278 }
26279
26280
26281 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26282 PyObject *resultobj = 0;
26283 wxDateTime *arg1 = (wxDateTime *) 0 ;
26284 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26285 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26286 int result;
26287 void *argp1 = 0 ;
26288 int res1 = 0 ;
26289 bool temp2 = false ;
26290 PyObject * obj0 = 0 ;
26291 PyObject * obj1 = 0 ;
26292 char * kwnames[] = {
26293 (char *) "self",(char *) "tz", NULL
26294 };
26295
26296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26298 if (!SWIG_IsOK(res1)) {
26299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26300 }
26301 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26302 if (obj1) {
26303 {
26304 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26305 temp2 = true;
26306 }
26307 }
26308 {
26309 PyThreadState* __tstate = wxPyBeginAllowThreads();
26310 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26311 wxPyEndAllowThreads(__tstate);
26312 if (PyErr_Occurred()) SWIG_fail;
26313 }
26314 resultobj = SWIG_From_int(static_cast< int >(result));
26315 {
26316 if (temp2) delete arg2;
26317 }
26318 return resultobj;
26319 fail:
26320 {
26321 if (temp2) delete arg2;
26322 }
26323 return NULL;
26324 }
26325
26326
26327 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26328 PyObject *resultobj = 0;
26329 wxDateTime *arg1 = (wxDateTime *) 0 ;
26330 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26331 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26332 wxDateTime::WeekDay result;
26333 void *argp1 = 0 ;
26334 int res1 = 0 ;
26335 bool temp2 = false ;
26336 PyObject * obj0 = 0 ;
26337 PyObject * obj1 = 0 ;
26338 char * kwnames[] = {
26339 (char *) "self",(char *) "tz", NULL
26340 };
26341
26342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26344 if (!SWIG_IsOK(res1)) {
26345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26346 }
26347 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26348 if (obj1) {
26349 {
26350 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26351 temp2 = true;
26352 }
26353 }
26354 {
26355 PyThreadState* __tstate = wxPyBeginAllowThreads();
26356 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26357 wxPyEndAllowThreads(__tstate);
26358 if (PyErr_Occurred()) SWIG_fail;
26359 }
26360 resultobj = SWIG_From_int(static_cast< int >(result));
26361 {
26362 if (temp2) delete arg2;
26363 }
26364 return resultobj;
26365 fail:
26366 {
26367 if (temp2) delete arg2;
26368 }
26369 return NULL;
26370 }
26371
26372
26373 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26374 PyObject *resultobj = 0;
26375 wxDateTime *arg1 = (wxDateTime *) 0 ;
26376 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26377 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26378 int result;
26379 void *argp1 = 0 ;
26380 int res1 = 0 ;
26381 bool temp2 = false ;
26382 PyObject * obj0 = 0 ;
26383 PyObject * obj1 = 0 ;
26384 char * kwnames[] = {
26385 (char *) "self",(char *) "tz", NULL
26386 };
26387
26388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26390 if (!SWIG_IsOK(res1)) {
26391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26392 }
26393 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26394 if (obj1) {
26395 {
26396 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26397 temp2 = true;
26398 }
26399 }
26400 {
26401 PyThreadState* __tstate = wxPyBeginAllowThreads();
26402 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26403 wxPyEndAllowThreads(__tstate);
26404 if (PyErr_Occurred()) SWIG_fail;
26405 }
26406 resultobj = SWIG_From_int(static_cast< int >(result));
26407 {
26408 if (temp2) delete arg2;
26409 }
26410 return resultobj;
26411 fail:
26412 {
26413 if (temp2) delete arg2;
26414 }
26415 return NULL;
26416 }
26417
26418
26419 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26420 PyObject *resultobj = 0;
26421 wxDateTime *arg1 = (wxDateTime *) 0 ;
26422 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26423 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26424 int result;
26425 void *argp1 = 0 ;
26426 int res1 = 0 ;
26427 bool temp2 = false ;
26428 PyObject * obj0 = 0 ;
26429 PyObject * obj1 = 0 ;
26430 char * kwnames[] = {
26431 (char *) "self",(char *) "tz", NULL
26432 };
26433
26434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26436 if (!SWIG_IsOK(res1)) {
26437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26438 }
26439 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26440 if (obj1) {
26441 {
26442 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26443 temp2 = true;
26444 }
26445 }
26446 {
26447 PyThreadState* __tstate = wxPyBeginAllowThreads();
26448 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26449 wxPyEndAllowThreads(__tstate);
26450 if (PyErr_Occurred()) SWIG_fail;
26451 }
26452 resultobj = SWIG_From_int(static_cast< int >(result));
26453 {
26454 if (temp2) delete arg2;
26455 }
26456 return resultobj;
26457 fail:
26458 {
26459 if (temp2) delete arg2;
26460 }
26461 return NULL;
26462 }
26463
26464
26465 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26466 PyObject *resultobj = 0;
26467 wxDateTime *arg1 = (wxDateTime *) 0 ;
26468 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26469 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26470 int result;
26471 void *argp1 = 0 ;
26472 int res1 = 0 ;
26473 bool temp2 = false ;
26474 PyObject * obj0 = 0 ;
26475 PyObject * obj1 = 0 ;
26476 char * kwnames[] = {
26477 (char *) "self",(char *) "tz", NULL
26478 };
26479
26480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26482 if (!SWIG_IsOK(res1)) {
26483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26484 }
26485 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26486 if (obj1) {
26487 {
26488 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26489 temp2 = true;
26490 }
26491 }
26492 {
26493 PyThreadState* __tstate = wxPyBeginAllowThreads();
26494 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26495 wxPyEndAllowThreads(__tstate);
26496 if (PyErr_Occurred()) SWIG_fail;
26497 }
26498 resultobj = SWIG_From_int(static_cast< int >(result));
26499 {
26500 if (temp2) delete arg2;
26501 }
26502 return resultobj;
26503 fail:
26504 {
26505 if (temp2) delete arg2;
26506 }
26507 return NULL;
26508 }
26509
26510
26511 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26512 PyObject *resultobj = 0;
26513 wxDateTime *arg1 = (wxDateTime *) 0 ;
26514 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26515 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26516 int result;
26517 void *argp1 = 0 ;
26518 int res1 = 0 ;
26519 bool temp2 = false ;
26520 PyObject * obj0 = 0 ;
26521 PyObject * obj1 = 0 ;
26522 char * kwnames[] = {
26523 (char *) "self",(char *) "tz", NULL
26524 };
26525
26526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26528 if (!SWIG_IsOK(res1)) {
26529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26530 }
26531 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26532 if (obj1) {
26533 {
26534 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26535 temp2 = true;
26536 }
26537 }
26538 {
26539 PyThreadState* __tstate = wxPyBeginAllowThreads();
26540 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26541 wxPyEndAllowThreads(__tstate);
26542 if (PyErr_Occurred()) SWIG_fail;
26543 }
26544 resultobj = SWIG_From_int(static_cast< int >(result));
26545 {
26546 if (temp2) delete arg2;
26547 }
26548 return resultobj;
26549 fail:
26550 {
26551 if (temp2) delete arg2;
26552 }
26553 return NULL;
26554 }
26555
26556
26557 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26558 PyObject *resultobj = 0;
26559 wxDateTime *arg1 = (wxDateTime *) 0 ;
26560 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26561 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26562 int result;
26563 void *argp1 = 0 ;
26564 int res1 = 0 ;
26565 bool temp2 = false ;
26566 PyObject * obj0 = 0 ;
26567 PyObject * obj1 = 0 ;
26568 char * kwnames[] = {
26569 (char *) "self",(char *) "tz", NULL
26570 };
26571
26572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26574 if (!SWIG_IsOK(res1)) {
26575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26576 }
26577 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26578 if (obj1) {
26579 {
26580 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26581 temp2 = true;
26582 }
26583 }
26584 {
26585 PyThreadState* __tstate = wxPyBeginAllowThreads();
26586 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26587 wxPyEndAllowThreads(__tstate);
26588 if (PyErr_Occurred()) SWIG_fail;
26589 }
26590 resultobj = SWIG_From_int(static_cast< int >(result));
26591 {
26592 if (temp2) delete arg2;
26593 }
26594 return resultobj;
26595 fail:
26596 {
26597 if (temp2) delete arg2;
26598 }
26599 return NULL;
26600 }
26601
26602
26603 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26604 PyObject *resultobj = 0;
26605 wxDateTime *arg1 = (wxDateTime *) 0 ;
26606 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26607 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26608 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26609 int result;
26610 void *argp1 = 0 ;
26611 int res1 = 0 ;
26612 int val2 ;
26613 int ecode2 = 0 ;
26614 bool temp3 = false ;
26615 PyObject * obj0 = 0 ;
26616 PyObject * obj1 = 0 ;
26617 PyObject * obj2 = 0 ;
26618 char * kwnames[] = {
26619 (char *) "self",(char *) "flags",(char *) "tz", NULL
26620 };
26621
26622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) 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_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26626 }
26627 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26628 if (obj1) {
26629 ecode2 = SWIG_AsVal_int(obj1, &val2);
26630 if (!SWIG_IsOK(ecode2)) {
26631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26632 }
26633 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26634 }
26635 if (obj2) {
26636 {
26637 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26638 temp3 = true;
26639 }
26640 }
26641 {
26642 PyThreadState* __tstate = wxPyBeginAllowThreads();
26643 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26644 wxPyEndAllowThreads(__tstate);
26645 if (PyErr_Occurred()) SWIG_fail;
26646 }
26647 resultobj = SWIG_From_int(static_cast< int >(result));
26648 {
26649 if (temp3) delete arg3;
26650 }
26651 return resultobj;
26652 fail:
26653 {
26654 if (temp3) delete arg3;
26655 }
26656 return NULL;
26657 }
26658
26659
26660 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26661 PyObject *resultobj = 0;
26662 wxDateTime *arg1 = (wxDateTime *) 0 ;
26663 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26664 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26665 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26666 int result;
26667 void *argp1 = 0 ;
26668 int res1 = 0 ;
26669 int val2 ;
26670 int ecode2 = 0 ;
26671 bool temp3 = false ;
26672 PyObject * obj0 = 0 ;
26673 PyObject * obj1 = 0 ;
26674 PyObject * obj2 = 0 ;
26675 char * kwnames[] = {
26676 (char *) "self",(char *) "flags",(char *) "tz", NULL
26677 };
26678
26679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26681 if (!SWIG_IsOK(res1)) {
26682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26683 }
26684 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26685 if (obj1) {
26686 ecode2 = SWIG_AsVal_int(obj1, &val2);
26687 if (!SWIG_IsOK(ecode2)) {
26688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26689 }
26690 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26691 }
26692 if (obj2) {
26693 {
26694 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26695 temp3 = true;
26696 }
26697 }
26698 {
26699 PyThreadState* __tstate = wxPyBeginAllowThreads();
26700 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26701 wxPyEndAllowThreads(__tstate);
26702 if (PyErr_Occurred()) SWIG_fail;
26703 }
26704 resultobj = SWIG_From_int(static_cast< int >(result));
26705 {
26706 if (temp3) delete arg3;
26707 }
26708 return resultobj;
26709 fail:
26710 {
26711 if (temp3) delete arg3;
26712 }
26713 return NULL;
26714 }
26715
26716
26717 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26718 PyObject *resultobj = 0;
26719 wxDateTime *arg1 = (wxDateTime *) 0 ;
26720 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26721 bool result;
26722 void *argp1 = 0 ;
26723 int res1 = 0 ;
26724 int val2 ;
26725 int ecode2 = 0 ;
26726 PyObject * obj0 = 0 ;
26727 PyObject * obj1 = 0 ;
26728 char * kwnames[] = {
26729 (char *) "self",(char *) "country", NULL
26730 };
26731
26732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26734 if (!SWIG_IsOK(res1)) {
26735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26736 }
26737 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26738 if (obj1) {
26739 ecode2 = SWIG_AsVal_int(obj1, &val2);
26740 if (!SWIG_IsOK(ecode2)) {
26741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26742 }
26743 arg2 = static_cast< wxDateTime::Country >(val2);
26744 }
26745 {
26746 PyThreadState* __tstate = wxPyBeginAllowThreads();
26747 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26748 wxPyEndAllowThreads(__tstate);
26749 if (PyErr_Occurred()) SWIG_fail;
26750 }
26751 {
26752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26753 }
26754 return resultobj;
26755 fail:
26756 return NULL;
26757 }
26758
26759
26760 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26761 PyObject *resultobj = 0;
26762 wxDateTime *arg1 = (wxDateTime *) 0 ;
26763 wxDateTime *arg2 = 0 ;
26764 bool result;
26765 void *argp1 = 0 ;
26766 int res1 = 0 ;
26767 void *argp2 = 0 ;
26768 int res2 = 0 ;
26769 PyObject * obj0 = 0 ;
26770 PyObject * obj1 = 0 ;
26771 char * kwnames[] = {
26772 (char *) "self",(char *) "datetime", NULL
26773 };
26774
26775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) 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_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26779 }
26780 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26781 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26782 if (!SWIG_IsOK(res2)) {
26783 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26784 }
26785 if (!argp2) {
26786 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26787 }
26788 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26789 {
26790 PyThreadState* __tstate = wxPyBeginAllowThreads();
26791 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26792 wxPyEndAllowThreads(__tstate);
26793 if (PyErr_Occurred()) SWIG_fail;
26794 }
26795 {
26796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26797 }
26798 return resultobj;
26799 fail:
26800 return NULL;
26801 }
26802
26803
26804 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26805 PyObject *resultobj = 0;
26806 wxDateTime *arg1 = (wxDateTime *) 0 ;
26807 wxDateTime *arg2 = 0 ;
26808 bool result;
26809 void *argp1 = 0 ;
26810 int res1 = 0 ;
26811 void *argp2 = 0 ;
26812 int res2 = 0 ;
26813 PyObject * obj0 = 0 ;
26814 PyObject * obj1 = 0 ;
26815 char * kwnames[] = {
26816 (char *) "self",(char *) "datetime", NULL
26817 };
26818
26819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26821 if (!SWIG_IsOK(res1)) {
26822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26823 }
26824 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26825 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26826 if (!SWIG_IsOK(res2)) {
26827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26828 }
26829 if (!argp2) {
26830 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26831 }
26832 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26833 {
26834 PyThreadState* __tstate = wxPyBeginAllowThreads();
26835 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26836 wxPyEndAllowThreads(__tstate);
26837 if (PyErr_Occurred()) SWIG_fail;
26838 }
26839 {
26840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26841 }
26842 return resultobj;
26843 fail:
26844 return NULL;
26845 }
26846
26847
26848 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26849 PyObject *resultobj = 0;
26850 wxDateTime *arg1 = (wxDateTime *) 0 ;
26851 wxDateTime *arg2 = 0 ;
26852 bool result;
26853 void *argp1 = 0 ;
26854 int res1 = 0 ;
26855 void *argp2 = 0 ;
26856 int res2 = 0 ;
26857 PyObject * obj0 = 0 ;
26858 PyObject * obj1 = 0 ;
26859 char * kwnames[] = {
26860 (char *) "self",(char *) "datetime", NULL
26861 };
26862
26863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26865 if (!SWIG_IsOK(res1)) {
26866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26867 }
26868 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26869 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26870 if (!SWIG_IsOK(res2)) {
26871 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26872 }
26873 if (!argp2) {
26874 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26875 }
26876 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26877 {
26878 PyThreadState* __tstate = wxPyBeginAllowThreads();
26879 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26880 wxPyEndAllowThreads(__tstate);
26881 if (PyErr_Occurred()) SWIG_fail;
26882 }
26883 {
26884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26885 }
26886 return resultobj;
26887 fail:
26888 return NULL;
26889 }
26890
26891
26892 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26893 PyObject *resultobj = 0;
26894 wxDateTime *arg1 = (wxDateTime *) 0 ;
26895 wxDateTime *arg2 = 0 ;
26896 wxDateTime *arg3 = 0 ;
26897 bool result;
26898 void *argp1 = 0 ;
26899 int res1 = 0 ;
26900 void *argp2 = 0 ;
26901 int res2 = 0 ;
26902 void *argp3 = 0 ;
26903 int res3 = 0 ;
26904 PyObject * obj0 = 0 ;
26905 PyObject * obj1 = 0 ;
26906 PyObject * obj2 = 0 ;
26907 char * kwnames[] = {
26908 (char *) "self",(char *) "t1",(char *) "t2", NULL
26909 };
26910
26911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26913 if (!SWIG_IsOK(res1)) {
26914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26915 }
26916 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26917 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26918 if (!SWIG_IsOK(res2)) {
26919 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26920 }
26921 if (!argp2) {
26922 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26923 }
26924 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26925 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26926 if (!SWIG_IsOK(res3)) {
26927 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26928 }
26929 if (!argp3) {
26930 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26931 }
26932 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26933 {
26934 PyThreadState* __tstate = wxPyBeginAllowThreads();
26935 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26936 wxPyEndAllowThreads(__tstate);
26937 if (PyErr_Occurred()) SWIG_fail;
26938 }
26939 {
26940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26941 }
26942 return resultobj;
26943 fail:
26944 return NULL;
26945 }
26946
26947
26948 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26949 PyObject *resultobj = 0;
26950 wxDateTime *arg1 = (wxDateTime *) 0 ;
26951 wxDateTime *arg2 = 0 ;
26952 wxDateTime *arg3 = 0 ;
26953 bool result;
26954 void *argp1 = 0 ;
26955 int res1 = 0 ;
26956 void *argp2 = 0 ;
26957 int res2 = 0 ;
26958 void *argp3 = 0 ;
26959 int res3 = 0 ;
26960 PyObject * obj0 = 0 ;
26961 PyObject * obj1 = 0 ;
26962 PyObject * obj2 = 0 ;
26963 char * kwnames[] = {
26964 (char *) "self",(char *) "t1",(char *) "t2", NULL
26965 };
26966
26967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26969 if (!SWIG_IsOK(res1)) {
26970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26971 }
26972 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26973 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26974 if (!SWIG_IsOK(res2)) {
26975 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26976 }
26977 if (!argp2) {
26978 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26979 }
26980 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26981 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26982 if (!SWIG_IsOK(res3)) {
26983 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26984 }
26985 if (!argp3) {
26986 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26987 }
26988 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26989 {
26990 PyThreadState* __tstate = wxPyBeginAllowThreads();
26991 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26992 wxPyEndAllowThreads(__tstate);
26993 if (PyErr_Occurred()) SWIG_fail;
26994 }
26995 {
26996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26997 }
26998 return resultobj;
26999 fail:
27000 return NULL;
27001 }
27002
27003
27004 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27005 PyObject *resultobj = 0;
27006 wxDateTime *arg1 = (wxDateTime *) 0 ;
27007 wxDateTime *arg2 = 0 ;
27008 bool result;
27009 void *argp1 = 0 ;
27010 int res1 = 0 ;
27011 void *argp2 = 0 ;
27012 int res2 = 0 ;
27013 PyObject * obj0 = 0 ;
27014 PyObject * obj1 = 0 ;
27015 char * kwnames[] = {
27016 (char *) "self",(char *) "dt", NULL
27017 };
27018
27019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27021 if (!SWIG_IsOK(res1)) {
27022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27023 }
27024 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27025 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27026 if (!SWIG_IsOK(res2)) {
27027 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27028 }
27029 if (!argp2) {
27030 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27031 }
27032 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27033 {
27034 PyThreadState* __tstate = wxPyBeginAllowThreads();
27035 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27036 wxPyEndAllowThreads(__tstate);
27037 if (PyErr_Occurred()) SWIG_fail;
27038 }
27039 {
27040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27041 }
27042 return resultobj;
27043 fail:
27044 return NULL;
27045 }
27046
27047
27048 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27049 PyObject *resultobj = 0;
27050 wxDateTime *arg1 = (wxDateTime *) 0 ;
27051 wxDateTime *arg2 = 0 ;
27052 bool result;
27053 void *argp1 = 0 ;
27054 int res1 = 0 ;
27055 void *argp2 = 0 ;
27056 int res2 = 0 ;
27057 PyObject * obj0 = 0 ;
27058 PyObject * obj1 = 0 ;
27059 char * kwnames[] = {
27060 (char *) "self",(char *) "dt", NULL
27061 };
27062
27063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) 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_IsSameTime" "', 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_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27072 }
27073 if (!argp2) {
27074 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27075 }
27076 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27077 {
27078 PyThreadState* __tstate = wxPyBeginAllowThreads();
27079 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27080 wxPyEndAllowThreads(__tstate);
27081 if (PyErr_Occurred()) SWIG_fail;
27082 }
27083 {
27084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27085 }
27086 return resultobj;
27087 fail:
27088 return NULL;
27089 }
27090
27091
27092 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27093 PyObject *resultobj = 0;
27094 wxDateTime *arg1 = (wxDateTime *) 0 ;
27095 wxDateTime *arg2 = 0 ;
27096 wxTimeSpan *arg3 = 0 ;
27097 bool result;
27098 void *argp1 = 0 ;
27099 int res1 = 0 ;
27100 void *argp2 = 0 ;
27101 int res2 = 0 ;
27102 void *argp3 = 0 ;
27103 int res3 = 0 ;
27104 PyObject * obj0 = 0 ;
27105 PyObject * obj1 = 0 ;
27106 PyObject * obj2 = 0 ;
27107 char * kwnames[] = {
27108 (char *) "self",(char *) "dt",(char *) "ts", NULL
27109 };
27110
27111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27113 if (!SWIG_IsOK(res1)) {
27114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27115 }
27116 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27117 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27118 if (!SWIG_IsOK(res2)) {
27119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27120 }
27121 if (!argp2) {
27122 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27123 }
27124 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27125 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27126 if (!SWIG_IsOK(res3)) {
27127 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27128 }
27129 if (!argp3) {
27130 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27131 }
27132 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27133 {
27134 PyThreadState* __tstate = wxPyBeginAllowThreads();
27135 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27136 wxPyEndAllowThreads(__tstate);
27137 if (PyErr_Occurred()) SWIG_fail;
27138 }
27139 {
27140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27141 }
27142 return resultobj;
27143 fail:
27144 return NULL;
27145 }
27146
27147
27148 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27149 PyObject *resultobj = 0;
27150 wxDateTime *arg1 = (wxDateTime *) 0 ;
27151 wxTimeSpan *arg2 = 0 ;
27152 wxDateTime *result = 0 ;
27153 void *argp1 = 0 ;
27154 int res1 = 0 ;
27155 void *argp2 = 0 ;
27156 int res2 = 0 ;
27157 PyObject * obj0 = 0 ;
27158 PyObject * obj1 = 0 ;
27159 char * kwnames[] = {
27160 (char *) "self",(char *) "diff", NULL
27161 };
27162
27163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27165 if (!SWIG_IsOK(res1)) {
27166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27167 }
27168 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27169 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27170 if (!SWIG_IsOK(res2)) {
27171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27172 }
27173 if (!argp2) {
27174 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27175 }
27176 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27177 {
27178 PyThreadState* __tstate = wxPyBeginAllowThreads();
27179 {
27180 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27181 result = (wxDateTime *) &_result_ref;
27182 }
27183 wxPyEndAllowThreads(__tstate);
27184 if (PyErr_Occurred()) SWIG_fail;
27185 }
27186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27187 return resultobj;
27188 fail:
27189 return NULL;
27190 }
27191
27192
27193 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27194 PyObject *resultobj = 0;
27195 wxDateTime *arg1 = (wxDateTime *) 0 ;
27196 wxDateSpan *arg2 = 0 ;
27197 wxDateTime *result = 0 ;
27198 void *argp1 = 0 ;
27199 int res1 = 0 ;
27200 void *argp2 = 0 ;
27201 int res2 = 0 ;
27202 PyObject * obj0 = 0 ;
27203 PyObject * obj1 = 0 ;
27204 char * kwnames[] = {
27205 (char *) "self",(char *) "diff", NULL
27206 };
27207
27208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27210 if (!SWIG_IsOK(res1)) {
27211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27212 }
27213 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27214 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27215 if (!SWIG_IsOK(res2)) {
27216 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27217 }
27218 if (!argp2) {
27219 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27220 }
27221 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27222 {
27223 PyThreadState* __tstate = wxPyBeginAllowThreads();
27224 {
27225 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27226 result = (wxDateTime *) &_result_ref;
27227 }
27228 wxPyEndAllowThreads(__tstate);
27229 if (PyErr_Occurred()) SWIG_fail;
27230 }
27231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27232 return resultobj;
27233 fail:
27234 return NULL;
27235 }
27236
27237
27238 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27239 PyObject *resultobj = 0;
27240 wxDateTime *arg1 = (wxDateTime *) 0 ;
27241 wxTimeSpan *arg2 = 0 ;
27242 wxDateTime *result = 0 ;
27243 void *argp1 = 0 ;
27244 int res1 = 0 ;
27245 void *argp2 = 0 ;
27246 int res2 = 0 ;
27247 PyObject * obj0 = 0 ;
27248 PyObject * obj1 = 0 ;
27249 char * kwnames[] = {
27250 (char *) "self",(char *) "diff", NULL
27251 };
27252
27253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27255 if (!SWIG_IsOK(res1)) {
27256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27257 }
27258 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27259 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27260 if (!SWIG_IsOK(res2)) {
27261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27262 }
27263 if (!argp2) {
27264 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27265 }
27266 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27267 {
27268 PyThreadState* __tstate = wxPyBeginAllowThreads();
27269 {
27270 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27271 result = (wxDateTime *) &_result_ref;
27272 }
27273 wxPyEndAllowThreads(__tstate);
27274 if (PyErr_Occurred()) SWIG_fail;
27275 }
27276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27277 return resultobj;
27278 fail:
27279 return NULL;
27280 }
27281
27282
27283 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27284 PyObject *resultobj = 0;
27285 wxDateTime *arg1 = (wxDateTime *) 0 ;
27286 wxDateSpan *arg2 = 0 ;
27287 wxDateTime *result = 0 ;
27288 void *argp1 = 0 ;
27289 int res1 = 0 ;
27290 void *argp2 = 0 ;
27291 int res2 = 0 ;
27292 PyObject * obj0 = 0 ;
27293 PyObject * obj1 = 0 ;
27294 char * kwnames[] = {
27295 (char *) "self",(char *) "diff", NULL
27296 };
27297
27298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27300 if (!SWIG_IsOK(res1)) {
27301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27302 }
27303 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27304 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27305 if (!SWIG_IsOK(res2)) {
27306 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27307 }
27308 if (!argp2) {
27309 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27310 }
27311 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27312 {
27313 PyThreadState* __tstate = wxPyBeginAllowThreads();
27314 {
27315 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27316 result = (wxDateTime *) &_result_ref;
27317 }
27318 wxPyEndAllowThreads(__tstate);
27319 if (PyErr_Occurred()) SWIG_fail;
27320 }
27321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27322 return resultobj;
27323 fail:
27324 return NULL;
27325 }
27326
27327
27328 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27329 PyObject *resultobj = 0;
27330 wxDateTime *arg1 = (wxDateTime *) 0 ;
27331 wxDateTime *arg2 = 0 ;
27332 wxTimeSpan result;
27333 void *argp1 = 0 ;
27334 int res1 = 0 ;
27335 void *argp2 = 0 ;
27336 int res2 = 0 ;
27337 PyObject * obj0 = 0 ;
27338 PyObject * obj1 = 0 ;
27339 char * kwnames[] = {
27340 (char *) "self",(char *) "dt", NULL
27341 };
27342
27343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27345 if (!SWIG_IsOK(res1)) {
27346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27347 }
27348 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27349 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27350 if (!SWIG_IsOK(res2)) {
27351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27352 }
27353 if (!argp2) {
27354 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27355 }
27356 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27357 {
27358 PyThreadState* __tstate = wxPyBeginAllowThreads();
27359 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27360 wxPyEndAllowThreads(__tstate);
27361 if (PyErr_Occurred()) SWIG_fail;
27362 }
27363 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27364 return resultobj;
27365 fail:
27366 return NULL;
27367 }
27368
27369
27370 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27371 PyObject *resultobj = 0;
27372 wxDateTime *arg1 = (wxDateTime *) 0 ;
27373 wxTimeSpan *arg2 = 0 ;
27374 wxDateTime *result = 0 ;
27375 void *argp1 = 0 ;
27376 int res1 = 0 ;
27377 void *argp2 = 0 ;
27378 int res2 = 0 ;
27379
27380 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27382 if (!SWIG_IsOK(res1)) {
27383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27384 }
27385 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27386 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27387 if (!SWIG_IsOK(res2)) {
27388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27389 }
27390 if (!argp2) {
27391 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27392 }
27393 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27394 {
27395 PyThreadState* __tstate = wxPyBeginAllowThreads();
27396 {
27397 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27398 result = (wxDateTime *) &_result_ref;
27399 }
27400 wxPyEndAllowThreads(__tstate);
27401 if (PyErr_Occurred()) SWIG_fail;
27402 }
27403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27404 return resultobj;
27405 fail:
27406 return NULL;
27407 }
27408
27409
27410 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27411 PyObject *resultobj = 0;
27412 wxDateTime *arg1 = (wxDateTime *) 0 ;
27413 wxDateSpan *arg2 = 0 ;
27414 wxDateTime *result = 0 ;
27415 void *argp1 = 0 ;
27416 int res1 = 0 ;
27417 void *argp2 = 0 ;
27418 int res2 = 0 ;
27419
27420 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27422 if (!SWIG_IsOK(res1)) {
27423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27424 }
27425 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27426 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27427 if (!SWIG_IsOK(res2)) {
27428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27429 }
27430 if (!argp2) {
27431 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27432 }
27433 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27434 {
27435 PyThreadState* __tstate = wxPyBeginAllowThreads();
27436 {
27437 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27438 result = (wxDateTime *) &_result_ref;
27439 }
27440 wxPyEndAllowThreads(__tstate);
27441 if (PyErr_Occurred()) SWIG_fail;
27442 }
27443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27444 return resultobj;
27445 fail:
27446 return NULL;
27447 }
27448
27449
27450 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27451 int argc;
27452 PyObject *argv[3];
27453
27454 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27455 --argc;
27456 if (argc == 2) {
27457 int _v = 0;
27458 {
27459 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27460 _v = SWIG_CheckState(res);
27461 }
27462 if (!_v) goto check_1;
27463 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27464 }
27465 check_1:
27466
27467 if (argc == 2) {
27468 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27469 }
27470
27471 fail:
27472 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27473 return NULL;
27474 }
27475
27476
27477 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27478 PyObject *resultobj = 0;
27479 wxDateTime *arg1 = (wxDateTime *) 0 ;
27480 wxTimeSpan *arg2 = 0 ;
27481 wxDateTime *result = 0 ;
27482 void *argp1 = 0 ;
27483 int res1 = 0 ;
27484 void *argp2 = 0 ;
27485 int res2 = 0 ;
27486
27487 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27489 if (!SWIG_IsOK(res1)) {
27490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27491 }
27492 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27493 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27494 if (!SWIG_IsOK(res2)) {
27495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27496 }
27497 if (!argp2) {
27498 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27499 }
27500 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27501 {
27502 PyThreadState* __tstate = wxPyBeginAllowThreads();
27503 {
27504 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27505 result = (wxDateTime *) &_result_ref;
27506 }
27507 wxPyEndAllowThreads(__tstate);
27508 if (PyErr_Occurred()) SWIG_fail;
27509 }
27510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27511 return resultobj;
27512 fail:
27513 return NULL;
27514 }
27515
27516
27517 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27518 PyObject *resultobj = 0;
27519 wxDateTime *arg1 = (wxDateTime *) 0 ;
27520 wxDateSpan *arg2 = 0 ;
27521 wxDateTime *result = 0 ;
27522 void *argp1 = 0 ;
27523 int res1 = 0 ;
27524 void *argp2 = 0 ;
27525 int res2 = 0 ;
27526
27527 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27529 if (!SWIG_IsOK(res1)) {
27530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27531 }
27532 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27533 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27534 if (!SWIG_IsOK(res2)) {
27535 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27536 }
27537 if (!argp2) {
27538 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27539 }
27540 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27541 {
27542 PyThreadState* __tstate = wxPyBeginAllowThreads();
27543 {
27544 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27545 result = (wxDateTime *) &_result_ref;
27546 }
27547 wxPyEndAllowThreads(__tstate);
27548 if (PyErr_Occurred()) SWIG_fail;
27549 }
27550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27551 return resultobj;
27552 fail:
27553 return NULL;
27554 }
27555
27556
27557 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27558 int argc;
27559 PyObject *argv[3];
27560
27561 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27562 --argc;
27563 if (argc == 2) {
27564 int _v = 0;
27565 {
27566 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27567 _v = SWIG_CheckState(res);
27568 }
27569 if (!_v) goto check_1;
27570 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27571 }
27572 check_1:
27573
27574 if (argc == 2) {
27575 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27576 }
27577
27578 fail:
27579 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27580 return NULL;
27581 }
27582
27583
27584 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27585 PyObject *resultobj = 0;
27586 wxDateTime *arg1 = (wxDateTime *) 0 ;
27587 wxTimeSpan *arg2 = 0 ;
27588 wxDateTime result;
27589 void *argp1 = 0 ;
27590 int res1 = 0 ;
27591 void *argp2 = 0 ;
27592 int res2 = 0 ;
27593
27594 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27596 if (!SWIG_IsOK(res1)) {
27597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27598 }
27599 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27600 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27601 if (!SWIG_IsOK(res2)) {
27602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27603 }
27604 if (!argp2) {
27605 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27606 }
27607 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27608 {
27609 PyThreadState* __tstate = wxPyBeginAllowThreads();
27610 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27611 wxPyEndAllowThreads(__tstate);
27612 if (PyErr_Occurred()) SWIG_fail;
27613 }
27614 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27615 return resultobj;
27616 fail:
27617 return NULL;
27618 }
27619
27620
27621 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27622 PyObject *resultobj = 0;
27623 wxDateTime *arg1 = (wxDateTime *) 0 ;
27624 wxDateSpan *arg2 = 0 ;
27625 wxDateTime result;
27626 void *argp1 = 0 ;
27627 int res1 = 0 ;
27628 void *argp2 = 0 ;
27629 int res2 = 0 ;
27630
27631 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27633 if (!SWIG_IsOK(res1)) {
27634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27635 }
27636 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27637 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27638 if (!SWIG_IsOK(res2)) {
27639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27640 }
27641 if (!argp2) {
27642 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27643 }
27644 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27645 {
27646 PyThreadState* __tstate = wxPyBeginAllowThreads();
27647 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27648 wxPyEndAllowThreads(__tstate);
27649 if (PyErr_Occurred()) SWIG_fail;
27650 }
27651 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27652 return resultobj;
27653 fail:
27654 return NULL;
27655 }
27656
27657
27658 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27659 int argc;
27660 PyObject *argv[3];
27661
27662 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27663 --argc;
27664 if (argc == 2) {
27665 int _v = 0;
27666 {
27667 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27668 _v = SWIG_CheckState(res);
27669 }
27670 if (!_v) goto check_1;
27671 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27672 }
27673 check_1:
27674
27675 if (argc == 2) {
27676 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27677 }
27678
27679 fail:
27680 Py_INCREF(Py_NotImplemented);
27681 return Py_NotImplemented;
27682 }
27683
27684
27685 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27686 PyObject *resultobj = 0;
27687 wxDateTime *arg1 = (wxDateTime *) 0 ;
27688 wxDateTime *arg2 = 0 ;
27689 wxTimeSpan result;
27690 void *argp1 = 0 ;
27691 int res1 = 0 ;
27692 void *argp2 = 0 ;
27693 int res2 = 0 ;
27694
27695 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27697 if (!SWIG_IsOK(res1)) {
27698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27699 }
27700 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27701 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27702 if (!SWIG_IsOK(res2)) {
27703 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27704 }
27705 if (!argp2) {
27706 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27707 }
27708 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27709 {
27710 PyThreadState* __tstate = wxPyBeginAllowThreads();
27711 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27712 wxPyEndAllowThreads(__tstate);
27713 if (PyErr_Occurred()) SWIG_fail;
27714 }
27715 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27716 return resultobj;
27717 fail:
27718 return NULL;
27719 }
27720
27721
27722 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27723 PyObject *resultobj = 0;
27724 wxDateTime *arg1 = (wxDateTime *) 0 ;
27725 wxTimeSpan *arg2 = 0 ;
27726 wxDateTime result;
27727 void *argp1 = 0 ;
27728 int res1 = 0 ;
27729 void *argp2 = 0 ;
27730 int res2 = 0 ;
27731
27732 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27734 if (!SWIG_IsOK(res1)) {
27735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27736 }
27737 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27738 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27739 if (!SWIG_IsOK(res2)) {
27740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27741 }
27742 if (!argp2) {
27743 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27744 }
27745 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27746 {
27747 PyThreadState* __tstate = wxPyBeginAllowThreads();
27748 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27749 wxPyEndAllowThreads(__tstate);
27750 if (PyErr_Occurred()) SWIG_fail;
27751 }
27752 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27753 return resultobj;
27754 fail:
27755 return NULL;
27756 }
27757
27758
27759 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27760 PyObject *resultobj = 0;
27761 wxDateTime *arg1 = (wxDateTime *) 0 ;
27762 wxDateSpan *arg2 = 0 ;
27763 wxDateTime result;
27764 void *argp1 = 0 ;
27765 int res1 = 0 ;
27766 void *argp2 = 0 ;
27767 int res2 = 0 ;
27768
27769 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27771 if (!SWIG_IsOK(res1)) {
27772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27773 }
27774 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27775 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27776 if (!SWIG_IsOK(res2)) {
27777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27778 }
27779 if (!argp2) {
27780 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27781 }
27782 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27783 {
27784 PyThreadState* __tstate = wxPyBeginAllowThreads();
27785 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27786 wxPyEndAllowThreads(__tstate);
27787 if (PyErr_Occurred()) SWIG_fail;
27788 }
27789 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27790 return resultobj;
27791 fail:
27792 return NULL;
27793 }
27794
27795
27796 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27797 int argc;
27798 PyObject *argv[3];
27799
27800 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27801 --argc;
27802 if (argc == 2) {
27803 int _v = 0;
27804 {
27805 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27806 _v = SWIG_CheckState(res);
27807 }
27808 if (!_v) goto check_1;
27809 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27810 }
27811 check_1:
27812
27813 if (argc == 2) {
27814 int _v = 0;
27815 {
27816 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27817 _v = SWIG_CheckState(res);
27818 }
27819 if (!_v) goto check_2;
27820 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27821 }
27822 check_2:
27823
27824 if (argc == 2) {
27825 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27826 }
27827
27828 fail:
27829 Py_INCREF(Py_NotImplemented);
27830 return Py_NotImplemented;
27831 }
27832
27833
27834 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27835 PyObject *resultobj = 0;
27836 wxDateTime *arg1 = (wxDateTime *) 0 ;
27837 wxDateTime *arg2 = (wxDateTime *) 0 ;
27838 bool result;
27839 void *argp1 = 0 ;
27840 int res1 = 0 ;
27841 void *argp2 = 0 ;
27842 int res2 = 0 ;
27843 PyObject * obj0 = 0 ;
27844 PyObject * obj1 = 0 ;
27845 char * kwnames[] = {
27846 (char *) "self",(char *) "other", NULL
27847 };
27848
27849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27851 if (!SWIG_IsOK(res1)) {
27852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27853 }
27854 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27855 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27856 if (!SWIG_IsOK(res2)) {
27857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27858 }
27859 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27860 {
27861 PyThreadState* __tstate = wxPyBeginAllowThreads();
27862 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27863 wxPyEndAllowThreads(__tstate);
27864 if (PyErr_Occurred()) SWIG_fail;
27865 }
27866 {
27867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27868 }
27869 return resultobj;
27870 fail:
27871 return NULL;
27872 }
27873
27874
27875 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27876 PyObject *resultobj = 0;
27877 wxDateTime *arg1 = (wxDateTime *) 0 ;
27878 wxDateTime *arg2 = (wxDateTime *) 0 ;
27879 bool result;
27880 void *argp1 = 0 ;
27881 int res1 = 0 ;
27882 void *argp2 = 0 ;
27883 int res2 = 0 ;
27884 PyObject * obj0 = 0 ;
27885 PyObject * obj1 = 0 ;
27886 char * kwnames[] = {
27887 (char *) "self",(char *) "other", NULL
27888 };
27889
27890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27892 if (!SWIG_IsOK(res1)) {
27893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27894 }
27895 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27896 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27897 if (!SWIG_IsOK(res2)) {
27898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27899 }
27900 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27901 {
27902 PyThreadState* __tstate = wxPyBeginAllowThreads();
27903 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27904 wxPyEndAllowThreads(__tstate);
27905 if (PyErr_Occurred()) SWIG_fail;
27906 }
27907 {
27908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27909 }
27910 return resultobj;
27911 fail:
27912 return NULL;
27913 }
27914
27915
27916 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27917 PyObject *resultobj = 0;
27918 wxDateTime *arg1 = (wxDateTime *) 0 ;
27919 wxDateTime *arg2 = (wxDateTime *) 0 ;
27920 bool result;
27921 void *argp1 = 0 ;
27922 int res1 = 0 ;
27923 void *argp2 = 0 ;
27924 int res2 = 0 ;
27925 PyObject * obj0 = 0 ;
27926 PyObject * obj1 = 0 ;
27927 char * kwnames[] = {
27928 (char *) "self",(char *) "other", NULL
27929 };
27930
27931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
27932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27933 if (!SWIG_IsOK(res1)) {
27934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27935 }
27936 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27937 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27938 if (!SWIG_IsOK(res2)) {
27939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27940 }
27941 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27942 {
27943 PyThreadState* __tstate = wxPyBeginAllowThreads();
27944 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
27945 wxPyEndAllowThreads(__tstate);
27946 if (PyErr_Occurred()) SWIG_fail;
27947 }
27948 {
27949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27950 }
27951 return resultobj;
27952 fail:
27953 return NULL;
27954 }
27955
27956
27957 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27958 PyObject *resultobj = 0;
27959 wxDateTime *arg1 = (wxDateTime *) 0 ;
27960 wxDateTime *arg2 = (wxDateTime *) 0 ;
27961 bool result;
27962 void *argp1 = 0 ;
27963 int res1 = 0 ;
27964 void *argp2 = 0 ;
27965 int res2 = 0 ;
27966 PyObject * obj0 = 0 ;
27967 PyObject * obj1 = 0 ;
27968 char * kwnames[] = {
27969 (char *) "self",(char *) "other", NULL
27970 };
27971
27972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
27973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27974 if (!SWIG_IsOK(res1)) {
27975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27976 }
27977 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27978 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27979 if (!SWIG_IsOK(res2)) {
27980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27981 }
27982 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27983 {
27984 PyThreadState* __tstate = wxPyBeginAllowThreads();
27985 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
27986 wxPyEndAllowThreads(__tstate);
27987 if (PyErr_Occurred()) SWIG_fail;
27988 }
27989 {
27990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27991 }
27992 return resultobj;
27993 fail:
27994 return NULL;
27995 }
27996
27997
27998 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27999 PyObject *resultobj = 0;
28000 wxDateTime *arg1 = (wxDateTime *) 0 ;
28001 wxDateTime *arg2 = (wxDateTime *) 0 ;
28002 bool result;
28003 void *argp1 = 0 ;
28004 int res1 = 0 ;
28005 void *argp2 = 0 ;
28006 int res2 = 0 ;
28007 PyObject * obj0 = 0 ;
28008 PyObject * obj1 = 0 ;
28009 char * kwnames[] = {
28010 (char *) "self",(char *) "other", NULL
28011 };
28012
28013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28015 if (!SWIG_IsOK(res1)) {
28016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28017 }
28018 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28019 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28020 if (!SWIG_IsOK(res2)) {
28021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28022 }
28023 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28024 {
28025 PyThreadState* __tstate = wxPyBeginAllowThreads();
28026 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28027 wxPyEndAllowThreads(__tstate);
28028 if (PyErr_Occurred()) SWIG_fail;
28029 }
28030 {
28031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28032 }
28033 return resultobj;
28034 fail:
28035 return NULL;
28036 }
28037
28038
28039 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28040 PyObject *resultobj = 0;
28041 wxDateTime *arg1 = (wxDateTime *) 0 ;
28042 wxDateTime *arg2 = (wxDateTime *) 0 ;
28043 bool result;
28044 void *argp1 = 0 ;
28045 int res1 = 0 ;
28046 void *argp2 = 0 ;
28047 int res2 = 0 ;
28048 PyObject * obj0 = 0 ;
28049 PyObject * obj1 = 0 ;
28050 char * kwnames[] = {
28051 (char *) "self",(char *) "other", NULL
28052 };
28053
28054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28056 if (!SWIG_IsOK(res1)) {
28057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28058 }
28059 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28060 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28061 if (!SWIG_IsOK(res2)) {
28062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28063 }
28064 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28065 {
28066 PyThreadState* __tstate = wxPyBeginAllowThreads();
28067 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28068 wxPyEndAllowThreads(__tstate);
28069 if (PyErr_Occurred()) SWIG_fail;
28070 }
28071 {
28072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28073 }
28074 return resultobj;
28075 fail:
28076 return NULL;
28077 }
28078
28079
28080 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28081 PyObject *resultobj = 0;
28082 wxDateTime *arg1 = (wxDateTime *) 0 ;
28083 wxString *arg2 = 0 ;
28084 int result;
28085 void *argp1 = 0 ;
28086 int res1 = 0 ;
28087 bool temp2 = false ;
28088 PyObject * obj0 = 0 ;
28089 PyObject * obj1 = 0 ;
28090 char * kwnames[] = {
28091 (char *) "self",(char *) "date", NULL
28092 };
28093
28094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28096 if (!SWIG_IsOK(res1)) {
28097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28098 }
28099 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28100 {
28101 arg2 = wxString_in_helper(obj1);
28102 if (arg2 == NULL) SWIG_fail;
28103 temp2 = true;
28104 }
28105 {
28106 PyThreadState* __tstate = wxPyBeginAllowThreads();
28107 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28108 wxPyEndAllowThreads(__tstate);
28109 if (PyErr_Occurred()) SWIG_fail;
28110 }
28111 resultobj = SWIG_From_int(static_cast< int >(result));
28112 {
28113 if (temp2)
28114 delete arg2;
28115 }
28116 return resultobj;
28117 fail:
28118 {
28119 if (temp2)
28120 delete arg2;
28121 }
28122 return NULL;
28123 }
28124
28125
28126 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28127 PyObject *resultobj = 0;
28128 wxDateTime *arg1 = (wxDateTime *) 0 ;
28129 wxString *arg2 = 0 ;
28130 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28131 wxString *arg3 = (wxString *) &arg3_defvalue ;
28132 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28133 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28134 int result;
28135 void *argp1 = 0 ;
28136 int res1 = 0 ;
28137 bool temp2 = false ;
28138 bool temp3 = false ;
28139 void *argp4 = 0 ;
28140 int res4 = 0 ;
28141 PyObject * obj0 = 0 ;
28142 PyObject * obj1 = 0 ;
28143 PyObject * obj2 = 0 ;
28144 PyObject * obj3 = 0 ;
28145 char * kwnames[] = {
28146 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28147 };
28148
28149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28151 if (!SWIG_IsOK(res1)) {
28152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28153 }
28154 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28155 {
28156 arg2 = wxString_in_helper(obj1);
28157 if (arg2 == NULL) SWIG_fail;
28158 temp2 = true;
28159 }
28160 if (obj2) {
28161 {
28162 arg3 = wxString_in_helper(obj2);
28163 if (arg3 == NULL) SWIG_fail;
28164 temp3 = true;
28165 }
28166 }
28167 if (obj3) {
28168 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28169 if (!SWIG_IsOK(res4)) {
28170 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28171 }
28172 if (!argp4) {
28173 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28174 }
28175 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28176 }
28177 {
28178 PyThreadState* __tstate = wxPyBeginAllowThreads();
28179 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28180 wxPyEndAllowThreads(__tstate);
28181 if (PyErr_Occurred()) SWIG_fail;
28182 }
28183 resultobj = SWIG_From_int(static_cast< int >(result));
28184 {
28185 if (temp2)
28186 delete arg2;
28187 }
28188 {
28189 if (temp3)
28190 delete arg3;
28191 }
28192 return resultobj;
28193 fail:
28194 {
28195 if (temp2)
28196 delete arg2;
28197 }
28198 {
28199 if (temp3)
28200 delete arg3;
28201 }
28202 return NULL;
28203 }
28204
28205
28206 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28207 PyObject *resultobj = 0;
28208 wxDateTime *arg1 = (wxDateTime *) 0 ;
28209 wxString *arg2 = 0 ;
28210 int result;
28211 void *argp1 = 0 ;
28212 int res1 = 0 ;
28213 bool temp2 = false ;
28214 PyObject * obj0 = 0 ;
28215 PyObject * obj1 = 0 ;
28216 char * kwnames[] = {
28217 (char *) "self",(char *) "datetime", NULL
28218 };
28219
28220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28222 if (!SWIG_IsOK(res1)) {
28223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28224 }
28225 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28226 {
28227 arg2 = wxString_in_helper(obj1);
28228 if (arg2 == NULL) SWIG_fail;
28229 temp2 = true;
28230 }
28231 {
28232 PyThreadState* __tstate = wxPyBeginAllowThreads();
28233 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28234 wxPyEndAllowThreads(__tstate);
28235 if (PyErr_Occurred()) SWIG_fail;
28236 }
28237 resultobj = SWIG_From_int(static_cast< int >(result));
28238 {
28239 if (temp2)
28240 delete arg2;
28241 }
28242 return resultobj;
28243 fail:
28244 {
28245 if (temp2)
28246 delete arg2;
28247 }
28248 return NULL;
28249 }
28250
28251
28252 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28253 PyObject *resultobj = 0;
28254 wxDateTime *arg1 = (wxDateTime *) 0 ;
28255 wxString *arg2 = 0 ;
28256 int result;
28257 void *argp1 = 0 ;
28258 int res1 = 0 ;
28259 bool temp2 = false ;
28260 PyObject * obj0 = 0 ;
28261 PyObject * obj1 = 0 ;
28262 char * kwnames[] = {
28263 (char *) "self",(char *) "date", NULL
28264 };
28265
28266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28268 if (!SWIG_IsOK(res1)) {
28269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28270 }
28271 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28272 {
28273 arg2 = wxString_in_helper(obj1);
28274 if (arg2 == NULL) SWIG_fail;
28275 temp2 = true;
28276 }
28277 {
28278 PyThreadState* __tstate = wxPyBeginAllowThreads();
28279 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28280 wxPyEndAllowThreads(__tstate);
28281 if (PyErr_Occurred()) SWIG_fail;
28282 }
28283 resultobj = SWIG_From_int(static_cast< int >(result));
28284 {
28285 if (temp2)
28286 delete arg2;
28287 }
28288 return resultobj;
28289 fail:
28290 {
28291 if (temp2)
28292 delete arg2;
28293 }
28294 return NULL;
28295 }
28296
28297
28298 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28299 PyObject *resultobj = 0;
28300 wxDateTime *arg1 = (wxDateTime *) 0 ;
28301 wxString *arg2 = 0 ;
28302 int result;
28303 void *argp1 = 0 ;
28304 int res1 = 0 ;
28305 bool temp2 = false ;
28306 PyObject * obj0 = 0 ;
28307 PyObject * obj1 = 0 ;
28308 char * kwnames[] = {
28309 (char *) "self",(char *) "time", NULL
28310 };
28311
28312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28314 if (!SWIG_IsOK(res1)) {
28315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28316 }
28317 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28318 {
28319 arg2 = wxString_in_helper(obj1);
28320 if (arg2 == NULL) SWIG_fail;
28321 temp2 = true;
28322 }
28323 {
28324 PyThreadState* __tstate = wxPyBeginAllowThreads();
28325 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28326 wxPyEndAllowThreads(__tstate);
28327 if (PyErr_Occurred()) SWIG_fail;
28328 }
28329 resultobj = SWIG_From_int(static_cast< int >(result));
28330 {
28331 if (temp2)
28332 delete arg2;
28333 }
28334 return resultobj;
28335 fail:
28336 {
28337 if (temp2)
28338 delete arg2;
28339 }
28340 return NULL;
28341 }
28342
28343
28344 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28345 PyObject *resultobj = 0;
28346 wxDateTime *arg1 = (wxDateTime *) 0 ;
28347 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28348 wxString *arg2 = (wxString *) &arg2_defvalue ;
28349 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28350 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28351 wxString result;
28352 void *argp1 = 0 ;
28353 int res1 = 0 ;
28354 bool temp2 = false ;
28355 bool temp3 = false ;
28356 PyObject * obj0 = 0 ;
28357 PyObject * obj1 = 0 ;
28358 PyObject * obj2 = 0 ;
28359 char * kwnames[] = {
28360 (char *) "self",(char *) "format",(char *) "tz", NULL
28361 };
28362
28363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28365 if (!SWIG_IsOK(res1)) {
28366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28367 }
28368 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28369 if (obj1) {
28370 {
28371 arg2 = wxString_in_helper(obj1);
28372 if (arg2 == NULL) SWIG_fail;
28373 temp2 = true;
28374 }
28375 }
28376 if (obj2) {
28377 {
28378 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28379 temp3 = true;
28380 }
28381 }
28382 {
28383 PyThreadState* __tstate = wxPyBeginAllowThreads();
28384 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28385 wxPyEndAllowThreads(__tstate);
28386 if (PyErr_Occurred()) SWIG_fail;
28387 }
28388 {
28389 #if wxUSE_UNICODE
28390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28391 #else
28392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28393 #endif
28394 }
28395 {
28396 if (temp2)
28397 delete arg2;
28398 }
28399 {
28400 if (temp3) delete arg3;
28401 }
28402 return resultobj;
28403 fail:
28404 {
28405 if (temp2)
28406 delete arg2;
28407 }
28408 {
28409 if (temp3) delete arg3;
28410 }
28411 return NULL;
28412 }
28413
28414
28415 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28416 PyObject *resultobj = 0;
28417 wxDateTime *arg1 = (wxDateTime *) 0 ;
28418 wxString result;
28419 void *argp1 = 0 ;
28420 int res1 = 0 ;
28421 PyObject *swig_obj[1] ;
28422
28423 if (!args) SWIG_fail;
28424 swig_obj[0] = args;
28425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28426 if (!SWIG_IsOK(res1)) {
28427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28428 }
28429 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28430 {
28431 PyThreadState* __tstate = wxPyBeginAllowThreads();
28432 result = ((wxDateTime const *)arg1)->FormatDate();
28433 wxPyEndAllowThreads(__tstate);
28434 if (PyErr_Occurred()) SWIG_fail;
28435 }
28436 {
28437 #if wxUSE_UNICODE
28438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28439 #else
28440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28441 #endif
28442 }
28443 return resultobj;
28444 fail:
28445 return NULL;
28446 }
28447
28448
28449 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28450 PyObject *resultobj = 0;
28451 wxDateTime *arg1 = (wxDateTime *) 0 ;
28452 wxString result;
28453 void *argp1 = 0 ;
28454 int res1 = 0 ;
28455 PyObject *swig_obj[1] ;
28456
28457 if (!args) SWIG_fail;
28458 swig_obj[0] = args;
28459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28460 if (!SWIG_IsOK(res1)) {
28461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28462 }
28463 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28464 {
28465 PyThreadState* __tstate = wxPyBeginAllowThreads();
28466 result = ((wxDateTime const *)arg1)->FormatTime();
28467 wxPyEndAllowThreads(__tstate);
28468 if (PyErr_Occurred()) SWIG_fail;
28469 }
28470 {
28471 #if wxUSE_UNICODE
28472 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28473 #else
28474 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28475 #endif
28476 }
28477 return resultobj;
28478 fail:
28479 return NULL;
28480 }
28481
28482
28483 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28484 PyObject *resultobj = 0;
28485 wxDateTime *arg1 = (wxDateTime *) 0 ;
28486 wxString result;
28487 void *argp1 = 0 ;
28488 int res1 = 0 ;
28489 PyObject *swig_obj[1] ;
28490
28491 if (!args) SWIG_fail;
28492 swig_obj[0] = args;
28493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28494 if (!SWIG_IsOK(res1)) {
28495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28496 }
28497 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28498 {
28499 PyThreadState* __tstate = wxPyBeginAllowThreads();
28500 result = ((wxDateTime const *)arg1)->FormatISODate();
28501 wxPyEndAllowThreads(__tstate);
28502 if (PyErr_Occurred()) SWIG_fail;
28503 }
28504 {
28505 #if wxUSE_UNICODE
28506 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28507 #else
28508 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28509 #endif
28510 }
28511 return resultobj;
28512 fail:
28513 return NULL;
28514 }
28515
28516
28517 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28518 PyObject *resultobj = 0;
28519 wxDateTime *arg1 = (wxDateTime *) 0 ;
28520 wxString result;
28521 void *argp1 = 0 ;
28522 int res1 = 0 ;
28523 PyObject *swig_obj[1] ;
28524
28525 if (!args) SWIG_fail;
28526 swig_obj[0] = args;
28527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28528 if (!SWIG_IsOK(res1)) {
28529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28530 }
28531 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28532 {
28533 PyThreadState* __tstate = wxPyBeginAllowThreads();
28534 result = ((wxDateTime const *)arg1)->FormatISOTime();
28535 wxPyEndAllowThreads(__tstate);
28536 if (PyErr_Occurred()) SWIG_fail;
28537 }
28538 {
28539 #if wxUSE_UNICODE
28540 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28541 #else
28542 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28543 #endif
28544 }
28545 return resultobj;
28546 fail:
28547 return NULL;
28548 }
28549
28550
28551 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28552 PyObject *obj;
28553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28554 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28555 return SWIG_Py_Void();
28556 }
28557
28558 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28559 return SWIG_Python_InitShadowInstance(args);
28560 }
28561
28562 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28563 PyObject *resultobj = 0;
28564 long arg1 ;
28565 wxTimeSpan result;
28566 long val1 ;
28567 int ecode1 = 0 ;
28568 PyObject * obj0 = 0 ;
28569 char * kwnames[] = {
28570 (char *) "ms", NULL
28571 };
28572
28573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28574 ecode1 = SWIG_AsVal_long(obj0, &val1);
28575 if (!SWIG_IsOK(ecode1)) {
28576 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28577 }
28578 arg1 = static_cast< long >(val1);
28579 {
28580 PyThreadState* __tstate = wxPyBeginAllowThreads();
28581 result = wxTimeSpan::Milliseconds(arg1);
28582 wxPyEndAllowThreads(__tstate);
28583 if (PyErr_Occurred()) SWIG_fail;
28584 }
28585 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28586 return resultobj;
28587 fail:
28588 return NULL;
28589 }
28590
28591
28592 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28593 PyObject *resultobj = 0;
28594 wxTimeSpan result;
28595
28596 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28597 {
28598 PyThreadState* __tstate = wxPyBeginAllowThreads();
28599 result = wxTimeSpan::Millisecond();
28600 wxPyEndAllowThreads(__tstate);
28601 if (PyErr_Occurred()) SWIG_fail;
28602 }
28603 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28604 return resultobj;
28605 fail:
28606 return NULL;
28607 }
28608
28609
28610 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28611 PyObject *resultobj = 0;
28612 long arg1 ;
28613 wxTimeSpan result;
28614 long val1 ;
28615 int ecode1 = 0 ;
28616 PyObject * obj0 = 0 ;
28617 char * kwnames[] = {
28618 (char *) "sec", NULL
28619 };
28620
28621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28622 ecode1 = SWIG_AsVal_long(obj0, &val1);
28623 if (!SWIG_IsOK(ecode1)) {
28624 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28625 }
28626 arg1 = static_cast< long >(val1);
28627 {
28628 PyThreadState* __tstate = wxPyBeginAllowThreads();
28629 result = wxTimeSpan::Seconds(arg1);
28630 wxPyEndAllowThreads(__tstate);
28631 if (PyErr_Occurred()) SWIG_fail;
28632 }
28633 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28634 return resultobj;
28635 fail:
28636 return NULL;
28637 }
28638
28639
28640 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28641 PyObject *resultobj = 0;
28642 wxTimeSpan result;
28643
28644 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28645 {
28646 PyThreadState* __tstate = wxPyBeginAllowThreads();
28647 result = wxTimeSpan::Second();
28648 wxPyEndAllowThreads(__tstate);
28649 if (PyErr_Occurred()) SWIG_fail;
28650 }
28651 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28652 return resultobj;
28653 fail:
28654 return NULL;
28655 }
28656
28657
28658 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(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 *) "min", NULL
28667 };
28668
28669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",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_Minutes" "', expected argument " "1"" of type '" "long""'");
28673 }
28674 arg1 = static_cast< long >(val1);
28675 {
28676 PyThreadState* __tstate = wxPyBeginAllowThreads();
28677 result = wxTimeSpan::Minutes(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_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28689 PyObject *resultobj = 0;
28690 wxTimeSpan result;
28691
28692 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28693 {
28694 PyThreadState* __tstate = wxPyBeginAllowThreads();
28695 result = wxTimeSpan::Minute();
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_Hours(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 *) "hours", NULL
28715 };
28716
28717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",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_Hours" "', expected argument " "1"" of type '" "long""'");
28721 }
28722 arg1 = static_cast< long >(val1);
28723 {
28724 PyThreadState* __tstate = wxPyBeginAllowThreads();
28725 result = wxTimeSpan::Hours(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_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28737 PyObject *resultobj = 0;
28738 wxTimeSpan result;
28739
28740 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28741 {
28742 PyThreadState* __tstate = wxPyBeginAllowThreads();
28743 result = wxTimeSpan::Hour();
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_Days(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 *) "days", NULL
28763 };
28764
28765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",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_Days" "', expected argument " "1"" of type '" "long""'");
28769 }
28770 arg1 = static_cast< long >(val1);
28771 {
28772 PyThreadState* __tstate = wxPyBeginAllowThreads();
28773 result = wxTimeSpan::Days(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_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28785 PyObject *resultobj = 0;
28786 wxTimeSpan result;
28787
28788 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28789 {
28790 PyThreadState* __tstate = wxPyBeginAllowThreads();
28791 result = wxTimeSpan::Day();
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_Weeks(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 *) "days", NULL
28811 };
28812
28813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",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_Weeks" "', expected argument " "1"" of type '" "long""'");
28817 }
28818 arg1 = static_cast< long >(val1);
28819 {
28820 PyThreadState* __tstate = wxPyBeginAllowThreads();
28821 result = wxTimeSpan::Weeks(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_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28833 PyObject *resultobj = 0;
28834 wxTimeSpan result;
28835
28836 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28837 {
28838 PyThreadState* __tstate = wxPyBeginAllowThreads();
28839 result = wxTimeSpan::Week();
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_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28851 PyObject *resultobj = 0;
28852 long arg1 = (long) 0 ;
28853 long arg2 = (long) 0 ;
28854 long arg3 = (long) 0 ;
28855 long arg4 = (long) 0 ;
28856 wxTimeSpan *result = 0 ;
28857 long val1 ;
28858 int ecode1 = 0 ;
28859 long val2 ;
28860 int ecode2 = 0 ;
28861 long val3 ;
28862 int ecode3 = 0 ;
28863 long val4 ;
28864 int ecode4 = 0 ;
28865 PyObject * obj0 = 0 ;
28866 PyObject * obj1 = 0 ;
28867 PyObject * obj2 = 0 ;
28868 PyObject * obj3 = 0 ;
28869 char * kwnames[] = {
28870 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28871 };
28872
28873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28874 if (obj0) {
28875 ecode1 = SWIG_AsVal_long(obj0, &val1);
28876 if (!SWIG_IsOK(ecode1)) {
28877 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28878 }
28879 arg1 = static_cast< long >(val1);
28880 }
28881 if (obj1) {
28882 ecode2 = SWIG_AsVal_long(obj1, &val2);
28883 if (!SWIG_IsOK(ecode2)) {
28884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28885 }
28886 arg2 = static_cast< long >(val2);
28887 }
28888 if (obj2) {
28889 ecode3 = SWIG_AsVal_long(obj2, &val3);
28890 if (!SWIG_IsOK(ecode3)) {
28891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28892 }
28893 arg3 = static_cast< long >(val3);
28894 }
28895 if (obj3) {
28896 ecode4 = SWIG_AsVal_long(obj3, &val4);
28897 if (!SWIG_IsOK(ecode4)) {
28898 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28899 }
28900 arg4 = static_cast< long >(val4);
28901 }
28902 {
28903 PyThreadState* __tstate = wxPyBeginAllowThreads();
28904 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28905 wxPyEndAllowThreads(__tstate);
28906 if (PyErr_Occurred()) SWIG_fail;
28907 }
28908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28909 return resultobj;
28910 fail:
28911 return NULL;
28912 }
28913
28914
28915 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28916 PyObject *resultobj = 0;
28917 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28918 void *argp1 = 0 ;
28919 int res1 = 0 ;
28920 PyObject *swig_obj[1] ;
28921
28922 if (!args) SWIG_fail;
28923 swig_obj[0] = args;
28924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28925 if (!SWIG_IsOK(res1)) {
28926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28927 }
28928 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28929 {
28930 PyThreadState* __tstate = wxPyBeginAllowThreads();
28931 delete arg1;
28932
28933 wxPyEndAllowThreads(__tstate);
28934 if (PyErr_Occurred()) SWIG_fail;
28935 }
28936 resultobj = SWIG_Py_Void();
28937 return resultobj;
28938 fail:
28939 return NULL;
28940 }
28941
28942
28943 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28944 PyObject *resultobj = 0;
28945 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28946 wxTimeSpan *arg2 = 0 ;
28947 wxTimeSpan *result = 0 ;
28948 void *argp1 = 0 ;
28949 int res1 = 0 ;
28950 void *argp2 = 0 ;
28951 int res2 = 0 ;
28952 PyObject * obj0 = 0 ;
28953 PyObject * obj1 = 0 ;
28954 char * kwnames[] = {
28955 (char *) "self",(char *) "diff", NULL
28956 };
28957
28958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
28959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28960 if (!SWIG_IsOK(res1)) {
28961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28962 }
28963 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28964 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28965 if (!SWIG_IsOK(res2)) {
28966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28967 }
28968 if (!argp2) {
28969 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28970 }
28971 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28972 {
28973 PyThreadState* __tstate = wxPyBeginAllowThreads();
28974 {
28975 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
28976 result = (wxTimeSpan *) &_result_ref;
28977 }
28978 wxPyEndAllowThreads(__tstate);
28979 if (PyErr_Occurred()) SWIG_fail;
28980 }
28981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28982 return resultobj;
28983 fail:
28984 return NULL;
28985 }
28986
28987
28988 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28989 PyObject *resultobj = 0;
28990 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28991 wxTimeSpan *arg2 = 0 ;
28992 wxTimeSpan *result = 0 ;
28993 void *argp1 = 0 ;
28994 int res1 = 0 ;
28995 void *argp2 = 0 ;
28996 int res2 = 0 ;
28997 PyObject * obj0 = 0 ;
28998 PyObject * obj1 = 0 ;
28999 char * kwnames[] = {
29000 (char *) "self",(char *) "diff", NULL
29001 };
29002
29003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29005 if (!SWIG_IsOK(res1)) {
29006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29007 }
29008 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29009 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29010 if (!SWIG_IsOK(res2)) {
29011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29012 }
29013 if (!argp2) {
29014 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29015 }
29016 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29017 {
29018 PyThreadState* __tstate = wxPyBeginAllowThreads();
29019 {
29020 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29021 result = (wxTimeSpan *) &_result_ref;
29022 }
29023 wxPyEndAllowThreads(__tstate);
29024 if (PyErr_Occurred()) SWIG_fail;
29025 }
29026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29027 return resultobj;
29028 fail:
29029 return NULL;
29030 }
29031
29032
29033 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29034 PyObject *resultobj = 0;
29035 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29036 int arg2 ;
29037 wxTimeSpan *result = 0 ;
29038 void *argp1 = 0 ;
29039 int res1 = 0 ;
29040 int val2 ;
29041 int ecode2 = 0 ;
29042 PyObject * obj0 = 0 ;
29043 PyObject * obj1 = 0 ;
29044 char * kwnames[] = {
29045 (char *) "self",(char *) "n", NULL
29046 };
29047
29048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29050 if (!SWIG_IsOK(res1)) {
29051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29052 }
29053 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29054 ecode2 = SWIG_AsVal_int(obj1, &val2);
29055 if (!SWIG_IsOK(ecode2)) {
29056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29057 }
29058 arg2 = static_cast< int >(val2);
29059 {
29060 PyThreadState* __tstate = wxPyBeginAllowThreads();
29061 {
29062 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29063 result = (wxTimeSpan *) &_result_ref;
29064 }
29065 wxPyEndAllowThreads(__tstate);
29066 if (PyErr_Occurred()) SWIG_fail;
29067 }
29068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29069 return resultobj;
29070 fail:
29071 return NULL;
29072 }
29073
29074
29075 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29076 PyObject *resultobj = 0;
29077 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29078 wxTimeSpan *result = 0 ;
29079 void *argp1 = 0 ;
29080 int res1 = 0 ;
29081 PyObject *swig_obj[1] ;
29082
29083 if (!args) SWIG_fail;
29084 swig_obj[0] = args;
29085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29086 if (!SWIG_IsOK(res1)) {
29087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29088 }
29089 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29090 {
29091 PyThreadState* __tstate = wxPyBeginAllowThreads();
29092 {
29093 wxTimeSpan &_result_ref = (arg1)->Neg();
29094 result = (wxTimeSpan *) &_result_ref;
29095 }
29096 wxPyEndAllowThreads(__tstate);
29097 if (PyErr_Occurred()) SWIG_fail;
29098 }
29099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29100 return resultobj;
29101 fail:
29102 return NULL;
29103 }
29104
29105
29106 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29107 PyObject *resultobj = 0;
29108 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29109 wxTimeSpan result;
29110 void *argp1 = 0 ;
29111 int res1 = 0 ;
29112 PyObject *swig_obj[1] ;
29113
29114 if (!args) SWIG_fail;
29115 swig_obj[0] = args;
29116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29117 if (!SWIG_IsOK(res1)) {
29118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29119 }
29120 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29121 {
29122 PyThreadState* __tstate = wxPyBeginAllowThreads();
29123 result = ((wxTimeSpan const *)arg1)->Abs();
29124 wxPyEndAllowThreads(__tstate);
29125 if (PyErr_Occurred()) SWIG_fail;
29126 }
29127 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29128 return resultobj;
29129 fail:
29130 return NULL;
29131 }
29132
29133
29134 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29135 PyObject *resultobj = 0;
29136 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29137 wxTimeSpan *arg2 = 0 ;
29138 wxTimeSpan *result = 0 ;
29139 void *argp1 = 0 ;
29140 int res1 = 0 ;
29141 void *argp2 = 0 ;
29142 int res2 = 0 ;
29143 PyObject * obj0 = 0 ;
29144 PyObject * obj1 = 0 ;
29145 char * kwnames[] = {
29146 (char *) "self",(char *) "diff", NULL
29147 };
29148
29149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29151 if (!SWIG_IsOK(res1)) {
29152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29153 }
29154 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29155 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29156 if (!SWIG_IsOK(res2)) {
29157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29158 }
29159 if (!argp2) {
29160 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29161 }
29162 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29163 {
29164 PyThreadState* __tstate = wxPyBeginAllowThreads();
29165 {
29166 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29167 result = (wxTimeSpan *) &_result_ref;
29168 }
29169 wxPyEndAllowThreads(__tstate);
29170 if (PyErr_Occurred()) SWIG_fail;
29171 }
29172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29173 return resultobj;
29174 fail:
29175 return NULL;
29176 }
29177
29178
29179 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29180 PyObject *resultobj = 0;
29181 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29182 wxTimeSpan *arg2 = 0 ;
29183 wxTimeSpan *result = 0 ;
29184 void *argp1 = 0 ;
29185 int res1 = 0 ;
29186 void *argp2 = 0 ;
29187 int res2 = 0 ;
29188 PyObject * obj0 = 0 ;
29189 PyObject * obj1 = 0 ;
29190 char * kwnames[] = {
29191 (char *) "self",(char *) "diff", NULL
29192 };
29193
29194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29196 if (!SWIG_IsOK(res1)) {
29197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29198 }
29199 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29200 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29201 if (!SWIG_IsOK(res2)) {
29202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29203 }
29204 if (!argp2) {
29205 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29206 }
29207 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29208 {
29209 PyThreadState* __tstate = wxPyBeginAllowThreads();
29210 {
29211 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29212 result = (wxTimeSpan *) &_result_ref;
29213 }
29214 wxPyEndAllowThreads(__tstate);
29215 if (PyErr_Occurred()) SWIG_fail;
29216 }
29217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29218 return resultobj;
29219 fail:
29220 return NULL;
29221 }
29222
29223
29224 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29225 PyObject *resultobj = 0;
29226 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29227 int arg2 ;
29228 wxTimeSpan *result = 0 ;
29229 void *argp1 = 0 ;
29230 int res1 = 0 ;
29231 int val2 ;
29232 int ecode2 = 0 ;
29233 PyObject * obj0 = 0 ;
29234 PyObject * obj1 = 0 ;
29235 char * kwnames[] = {
29236 (char *) "self",(char *) "n", NULL
29237 };
29238
29239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29241 if (!SWIG_IsOK(res1)) {
29242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29243 }
29244 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29245 ecode2 = SWIG_AsVal_int(obj1, &val2);
29246 if (!SWIG_IsOK(ecode2)) {
29247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29248 }
29249 arg2 = static_cast< int >(val2);
29250 {
29251 PyThreadState* __tstate = wxPyBeginAllowThreads();
29252 {
29253 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29254 result = (wxTimeSpan *) &_result_ref;
29255 }
29256 wxPyEndAllowThreads(__tstate);
29257 if (PyErr_Occurred()) SWIG_fail;
29258 }
29259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29260 return resultobj;
29261 fail:
29262 return NULL;
29263 }
29264
29265
29266 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29267 PyObject *resultobj = 0;
29268 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29269 wxTimeSpan *result = 0 ;
29270 void *argp1 = 0 ;
29271 int res1 = 0 ;
29272 PyObject *swig_obj[1] ;
29273
29274 if (!args) SWIG_fail;
29275 swig_obj[0] = args;
29276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29277 if (!SWIG_IsOK(res1)) {
29278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29279 }
29280 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29281 {
29282 PyThreadState* __tstate = wxPyBeginAllowThreads();
29283 {
29284 wxTimeSpan &_result_ref = (arg1)->operator -();
29285 result = (wxTimeSpan *) &_result_ref;
29286 }
29287 wxPyEndAllowThreads(__tstate);
29288 if (PyErr_Occurred()) SWIG_fail;
29289 }
29290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29291 return resultobj;
29292 fail:
29293 return NULL;
29294 }
29295
29296
29297 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29298 PyObject *resultobj = 0;
29299 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29300 wxTimeSpan *arg2 = 0 ;
29301 wxTimeSpan result;
29302 void *argp1 = 0 ;
29303 int res1 = 0 ;
29304 void *argp2 = 0 ;
29305 int res2 = 0 ;
29306 PyObject * obj0 = 0 ;
29307 PyObject * obj1 = 0 ;
29308 char * kwnames[] = {
29309 (char *) "self",(char *) "other", NULL
29310 };
29311
29312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29314 if (!SWIG_IsOK(res1)) {
29315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29316 }
29317 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29318 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29319 if (!SWIG_IsOK(res2)) {
29320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29321 }
29322 if (!argp2) {
29323 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29324 }
29325 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29326 {
29327 PyThreadState* __tstate = wxPyBeginAllowThreads();
29328 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29329 wxPyEndAllowThreads(__tstate);
29330 if (PyErr_Occurred()) SWIG_fail;
29331 }
29332 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29333 return resultobj;
29334 fail:
29335 return NULL;
29336 }
29337
29338
29339 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29340 PyObject *resultobj = 0;
29341 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29342 wxTimeSpan *arg2 = 0 ;
29343 wxTimeSpan result;
29344 void *argp1 = 0 ;
29345 int res1 = 0 ;
29346 void *argp2 = 0 ;
29347 int res2 = 0 ;
29348 PyObject * obj0 = 0 ;
29349 PyObject * obj1 = 0 ;
29350 char * kwnames[] = {
29351 (char *) "self",(char *) "other", NULL
29352 };
29353
29354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29356 if (!SWIG_IsOK(res1)) {
29357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29358 }
29359 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29360 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29361 if (!SWIG_IsOK(res2)) {
29362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29363 }
29364 if (!argp2) {
29365 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29366 }
29367 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29368 {
29369 PyThreadState* __tstate = wxPyBeginAllowThreads();
29370 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29371 wxPyEndAllowThreads(__tstate);
29372 if (PyErr_Occurred()) SWIG_fail;
29373 }
29374 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29375 return resultobj;
29376 fail:
29377 return NULL;
29378 }
29379
29380
29381 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29382 PyObject *resultobj = 0;
29383 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29384 int arg2 ;
29385 wxTimeSpan result;
29386 void *argp1 = 0 ;
29387 int res1 = 0 ;
29388 int val2 ;
29389 int ecode2 = 0 ;
29390 PyObject * obj0 = 0 ;
29391 PyObject * obj1 = 0 ;
29392 char * kwnames[] = {
29393 (char *) "self",(char *) "n", NULL
29394 };
29395
29396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29398 if (!SWIG_IsOK(res1)) {
29399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29400 }
29401 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29402 ecode2 = SWIG_AsVal_int(obj1, &val2);
29403 if (!SWIG_IsOK(ecode2)) {
29404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29405 }
29406 arg2 = static_cast< int >(val2);
29407 {
29408 PyThreadState* __tstate = wxPyBeginAllowThreads();
29409 result = wxTimeSpan___mul__(arg1,arg2);
29410 wxPyEndAllowThreads(__tstate);
29411 if (PyErr_Occurred()) SWIG_fail;
29412 }
29413 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29414 return resultobj;
29415 fail:
29416 return NULL;
29417 }
29418
29419
29420 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29421 PyObject *resultobj = 0;
29422 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29423 int arg2 ;
29424 wxTimeSpan result;
29425 void *argp1 = 0 ;
29426 int res1 = 0 ;
29427 int val2 ;
29428 int ecode2 = 0 ;
29429 PyObject * obj0 = 0 ;
29430 PyObject * obj1 = 0 ;
29431 char * kwnames[] = {
29432 (char *) "self",(char *) "n", NULL
29433 };
29434
29435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29437 if (!SWIG_IsOK(res1)) {
29438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29439 }
29440 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29441 ecode2 = SWIG_AsVal_int(obj1, &val2);
29442 if (!SWIG_IsOK(ecode2)) {
29443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29444 }
29445 arg2 = static_cast< int >(val2);
29446 {
29447 PyThreadState* __tstate = wxPyBeginAllowThreads();
29448 result = wxTimeSpan___rmul__(arg1,arg2);
29449 wxPyEndAllowThreads(__tstate);
29450 if (PyErr_Occurred()) SWIG_fail;
29451 }
29452 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29453 return resultobj;
29454 fail:
29455 return NULL;
29456 }
29457
29458
29459 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29460 PyObject *resultobj = 0;
29461 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29462 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29463 bool result;
29464 void *argp1 = 0 ;
29465 int res1 = 0 ;
29466 void *argp2 = 0 ;
29467 int res2 = 0 ;
29468 PyObject * obj0 = 0 ;
29469 PyObject * obj1 = 0 ;
29470 char * kwnames[] = {
29471 (char *) "self",(char *) "other", NULL
29472 };
29473
29474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29476 if (!SWIG_IsOK(res1)) {
29477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29478 }
29479 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29480 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29481 if (!SWIG_IsOK(res2)) {
29482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29483 }
29484 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29485 {
29486 PyThreadState* __tstate = wxPyBeginAllowThreads();
29487 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29488 wxPyEndAllowThreads(__tstate);
29489 if (PyErr_Occurred()) SWIG_fail;
29490 }
29491 {
29492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29493 }
29494 return resultobj;
29495 fail:
29496 return NULL;
29497 }
29498
29499
29500 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29501 PyObject *resultobj = 0;
29502 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29503 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29504 bool result;
29505 void *argp1 = 0 ;
29506 int res1 = 0 ;
29507 void *argp2 = 0 ;
29508 int res2 = 0 ;
29509 PyObject * obj0 = 0 ;
29510 PyObject * obj1 = 0 ;
29511 char * kwnames[] = {
29512 (char *) "self",(char *) "other", NULL
29513 };
29514
29515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29517 if (!SWIG_IsOK(res1)) {
29518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29519 }
29520 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29521 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29522 if (!SWIG_IsOK(res2)) {
29523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29524 }
29525 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29526 {
29527 PyThreadState* __tstate = wxPyBeginAllowThreads();
29528 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29529 wxPyEndAllowThreads(__tstate);
29530 if (PyErr_Occurred()) SWIG_fail;
29531 }
29532 {
29533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29534 }
29535 return resultobj;
29536 fail:
29537 return NULL;
29538 }
29539
29540
29541 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29542 PyObject *resultobj = 0;
29543 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29544 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29545 bool result;
29546 void *argp1 = 0 ;
29547 int res1 = 0 ;
29548 void *argp2 = 0 ;
29549 int res2 = 0 ;
29550 PyObject * obj0 = 0 ;
29551 PyObject * obj1 = 0 ;
29552 char * kwnames[] = {
29553 (char *) "self",(char *) "other", NULL
29554 };
29555
29556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29558 if (!SWIG_IsOK(res1)) {
29559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29560 }
29561 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29562 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29563 if (!SWIG_IsOK(res2)) {
29564 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29565 }
29566 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29567 {
29568 PyThreadState* __tstate = wxPyBeginAllowThreads();
29569 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29570 wxPyEndAllowThreads(__tstate);
29571 if (PyErr_Occurred()) SWIG_fail;
29572 }
29573 {
29574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29575 }
29576 return resultobj;
29577 fail:
29578 return NULL;
29579 }
29580
29581
29582 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29583 PyObject *resultobj = 0;
29584 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29585 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29586 bool result;
29587 void *argp1 = 0 ;
29588 int res1 = 0 ;
29589 void *argp2 = 0 ;
29590 int res2 = 0 ;
29591 PyObject * obj0 = 0 ;
29592 PyObject * obj1 = 0 ;
29593 char * kwnames[] = {
29594 (char *) "self",(char *) "other", NULL
29595 };
29596
29597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29599 if (!SWIG_IsOK(res1)) {
29600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29601 }
29602 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29603 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29604 if (!SWIG_IsOK(res2)) {
29605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29606 }
29607 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29608 {
29609 PyThreadState* __tstate = wxPyBeginAllowThreads();
29610 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29611 wxPyEndAllowThreads(__tstate);
29612 if (PyErr_Occurred()) SWIG_fail;
29613 }
29614 {
29615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29616 }
29617 return resultobj;
29618 fail:
29619 return NULL;
29620 }
29621
29622
29623 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29624 PyObject *resultobj = 0;
29625 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29626 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29627 bool result;
29628 void *argp1 = 0 ;
29629 int res1 = 0 ;
29630 void *argp2 = 0 ;
29631 int res2 = 0 ;
29632 PyObject * obj0 = 0 ;
29633 PyObject * obj1 = 0 ;
29634 char * kwnames[] = {
29635 (char *) "self",(char *) "other", NULL
29636 };
29637
29638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29640 if (!SWIG_IsOK(res1)) {
29641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29642 }
29643 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29644 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29645 if (!SWIG_IsOK(res2)) {
29646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29647 }
29648 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29649 {
29650 PyThreadState* __tstate = wxPyBeginAllowThreads();
29651 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29652 wxPyEndAllowThreads(__tstate);
29653 if (PyErr_Occurred()) SWIG_fail;
29654 }
29655 {
29656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29657 }
29658 return resultobj;
29659 fail:
29660 return NULL;
29661 }
29662
29663
29664 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29665 PyObject *resultobj = 0;
29666 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29667 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29668 bool result;
29669 void *argp1 = 0 ;
29670 int res1 = 0 ;
29671 void *argp2 = 0 ;
29672 int res2 = 0 ;
29673 PyObject * obj0 = 0 ;
29674 PyObject * obj1 = 0 ;
29675 char * kwnames[] = {
29676 (char *) "self",(char *) "other", NULL
29677 };
29678
29679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29681 if (!SWIG_IsOK(res1)) {
29682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29683 }
29684 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29686 if (!SWIG_IsOK(res2)) {
29687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29688 }
29689 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29690 {
29691 PyThreadState* __tstate = wxPyBeginAllowThreads();
29692 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29693 wxPyEndAllowThreads(__tstate);
29694 if (PyErr_Occurred()) SWIG_fail;
29695 }
29696 {
29697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29698 }
29699 return resultobj;
29700 fail:
29701 return NULL;
29702 }
29703
29704
29705 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29706 PyObject *resultobj = 0;
29707 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29708 bool result;
29709 void *argp1 = 0 ;
29710 int res1 = 0 ;
29711 PyObject *swig_obj[1] ;
29712
29713 if (!args) SWIG_fail;
29714 swig_obj[0] = args;
29715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29716 if (!SWIG_IsOK(res1)) {
29717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29718 }
29719 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29720 {
29721 PyThreadState* __tstate = wxPyBeginAllowThreads();
29722 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29723 wxPyEndAllowThreads(__tstate);
29724 if (PyErr_Occurred()) SWIG_fail;
29725 }
29726 {
29727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29728 }
29729 return resultobj;
29730 fail:
29731 return NULL;
29732 }
29733
29734
29735 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29736 PyObject *resultobj = 0;
29737 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29738 bool result;
29739 void *argp1 = 0 ;
29740 int res1 = 0 ;
29741 PyObject *swig_obj[1] ;
29742
29743 if (!args) SWIG_fail;
29744 swig_obj[0] = args;
29745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29746 if (!SWIG_IsOK(res1)) {
29747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29748 }
29749 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29750 {
29751 PyThreadState* __tstate = wxPyBeginAllowThreads();
29752 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29753 wxPyEndAllowThreads(__tstate);
29754 if (PyErr_Occurred()) SWIG_fail;
29755 }
29756 {
29757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29758 }
29759 return resultobj;
29760 fail:
29761 return NULL;
29762 }
29763
29764
29765 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29766 PyObject *resultobj = 0;
29767 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29768 bool result;
29769 void *argp1 = 0 ;
29770 int res1 = 0 ;
29771 PyObject *swig_obj[1] ;
29772
29773 if (!args) SWIG_fail;
29774 swig_obj[0] = args;
29775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29776 if (!SWIG_IsOK(res1)) {
29777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29778 }
29779 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29780 {
29781 PyThreadState* __tstate = wxPyBeginAllowThreads();
29782 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29783 wxPyEndAllowThreads(__tstate);
29784 if (PyErr_Occurred()) SWIG_fail;
29785 }
29786 {
29787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29788 }
29789 return resultobj;
29790 fail:
29791 return NULL;
29792 }
29793
29794
29795 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29796 PyObject *resultobj = 0;
29797 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29798 wxTimeSpan *arg2 = 0 ;
29799 bool result;
29800 void *argp1 = 0 ;
29801 int res1 = 0 ;
29802 void *argp2 = 0 ;
29803 int res2 = 0 ;
29804 PyObject * obj0 = 0 ;
29805 PyObject * obj1 = 0 ;
29806 char * kwnames[] = {
29807 (char *) "self",(char *) "ts", NULL
29808 };
29809
29810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29812 if (!SWIG_IsOK(res1)) {
29813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29814 }
29815 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29816 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29817 if (!SWIG_IsOK(res2)) {
29818 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29819 }
29820 if (!argp2) {
29821 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29822 }
29823 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29824 {
29825 PyThreadState* __tstate = wxPyBeginAllowThreads();
29826 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29827 wxPyEndAllowThreads(__tstate);
29828 if (PyErr_Occurred()) SWIG_fail;
29829 }
29830 {
29831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29832 }
29833 return resultobj;
29834 fail:
29835 return NULL;
29836 }
29837
29838
29839 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29840 PyObject *resultobj = 0;
29841 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29842 wxTimeSpan *arg2 = 0 ;
29843 bool result;
29844 void *argp1 = 0 ;
29845 int res1 = 0 ;
29846 void *argp2 = 0 ;
29847 int res2 = 0 ;
29848 PyObject * obj0 = 0 ;
29849 PyObject * obj1 = 0 ;
29850 char * kwnames[] = {
29851 (char *) "self",(char *) "ts", NULL
29852 };
29853
29854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29856 if (!SWIG_IsOK(res1)) {
29857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29858 }
29859 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29860 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29861 if (!SWIG_IsOK(res2)) {
29862 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29863 }
29864 if (!argp2) {
29865 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29866 }
29867 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29868 {
29869 PyThreadState* __tstate = wxPyBeginAllowThreads();
29870 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 {
29875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29876 }
29877 return resultobj;
29878 fail:
29879 return NULL;
29880 }
29881
29882
29883 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29884 PyObject *resultobj = 0;
29885 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29886 wxTimeSpan *arg2 = 0 ;
29887 bool result;
29888 void *argp1 = 0 ;
29889 int res1 = 0 ;
29890 void *argp2 = 0 ;
29891 int res2 = 0 ;
29892 PyObject * obj0 = 0 ;
29893 PyObject * obj1 = 0 ;
29894 char * kwnames[] = {
29895 (char *) "self",(char *) "t", NULL
29896 };
29897
29898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29900 if (!SWIG_IsOK(res1)) {
29901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29902 }
29903 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29904 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29905 if (!SWIG_IsOK(res2)) {
29906 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29907 }
29908 if (!argp2) {
29909 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29910 }
29911 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29912 {
29913 PyThreadState* __tstate = wxPyBeginAllowThreads();
29914 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
29915 wxPyEndAllowThreads(__tstate);
29916 if (PyErr_Occurred()) SWIG_fail;
29917 }
29918 {
29919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29920 }
29921 return resultobj;
29922 fail:
29923 return NULL;
29924 }
29925
29926
29927 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29928 PyObject *resultobj = 0;
29929 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29930 int result;
29931 void *argp1 = 0 ;
29932 int res1 = 0 ;
29933 PyObject *swig_obj[1] ;
29934
29935 if (!args) SWIG_fail;
29936 swig_obj[0] = args;
29937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29938 if (!SWIG_IsOK(res1)) {
29939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29940 }
29941 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29942 {
29943 PyThreadState* __tstate = wxPyBeginAllowThreads();
29944 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
29945 wxPyEndAllowThreads(__tstate);
29946 if (PyErr_Occurred()) SWIG_fail;
29947 }
29948 resultobj = SWIG_From_int(static_cast< int >(result));
29949 return resultobj;
29950 fail:
29951 return NULL;
29952 }
29953
29954
29955 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29956 PyObject *resultobj = 0;
29957 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29958 int result;
29959 void *argp1 = 0 ;
29960 int res1 = 0 ;
29961 PyObject *swig_obj[1] ;
29962
29963 if (!args) SWIG_fail;
29964 swig_obj[0] = args;
29965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29966 if (!SWIG_IsOK(res1)) {
29967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29968 }
29969 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29970 {
29971 PyThreadState* __tstate = wxPyBeginAllowThreads();
29972 result = (int)((wxTimeSpan const *)arg1)->GetDays();
29973 wxPyEndAllowThreads(__tstate);
29974 if (PyErr_Occurred()) SWIG_fail;
29975 }
29976 resultobj = SWIG_From_int(static_cast< int >(result));
29977 return resultobj;
29978 fail:
29979 return NULL;
29980 }
29981
29982
29983 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29984 PyObject *resultobj = 0;
29985 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29986 int result;
29987 void *argp1 = 0 ;
29988 int res1 = 0 ;
29989 PyObject *swig_obj[1] ;
29990
29991 if (!args) SWIG_fail;
29992 swig_obj[0] = args;
29993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29994 if (!SWIG_IsOK(res1)) {
29995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29996 }
29997 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29998 {
29999 PyThreadState* __tstate = wxPyBeginAllowThreads();
30000 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30001 wxPyEndAllowThreads(__tstate);
30002 if (PyErr_Occurred()) SWIG_fail;
30003 }
30004 resultobj = SWIG_From_int(static_cast< int >(result));
30005 return resultobj;
30006 fail:
30007 return NULL;
30008 }
30009
30010
30011 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30012 PyObject *resultobj = 0;
30013 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30014 int result;
30015 void *argp1 = 0 ;
30016 int res1 = 0 ;
30017 PyObject *swig_obj[1] ;
30018
30019 if (!args) SWIG_fail;
30020 swig_obj[0] = args;
30021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30022 if (!SWIG_IsOK(res1)) {
30023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30024 }
30025 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30026 {
30027 PyThreadState* __tstate = wxPyBeginAllowThreads();
30028 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30029 wxPyEndAllowThreads(__tstate);
30030 if (PyErr_Occurred()) SWIG_fail;
30031 }
30032 resultobj = SWIG_From_int(static_cast< int >(result));
30033 return resultobj;
30034 fail:
30035 return NULL;
30036 }
30037
30038
30039 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30040 PyObject *resultobj = 0;
30041 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30042 wxLongLong result;
30043 void *argp1 = 0 ;
30044 int res1 = 0 ;
30045 PyObject *swig_obj[1] ;
30046
30047 if (!args) SWIG_fail;
30048 swig_obj[0] = args;
30049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30050 if (!SWIG_IsOK(res1)) {
30051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30052 }
30053 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30054 {
30055 PyThreadState* __tstate = wxPyBeginAllowThreads();
30056 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30057 wxPyEndAllowThreads(__tstate);
30058 if (PyErr_Occurred()) SWIG_fail;
30059 }
30060 {
30061 PyObject *hi, *lo, *shifter, *shifted;
30062 hi = PyLong_FromLong( (&result)->GetHi() );
30063 lo = PyLong_FromLong( (&result)->GetLo() );
30064 shifter = PyLong_FromLong(32);
30065 shifted = PyNumber_Lshift(hi, shifter);
30066 resultobj = PyNumber_Or(shifted, lo);
30067 Py_DECREF(hi);
30068 Py_DECREF(lo);
30069 Py_DECREF(shifter);
30070 Py_DECREF(shifted);
30071 }
30072 return resultobj;
30073 fail:
30074 return NULL;
30075 }
30076
30077
30078 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30079 PyObject *resultobj = 0;
30080 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30081 wxLongLong result;
30082 void *argp1 = 0 ;
30083 int res1 = 0 ;
30084 PyObject *swig_obj[1] ;
30085
30086 if (!args) SWIG_fail;
30087 swig_obj[0] = args;
30088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30089 if (!SWIG_IsOK(res1)) {
30090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30091 }
30092 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30093 {
30094 PyThreadState* __tstate = wxPyBeginAllowThreads();
30095 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30096 wxPyEndAllowThreads(__tstate);
30097 if (PyErr_Occurred()) SWIG_fail;
30098 }
30099 {
30100 PyObject *hi, *lo, *shifter, *shifted;
30101 hi = PyLong_FromLong( (&result)->GetHi() );
30102 lo = PyLong_FromLong( (&result)->GetLo() );
30103 shifter = PyLong_FromLong(32);
30104 shifted = PyNumber_Lshift(hi, shifter);
30105 resultobj = PyNumber_Or(shifted, lo);
30106 Py_DECREF(hi);
30107 Py_DECREF(lo);
30108 Py_DECREF(shifter);
30109 Py_DECREF(shifted);
30110 }
30111 return resultobj;
30112 fail:
30113 return NULL;
30114 }
30115
30116
30117 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30118 PyObject *resultobj = 0;
30119 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30120 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30121 wxString *arg2 = (wxString *) &arg2_defvalue ;
30122 wxString result;
30123 void *argp1 = 0 ;
30124 int res1 = 0 ;
30125 bool temp2 = false ;
30126 PyObject * obj0 = 0 ;
30127 PyObject * obj1 = 0 ;
30128 char * kwnames[] = {
30129 (char *) "self",(char *) "format", NULL
30130 };
30131
30132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30134 if (!SWIG_IsOK(res1)) {
30135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30136 }
30137 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30138 if (obj1) {
30139 {
30140 arg2 = wxString_in_helper(obj1);
30141 if (arg2 == NULL) SWIG_fail;
30142 temp2 = true;
30143 }
30144 }
30145 {
30146 PyThreadState* __tstate = wxPyBeginAllowThreads();
30147 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30148 wxPyEndAllowThreads(__tstate);
30149 if (PyErr_Occurred()) SWIG_fail;
30150 }
30151 {
30152 #if wxUSE_UNICODE
30153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30154 #else
30155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30156 #endif
30157 }
30158 {
30159 if (temp2)
30160 delete arg2;
30161 }
30162 return resultobj;
30163 fail:
30164 {
30165 if (temp2)
30166 delete arg2;
30167 }
30168 return NULL;
30169 }
30170
30171
30172 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30173 PyObject *obj;
30174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30175 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30176 return SWIG_Py_Void();
30177 }
30178
30179 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30180 return SWIG_Python_InitShadowInstance(args);
30181 }
30182
30183 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30184 PyObject *resultobj = 0;
30185 int arg1 = (int) 0 ;
30186 int arg2 = (int) 0 ;
30187 int arg3 = (int) 0 ;
30188 int arg4 = (int) 0 ;
30189 wxDateSpan *result = 0 ;
30190 int val1 ;
30191 int ecode1 = 0 ;
30192 int val2 ;
30193 int ecode2 = 0 ;
30194 int val3 ;
30195 int ecode3 = 0 ;
30196 int val4 ;
30197 int ecode4 = 0 ;
30198 PyObject * obj0 = 0 ;
30199 PyObject * obj1 = 0 ;
30200 PyObject * obj2 = 0 ;
30201 PyObject * obj3 = 0 ;
30202 char * kwnames[] = {
30203 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30204 };
30205
30206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30207 if (obj0) {
30208 ecode1 = SWIG_AsVal_int(obj0, &val1);
30209 if (!SWIG_IsOK(ecode1)) {
30210 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30211 }
30212 arg1 = static_cast< int >(val1);
30213 }
30214 if (obj1) {
30215 ecode2 = SWIG_AsVal_int(obj1, &val2);
30216 if (!SWIG_IsOK(ecode2)) {
30217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30218 }
30219 arg2 = static_cast< int >(val2);
30220 }
30221 if (obj2) {
30222 ecode3 = SWIG_AsVal_int(obj2, &val3);
30223 if (!SWIG_IsOK(ecode3)) {
30224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30225 }
30226 arg3 = static_cast< int >(val3);
30227 }
30228 if (obj3) {
30229 ecode4 = SWIG_AsVal_int(obj3, &val4);
30230 if (!SWIG_IsOK(ecode4)) {
30231 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30232 }
30233 arg4 = static_cast< int >(val4);
30234 }
30235 {
30236 PyThreadState* __tstate = wxPyBeginAllowThreads();
30237 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30238 wxPyEndAllowThreads(__tstate);
30239 if (PyErr_Occurred()) SWIG_fail;
30240 }
30241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30242 return resultobj;
30243 fail:
30244 return NULL;
30245 }
30246
30247
30248 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30249 PyObject *resultobj = 0;
30250 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30251 void *argp1 = 0 ;
30252 int res1 = 0 ;
30253 PyObject *swig_obj[1] ;
30254
30255 if (!args) SWIG_fail;
30256 swig_obj[0] = args;
30257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30258 if (!SWIG_IsOK(res1)) {
30259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30260 }
30261 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30262 {
30263 PyThreadState* __tstate = wxPyBeginAllowThreads();
30264 delete arg1;
30265
30266 wxPyEndAllowThreads(__tstate);
30267 if (PyErr_Occurred()) SWIG_fail;
30268 }
30269 resultobj = SWIG_Py_Void();
30270 return resultobj;
30271 fail:
30272 return NULL;
30273 }
30274
30275
30276 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30277 PyObject *resultobj = 0;
30278 int arg1 ;
30279 wxDateSpan result;
30280 int val1 ;
30281 int ecode1 = 0 ;
30282 PyObject * obj0 = 0 ;
30283 char * kwnames[] = {
30284 (char *) "days", NULL
30285 };
30286
30287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30288 ecode1 = SWIG_AsVal_int(obj0, &val1);
30289 if (!SWIG_IsOK(ecode1)) {
30290 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30291 }
30292 arg1 = static_cast< int >(val1);
30293 {
30294 PyThreadState* __tstate = wxPyBeginAllowThreads();
30295 result = wxDateSpan::Days(arg1);
30296 wxPyEndAllowThreads(__tstate);
30297 if (PyErr_Occurred()) SWIG_fail;
30298 }
30299 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30300 return resultobj;
30301 fail:
30302 return NULL;
30303 }
30304
30305
30306 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30307 PyObject *resultobj = 0;
30308 wxDateSpan result;
30309
30310 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30311 {
30312 PyThreadState* __tstate = wxPyBeginAllowThreads();
30313 result = wxDateSpan::Day();
30314 wxPyEndAllowThreads(__tstate);
30315 if (PyErr_Occurred()) SWIG_fail;
30316 }
30317 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30318 return resultobj;
30319 fail:
30320 return NULL;
30321 }
30322
30323
30324 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30325 PyObject *resultobj = 0;
30326 int arg1 ;
30327 wxDateSpan result;
30328 int val1 ;
30329 int ecode1 = 0 ;
30330 PyObject * obj0 = 0 ;
30331 char * kwnames[] = {
30332 (char *) "weeks", NULL
30333 };
30334
30335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30336 ecode1 = SWIG_AsVal_int(obj0, &val1);
30337 if (!SWIG_IsOK(ecode1)) {
30338 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30339 }
30340 arg1 = static_cast< int >(val1);
30341 {
30342 PyThreadState* __tstate = wxPyBeginAllowThreads();
30343 result = wxDateSpan::Weeks(arg1);
30344 wxPyEndAllowThreads(__tstate);
30345 if (PyErr_Occurred()) SWIG_fail;
30346 }
30347 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30348 return resultobj;
30349 fail:
30350 return NULL;
30351 }
30352
30353
30354 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30355 PyObject *resultobj = 0;
30356 wxDateSpan result;
30357
30358 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30359 {
30360 PyThreadState* __tstate = wxPyBeginAllowThreads();
30361 result = wxDateSpan::Week();
30362 wxPyEndAllowThreads(__tstate);
30363 if (PyErr_Occurred()) SWIG_fail;
30364 }
30365 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30366 return resultobj;
30367 fail:
30368 return NULL;
30369 }
30370
30371
30372 SWIGINTERN PyObject *_wrap_DateSpan_Months(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 *) "mon", NULL
30381 };
30382
30383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",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_Months" "', expected argument " "1"" of type '" "int""'");
30387 }
30388 arg1 = static_cast< int >(val1);
30389 {
30390 PyThreadState* __tstate = wxPyBeginAllowThreads();
30391 result = wxDateSpan::Months(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_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30403 PyObject *resultobj = 0;
30404 wxDateSpan result;
30405
30406 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30407 {
30408 PyThreadState* __tstate = wxPyBeginAllowThreads();
30409 result = wxDateSpan::Month();
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_Years(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 *) "years", NULL
30429 };
30430
30431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",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_Years" "', expected argument " "1"" of type '" "int""'");
30435 }
30436 arg1 = static_cast< int >(val1);
30437 {
30438 PyThreadState* __tstate = wxPyBeginAllowThreads();
30439 result = wxDateSpan::Years(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_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30451 PyObject *resultobj = 0;
30452 wxDateSpan result;
30453
30454 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30455 {
30456 PyThreadState* __tstate = wxPyBeginAllowThreads();
30457 result = wxDateSpan::Year();
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_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30469 PyObject *resultobj = 0;
30470 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30471 int arg2 ;
30472 wxDateSpan *result = 0 ;
30473 void *argp1 = 0 ;
30474 int res1 = 0 ;
30475 int val2 ;
30476 int ecode2 = 0 ;
30477 PyObject * obj0 = 0 ;
30478 PyObject * obj1 = 0 ;
30479 char * kwnames[] = {
30480 (char *) "self",(char *) "n", NULL
30481 };
30482
30483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30485 if (!SWIG_IsOK(res1)) {
30486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30487 }
30488 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30489 ecode2 = SWIG_AsVal_int(obj1, &val2);
30490 if (!SWIG_IsOK(ecode2)) {
30491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30492 }
30493 arg2 = static_cast< int >(val2);
30494 {
30495 PyThreadState* __tstate = wxPyBeginAllowThreads();
30496 {
30497 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30498 result = (wxDateSpan *) &_result_ref;
30499 }
30500 wxPyEndAllowThreads(__tstate);
30501 if (PyErr_Occurred()) SWIG_fail;
30502 }
30503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30504 return resultobj;
30505 fail:
30506 return NULL;
30507 }
30508
30509
30510 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30511 PyObject *resultobj = 0;
30512 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30513 int arg2 ;
30514 wxDateSpan *result = 0 ;
30515 void *argp1 = 0 ;
30516 int res1 = 0 ;
30517 int val2 ;
30518 int ecode2 = 0 ;
30519 PyObject * obj0 = 0 ;
30520 PyObject * obj1 = 0 ;
30521 char * kwnames[] = {
30522 (char *) "self",(char *) "n", NULL
30523 };
30524
30525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30527 if (!SWIG_IsOK(res1)) {
30528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30529 }
30530 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30531 ecode2 = SWIG_AsVal_int(obj1, &val2);
30532 if (!SWIG_IsOK(ecode2)) {
30533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30534 }
30535 arg2 = static_cast< int >(val2);
30536 {
30537 PyThreadState* __tstate = wxPyBeginAllowThreads();
30538 {
30539 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30540 result = (wxDateSpan *) &_result_ref;
30541 }
30542 wxPyEndAllowThreads(__tstate);
30543 if (PyErr_Occurred()) SWIG_fail;
30544 }
30545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30546 return resultobj;
30547 fail:
30548 return NULL;
30549 }
30550
30551
30552 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30553 PyObject *resultobj = 0;
30554 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30555 int arg2 ;
30556 wxDateSpan *result = 0 ;
30557 void *argp1 = 0 ;
30558 int res1 = 0 ;
30559 int val2 ;
30560 int ecode2 = 0 ;
30561 PyObject * obj0 = 0 ;
30562 PyObject * obj1 = 0 ;
30563 char * kwnames[] = {
30564 (char *) "self",(char *) "n", NULL
30565 };
30566
30567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30569 if (!SWIG_IsOK(res1)) {
30570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30571 }
30572 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30573 ecode2 = SWIG_AsVal_int(obj1, &val2);
30574 if (!SWIG_IsOK(ecode2)) {
30575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30576 }
30577 arg2 = static_cast< int >(val2);
30578 {
30579 PyThreadState* __tstate = wxPyBeginAllowThreads();
30580 {
30581 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30582 result = (wxDateSpan *) &_result_ref;
30583 }
30584 wxPyEndAllowThreads(__tstate);
30585 if (PyErr_Occurred()) SWIG_fail;
30586 }
30587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30588 return resultobj;
30589 fail:
30590 return NULL;
30591 }
30592
30593
30594 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30595 PyObject *resultobj = 0;
30596 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30597 int arg2 ;
30598 wxDateSpan *result = 0 ;
30599 void *argp1 = 0 ;
30600 int res1 = 0 ;
30601 int val2 ;
30602 int ecode2 = 0 ;
30603 PyObject * obj0 = 0 ;
30604 PyObject * obj1 = 0 ;
30605 char * kwnames[] = {
30606 (char *) "self",(char *) "n", NULL
30607 };
30608
30609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30611 if (!SWIG_IsOK(res1)) {
30612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30613 }
30614 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30615 ecode2 = SWIG_AsVal_int(obj1, &val2);
30616 if (!SWIG_IsOK(ecode2)) {
30617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30618 }
30619 arg2 = static_cast< int >(val2);
30620 {
30621 PyThreadState* __tstate = wxPyBeginAllowThreads();
30622 {
30623 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30624 result = (wxDateSpan *) &_result_ref;
30625 }
30626 wxPyEndAllowThreads(__tstate);
30627 if (PyErr_Occurred()) SWIG_fail;
30628 }
30629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30630 return resultobj;
30631 fail:
30632 return NULL;
30633 }
30634
30635
30636 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30637 PyObject *resultobj = 0;
30638 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30639 int result;
30640 void *argp1 = 0 ;
30641 int res1 = 0 ;
30642 PyObject *swig_obj[1] ;
30643
30644 if (!args) SWIG_fail;
30645 swig_obj[0] = args;
30646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30647 if (!SWIG_IsOK(res1)) {
30648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30649 }
30650 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30651 {
30652 PyThreadState* __tstate = wxPyBeginAllowThreads();
30653 result = (int)((wxDateSpan const *)arg1)->GetYears();
30654 wxPyEndAllowThreads(__tstate);
30655 if (PyErr_Occurred()) SWIG_fail;
30656 }
30657 resultobj = SWIG_From_int(static_cast< int >(result));
30658 return resultobj;
30659 fail:
30660 return NULL;
30661 }
30662
30663
30664 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30665 PyObject *resultobj = 0;
30666 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30667 int result;
30668 void *argp1 = 0 ;
30669 int res1 = 0 ;
30670 PyObject *swig_obj[1] ;
30671
30672 if (!args) SWIG_fail;
30673 swig_obj[0] = args;
30674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30675 if (!SWIG_IsOK(res1)) {
30676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30677 }
30678 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30679 {
30680 PyThreadState* __tstate = wxPyBeginAllowThreads();
30681 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30682 wxPyEndAllowThreads(__tstate);
30683 if (PyErr_Occurred()) SWIG_fail;
30684 }
30685 resultobj = SWIG_From_int(static_cast< int >(result));
30686 return resultobj;
30687 fail:
30688 return NULL;
30689 }
30690
30691
30692 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30693 PyObject *resultobj = 0;
30694 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30695 int result;
30696 void *argp1 = 0 ;
30697 int res1 = 0 ;
30698 PyObject *swig_obj[1] ;
30699
30700 if (!args) SWIG_fail;
30701 swig_obj[0] = args;
30702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30703 if (!SWIG_IsOK(res1)) {
30704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30705 }
30706 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30707 {
30708 PyThreadState* __tstate = wxPyBeginAllowThreads();
30709 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30710 wxPyEndAllowThreads(__tstate);
30711 if (PyErr_Occurred()) SWIG_fail;
30712 }
30713 resultobj = SWIG_From_int(static_cast< int >(result));
30714 return resultobj;
30715 fail:
30716 return NULL;
30717 }
30718
30719
30720 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30721 PyObject *resultobj = 0;
30722 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30723 int result;
30724 void *argp1 = 0 ;
30725 int res1 = 0 ;
30726 PyObject *swig_obj[1] ;
30727
30728 if (!args) SWIG_fail;
30729 swig_obj[0] = args;
30730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30731 if (!SWIG_IsOK(res1)) {
30732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30733 }
30734 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30735 {
30736 PyThreadState* __tstate = wxPyBeginAllowThreads();
30737 result = (int)((wxDateSpan const *)arg1)->GetDays();
30738 wxPyEndAllowThreads(__tstate);
30739 if (PyErr_Occurred()) SWIG_fail;
30740 }
30741 resultobj = SWIG_From_int(static_cast< int >(result));
30742 return resultobj;
30743 fail:
30744 return NULL;
30745 }
30746
30747
30748 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30749 PyObject *resultobj = 0;
30750 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30751 int result;
30752 void *argp1 = 0 ;
30753 int res1 = 0 ;
30754 PyObject *swig_obj[1] ;
30755
30756 if (!args) SWIG_fail;
30757 swig_obj[0] = args;
30758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30759 if (!SWIG_IsOK(res1)) {
30760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30761 }
30762 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30763 {
30764 PyThreadState* __tstate = wxPyBeginAllowThreads();
30765 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30766 wxPyEndAllowThreads(__tstate);
30767 if (PyErr_Occurred()) SWIG_fail;
30768 }
30769 resultobj = SWIG_From_int(static_cast< int >(result));
30770 return resultobj;
30771 fail:
30772 return NULL;
30773 }
30774
30775
30776 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30777 PyObject *resultobj = 0;
30778 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30779 wxDateSpan *arg2 = 0 ;
30780 wxDateSpan *result = 0 ;
30781 void *argp1 = 0 ;
30782 int res1 = 0 ;
30783 void *argp2 = 0 ;
30784 int res2 = 0 ;
30785 PyObject * obj0 = 0 ;
30786 PyObject * obj1 = 0 ;
30787 char * kwnames[] = {
30788 (char *) "self",(char *) "other", NULL
30789 };
30790
30791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30793 if (!SWIG_IsOK(res1)) {
30794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30795 }
30796 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30797 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30798 if (!SWIG_IsOK(res2)) {
30799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30800 }
30801 if (!argp2) {
30802 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30803 }
30804 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30805 {
30806 PyThreadState* __tstate = wxPyBeginAllowThreads();
30807 {
30808 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30809 result = (wxDateSpan *) &_result_ref;
30810 }
30811 wxPyEndAllowThreads(__tstate);
30812 if (PyErr_Occurred()) SWIG_fail;
30813 }
30814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30815 return resultobj;
30816 fail:
30817 return NULL;
30818 }
30819
30820
30821 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30822 PyObject *resultobj = 0;
30823 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30824 wxDateSpan *arg2 = 0 ;
30825 wxDateSpan *result = 0 ;
30826 void *argp1 = 0 ;
30827 int res1 = 0 ;
30828 void *argp2 = 0 ;
30829 int res2 = 0 ;
30830 PyObject * obj0 = 0 ;
30831 PyObject * obj1 = 0 ;
30832 char * kwnames[] = {
30833 (char *) "self",(char *) "other", NULL
30834 };
30835
30836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30838 if (!SWIG_IsOK(res1)) {
30839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30840 }
30841 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30842 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30843 if (!SWIG_IsOK(res2)) {
30844 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30845 }
30846 if (!argp2) {
30847 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30848 }
30849 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30850 {
30851 PyThreadState* __tstate = wxPyBeginAllowThreads();
30852 {
30853 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30854 result = (wxDateSpan *) &_result_ref;
30855 }
30856 wxPyEndAllowThreads(__tstate);
30857 if (PyErr_Occurred()) SWIG_fail;
30858 }
30859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30860 return resultobj;
30861 fail:
30862 return NULL;
30863 }
30864
30865
30866 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30867 PyObject *resultobj = 0;
30868 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30869 wxDateSpan *result = 0 ;
30870 void *argp1 = 0 ;
30871 int res1 = 0 ;
30872 PyObject *swig_obj[1] ;
30873
30874 if (!args) SWIG_fail;
30875 swig_obj[0] = args;
30876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30877 if (!SWIG_IsOK(res1)) {
30878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30879 }
30880 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30881 {
30882 PyThreadState* __tstate = wxPyBeginAllowThreads();
30883 {
30884 wxDateSpan &_result_ref = (arg1)->Neg();
30885 result = (wxDateSpan *) &_result_ref;
30886 }
30887 wxPyEndAllowThreads(__tstate);
30888 if (PyErr_Occurred()) SWIG_fail;
30889 }
30890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30891 return resultobj;
30892 fail:
30893 return NULL;
30894 }
30895
30896
30897 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30898 PyObject *resultobj = 0;
30899 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30900 int arg2 ;
30901 wxDateSpan *result = 0 ;
30902 void *argp1 = 0 ;
30903 int res1 = 0 ;
30904 int val2 ;
30905 int ecode2 = 0 ;
30906 PyObject * obj0 = 0 ;
30907 PyObject * obj1 = 0 ;
30908 char * kwnames[] = {
30909 (char *) "self",(char *) "factor", NULL
30910 };
30911
30912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
30913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30914 if (!SWIG_IsOK(res1)) {
30915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30916 }
30917 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30918 ecode2 = SWIG_AsVal_int(obj1, &val2);
30919 if (!SWIG_IsOK(ecode2)) {
30920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
30921 }
30922 arg2 = static_cast< int >(val2);
30923 {
30924 PyThreadState* __tstate = wxPyBeginAllowThreads();
30925 {
30926 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
30927 result = (wxDateSpan *) &_result_ref;
30928 }
30929 wxPyEndAllowThreads(__tstate);
30930 if (PyErr_Occurred()) SWIG_fail;
30931 }
30932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30933 return resultobj;
30934 fail:
30935 return NULL;
30936 }
30937
30938
30939 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30940 PyObject *resultobj = 0;
30941 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30942 wxDateSpan *arg2 = 0 ;
30943 wxDateSpan *result = 0 ;
30944 void *argp1 = 0 ;
30945 int res1 = 0 ;
30946 void *argp2 = 0 ;
30947 int res2 = 0 ;
30948 PyObject * obj0 = 0 ;
30949 PyObject * obj1 = 0 ;
30950 char * kwnames[] = {
30951 (char *) "self",(char *) "other", NULL
30952 };
30953
30954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
30955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30956 if (!SWIG_IsOK(res1)) {
30957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30958 }
30959 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30960 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30961 if (!SWIG_IsOK(res2)) {
30962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30963 }
30964 if (!argp2) {
30965 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30966 }
30967 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30968 {
30969 PyThreadState* __tstate = wxPyBeginAllowThreads();
30970 {
30971 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
30972 result = (wxDateSpan *) &_result_ref;
30973 }
30974 wxPyEndAllowThreads(__tstate);
30975 if (PyErr_Occurred()) SWIG_fail;
30976 }
30977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30978 return resultobj;
30979 fail:
30980 return NULL;
30981 }
30982
30983
30984 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30985 PyObject *resultobj = 0;
30986 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30987 wxDateSpan *arg2 = 0 ;
30988 wxDateSpan *result = 0 ;
30989 void *argp1 = 0 ;
30990 int res1 = 0 ;
30991 void *argp2 = 0 ;
30992 int res2 = 0 ;
30993 PyObject * obj0 = 0 ;
30994 PyObject * obj1 = 0 ;
30995 char * kwnames[] = {
30996 (char *) "self",(char *) "other", NULL
30997 };
30998
30999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31001 if (!SWIG_IsOK(res1)) {
31002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31003 }
31004 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31005 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31006 if (!SWIG_IsOK(res2)) {
31007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31008 }
31009 if (!argp2) {
31010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31011 }
31012 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31013 {
31014 PyThreadState* __tstate = wxPyBeginAllowThreads();
31015 {
31016 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31017 result = (wxDateSpan *) &_result_ref;
31018 }
31019 wxPyEndAllowThreads(__tstate);
31020 if (PyErr_Occurred()) SWIG_fail;
31021 }
31022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31023 return resultobj;
31024 fail:
31025 return NULL;
31026 }
31027
31028
31029 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31030 PyObject *resultobj = 0;
31031 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31032 wxDateSpan *result = 0 ;
31033 void *argp1 = 0 ;
31034 int res1 = 0 ;
31035 PyObject *swig_obj[1] ;
31036
31037 if (!args) SWIG_fail;
31038 swig_obj[0] = args;
31039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31040 if (!SWIG_IsOK(res1)) {
31041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31042 }
31043 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31044 {
31045 PyThreadState* __tstate = wxPyBeginAllowThreads();
31046 {
31047 wxDateSpan &_result_ref = (arg1)->operator -();
31048 result = (wxDateSpan *) &_result_ref;
31049 }
31050 wxPyEndAllowThreads(__tstate);
31051 if (PyErr_Occurred()) SWIG_fail;
31052 }
31053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31054 return resultobj;
31055 fail:
31056 return NULL;
31057 }
31058
31059
31060 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31061 PyObject *resultobj = 0;
31062 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31063 int arg2 ;
31064 wxDateSpan *result = 0 ;
31065 void *argp1 = 0 ;
31066 int res1 = 0 ;
31067 int val2 ;
31068 int ecode2 = 0 ;
31069 PyObject * obj0 = 0 ;
31070 PyObject * obj1 = 0 ;
31071 char * kwnames[] = {
31072 (char *) "self",(char *) "factor", NULL
31073 };
31074
31075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31077 if (!SWIG_IsOK(res1)) {
31078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31079 }
31080 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31081 ecode2 = SWIG_AsVal_int(obj1, &val2);
31082 if (!SWIG_IsOK(ecode2)) {
31083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31084 }
31085 arg2 = static_cast< int >(val2);
31086 {
31087 PyThreadState* __tstate = wxPyBeginAllowThreads();
31088 {
31089 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31090 result = (wxDateSpan *) &_result_ref;
31091 }
31092 wxPyEndAllowThreads(__tstate);
31093 if (PyErr_Occurred()) SWIG_fail;
31094 }
31095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31096 return resultobj;
31097 fail:
31098 return NULL;
31099 }
31100
31101
31102 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31103 PyObject *resultobj = 0;
31104 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31105 wxDateSpan *arg2 = 0 ;
31106 wxDateSpan result;
31107 void *argp1 = 0 ;
31108 int res1 = 0 ;
31109 void *argp2 = 0 ;
31110 int res2 = 0 ;
31111 PyObject * obj0 = 0 ;
31112 PyObject * obj1 = 0 ;
31113 char * kwnames[] = {
31114 (char *) "self",(char *) "other", NULL
31115 };
31116
31117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31119 if (!SWIG_IsOK(res1)) {
31120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31121 }
31122 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31123 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31124 if (!SWIG_IsOK(res2)) {
31125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31126 }
31127 if (!argp2) {
31128 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31129 }
31130 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31131 {
31132 PyThreadState* __tstate = wxPyBeginAllowThreads();
31133 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31134 wxPyEndAllowThreads(__tstate);
31135 if (PyErr_Occurred()) SWIG_fail;
31136 }
31137 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31138 return resultobj;
31139 fail:
31140 return NULL;
31141 }
31142
31143
31144 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31145 PyObject *resultobj = 0;
31146 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31147 wxDateSpan *arg2 = 0 ;
31148 wxDateSpan result;
31149 void *argp1 = 0 ;
31150 int res1 = 0 ;
31151 void *argp2 = 0 ;
31152 int res2 = 0 ;
31153 PyObject * obj0 = 0 ;
31154 PyObject * obj1 = 0 ;
31155 char * kwnames[] = {
31156 (char *) "self",(char *) "other", NULL
31157 };
31158
31159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31161 if (!SWIG_IsOK(res1)) {
31162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31163 }
31164 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31165 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31166 if (!SWIG_IsOK(res2)) {
31167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31168 }
31169 if (!argp2) {
31170 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31171 }
31172 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31173 {
31174 PyThreadState* __tstate = wxPyBeginAllowThreads();
31175 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31176 wxPyEndAllowThreads(__tstate);
31177 if (PyErr_Occurred()) SWIG_fail;
31178 }
31179 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31180 return resultobj;
31181 fail:
31182 return NULL;
31183 }
31184
31185
31186 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31187 PyObject *resultobj = 0;
31188 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31189 int arg2 ;
31190 wxDateSpan result;
31191 void *argp1 = 0 ;
31192 int res1 = 0 ;
31193 int val2 ;
31194 int ecode2 = 0 ;
31195 PyObject * obj0 = 0 ;
31196 PyObject * obj1 = 0 ;
31197 char * kwnames[] = {
31198 (char *) "self",(char *) "n", NULL
31199 };
31200
31201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31203 if (!SWIG_IsOK(res1)) {
31204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31205 }
31206 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31207 ecode2 = SWIG_AsVal_int(obj1, &val2);
31208 if (!SWIG_IsOK(ecode2)) {
31209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31210 }
31211 arg2 = static_cast< int >(val2);
31212 {
31213 PyThreadState* __tstate = wxPyBeginAllowThreads();
31214 result = wxDateSpan___mul__(arg1,arg2);
31215 wxPyEndAllowThreads(__tstate);
31216 if (PyErr_Occurred()) SWIG_fail;
31217 }
31218 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31219 return resultobj;
31220 fail:
31221 return NULL;
31222 }
31223
31224
31225 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31226 PyObject *resultobj = 0;
31227 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31228 int arg2 ;
31229 wxDateSpan result;
31230 void *argp1 = 0 ;
31231 int res1 = 0 ;
31232 int val2 ;
31233 int ecode2 = 0 ;
31234 PyObject * obj0 = 0 ;
31235 PyObject * obj1 = 0 ;
31236 char * kwnames[] = {
31237 (char *) "self",(char *) "n", NULL
31238 };
31239
31240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31242 if (!SWIG_IsOK(res1)) {
31243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31244 }
31245 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31246 ecode2 = SWIG_AsVal_int(obj1, &val2);
31247 if (!SWIG_IsOK(ecode2)) {
31248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31249 }
31250 arg2 = static_cast< int >(val2);
31251 {
31252 PyThreadState* __tstate = wxPyBeginAllowThreads();
31253 result = wxDateSpan___rmul__(arg1,arg2);
31254 wxPyEndAllowThreads(__tstate);
31255 if (PyErr_Occurred()) SWIG_fail;
31256 }
31257 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31258 return resultobj;
31259 fail:
31260 return NULL;
31261 }
31262
31263
31264 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31265 PyObject *resultobj = 0;
31266 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31267 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31268 bool result;
31269 void *argp1 = 0 ;
31270 int res1 = 0 ;
31271 void *argp2 = 0 ;
31272 int res2 = 0 ;
31273 PyObject * obj0 = 0 ;
31274 PyObject * obj1 = 0 ;
31275 char * kwnames[] = {
31276 (char *) "self",(char *) "other", NULL
31277 };
31278
31279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31281 if (!SWIG_IsOK(res1)) {
31282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31283 }
31284 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31285 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31286 if (!SWIG_IsOK(res2)) {
31287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31288 }
31289 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31290 {
31291 PyThreadState* __tstate = wxPyBeginAllowThreads();
31292 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31293 wxPyEndAllowThreads(__tstate);
31294 if (PyErr_Occurred()) SWIG_fail;
31295 }
31296 {
31297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31298 }
31299 return resultobj;
31300 fail:
31301 return NULL;
31302 }
31303
31304
31305 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31306 PyObject *resultobj = 0;
31307 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31308 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31309 bool result;
31310 void *argp1 = 0 ;
31311 int res1 = 0 ;
31312 void *argp2 = 0 ;
31313 int res2 = 0 ;
31314 PyObject * obj0 = 0 ;
31315 PyObject * obj1 = 0 ;
31316 char * kwnames[] = {
31317 (char *) "self",(char *) "other", NULL
31318 };
31319
31320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31322 if (!SWIG_IsOK(res1)) {
31323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31324 }
31325 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31326 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31327 if (!SWIG_IsOK(res2)) {
31328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31329 }
31330 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31331 {
31332 PyThreadState* __tstate = wxPyBeginAllowThreads();
31333 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31334 wxPyEndAllowThreads(__tstate);
31335 if (PyErr_Occurred()) SWIG_fail;
31336 }
31337 {
31338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31339 }
31340 return resultobj;
31341 fail:
31342 return NULL;
31343 }
31344
31345
31346 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31347 PyObject *obj;
31348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31349 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31350 return SWIG_Py_Void();
31351 }
31352
31353 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31354 return SWIG_Python_InitShadowInstance(args);
31355 }
31356
31357 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31358 PyObject *resultobj = 0;
31359 long result;
31360
31361 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31362 {
31363 PyThreadState* __tstate = wxPyBeginAllowThreads();
31364 result = (long)wxGetLocalTime();
31365 wxPyEndAllowThreads(__tstate);
31366 if (PyErr_Occurred()) SWIG_fail;
31367 }
31368 resultobj = SWIG_From_long(static_cast< long >(result));
31369 return resultobj;
31370 fail:
31371 return NULL;
31372 }
31373
31374
31375 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31376 PyObject *resultobj = 0;
31377 long result;
31378
31379 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31380 {
31381 PyThreadState* __tstate = wxPyBeginAllowThreads();
31382 result = (long)wxGetUTCTime();
31383 wxPyEndAllowThreads(__tstate);
31384 if (PyErr_Occurred()) SWIG_fail;
31385 }
31386 resultobj = SWIG_From_long(static_cast< long >(result));
31387 return resultobj;
31388 fail:
31389 return NULL;
31390 }
31391
31392
31393 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31394 PyObject *resultobj = 0;
31395 long result;
31396
31397 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31398 {
31399 PyThreadState* __tstate = wxPyBeginAllowThreads();
31400 result = (long)wxGetCurrentTime();
31401 wxPyEndAllowThreads(__tstate);
31402 if (PyErr_Occurred()) SWIG_fail;
31403 }
31404 resultobj = SWIG_From_long(static_cast< long >(result));
31405 return resultobj;
31406 fail:
31407 return NULL;
31408 }
31409
31410
31411 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31412 PyObject *resultobj = 0;
31413 wxLongLong result;
31414
31415 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31416 {
31417 PyThreadState* __tstate = wxPyBeginAllowThreads();
31418 result = wxGetLocalTimeMillis();
31419 wxPyEndAllowThreads(__tstate);
31420 if (PyErr_Occurred()) SWIG_fail;
31421 }
31422 {
31423 PyObject *hi, *lo, *shifter, *shifted;
31424 hi = PyLong_FromLong( (&result)->GetHi() );
31425 lo = PyLong_FromLong( (&result)->GetLo() );
31426 shifter = PyLong_FromLong(32);
31427 shifted = PyNumber_Lshift(hi, shifter);
31428 resultobj = PyNumber_Or(shifted, lo);
31429 Py_DECREF(hi);
31430 Py_DECREF(lo);
31431 Py_DECREF(shifter);
31432 Py_DECREF(shifted);
31433 }
31434 return resultobj;
31435 fail:
31436 return NULL;
31437 }
31438
31439
31440 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31441 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31442 return 1;
31443 }
31444
31445
31446 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31447 PyObject *pyobj = 0;
31448
31449 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31450 return pyobj;
31451 }
31452
31453
31454 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31455 PyObject *resultobj = 0;
31456 wxDataFormatId arg1 ;
31457 wxDataFormat *result = 0 ;
31458 int val1 ;
31459 int ecode1 = 0 ;
31460 PyObject * obj0 = 0 ;
31461 char * kwnames[] = {
31462 (char *) "type", NULL
31463 };
31464
31465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31466 ecode1 = SWIG_AsVal_int(obj0, &val1);
31467 if (!SWIG_IsOK(ecode1)) {
31468 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31469 }
31470 arg1 = static_cast< wxDataFormatId >(val1);
31471 {
31472 PyThreadState* __tstate = wxPyBeginAllowThreads();
31473 result = (wxDataFormat *)new wxDataFormat(arg1);
31474 wxPyEndAllowThreads(__tstate);
31475 if (PyErr_Occurred()) SWIG_fail;
31476 }
31477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31478 return resultobj;
31479 fail:
31480 return NULL;
31481 }
31482
31483
31484 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31485 PyObject *resultobj = 0;
31486 wxString *arg1 = 0 ;
31487 wxDataFormat *result = 0 ;
31488 bool temp1 = false ;
31489 PyObject * obj0 = 0 ;
31490 char * kwnames[] = {
31491 (char *) "format", NULL
31492 };
31493
31494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31495 {
31496 arg1 = wxString_in_helper(obj0);
31497 if (arg1 == NULL) SWIG_fail;
31498 temp1 = true;
31499 }
31500 {
31501 PyThreadState* __tstate = wxPyBeginAllowThreads();
31502 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31503 wxPyEndAllowThreads(__tstate);
31504 if (PyErr_Occurred()) SWIG_fail;
31505 }
31506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31507 {
31508 if (temp1)
31509 delete arg1;
31510 }
31511 return resultobj;
31512 fail:
31513 {
31514 if (temp1)
31515 delete arg1;
31516 }
31517 return NULL;
31518 }
31519
31520
31521 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31522 PyObject *resultobj = 0;
31523 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31524 void *argp1 = 0 ;
31525 int res1 = 0 ;
31526 PyObject *swig_obj[1] ;
31527
31528 if (!args) SWIG_fail;
31529 swig_obj[0] = args;
31530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31531 if (!SWIG_IsOK(res1)) {
31532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31533 }
31534 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31535 {
31536 PyThreadState* __tstate = wxPyBeginAllowThreads();
31537 delete arg1;
31538
31539 wxPyEndAllowThreads(__tstate);
31540 if (PyErr_Occurred()) SWIG_fail;
31541 }
31542 resultobj = SWIG_Py_Void();
31543 return resultobj;
31544 fail:
31545 return NULL;
31546 }
31547
31548
31549 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31550 PyObject *resultobj = 0;
31551 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31552 wxDataFormatId arg2 ;
31553 bool result;
31554 void *argp1 = 0 ;
31555 int res1 = 0 ;
31556 int val2 ;
31557 int ecode2 = 0 ;
31558
31559 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31561 if (!SWIG_IsOK(res1)) {
31562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31563 }
31564 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31565 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31566 if (!SWIG_IsOK(ecode2)) {
31567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31568 }
31569 arg2 = static_cast< wxDataFormatId >(val2);
31570 {
31571 PyThreadState* __tstate = wxPyBeginAllowThreads();
31572 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31573 wxPyEndAllowThreads(__tstate);
31574 if (PyErr_Occurred()) SWIG_fail;
31575 }
31576 {
31577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31578 }
31579 return resultobj;
31580 fail:
31581 return NULL;
31582 }
31583
31584
31585 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31586 PyObject *resultobj = 0;
31587 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31588 wxDataFormatId arg2 ;
31589 bool result;
31590 void *argp1 = 0 ;
31591 int res1 = 0 ;
31592 int val2 ;
31593 int ecode2 = 0 ;
31594
31595 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31597 if (!SWIG_IsOK(res1)) {
31598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31599 }
31600 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31601 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31602 if (!SWIG_IsOK(ecode2)) {
31603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31604 }
31605 arg2 = static_cast< wxDataFormatId >(val2);
31606 {
31607 PyThreadState* __tstate = wxPyBeginAllowThreads();
31608 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31609 wxPyEndAllowThreads(__tstate);
31610 if (PyErr_Occurred()) SWIG_fail;
31611 }
31612 {
31613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31614 }
31615 return resultobj;
31616 fail:
31617 return NULL;
31618 }
31619
31620
31621 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31622 PyObject *resultobj = 0;
31623 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31624 wxDataFormat *arg2 = 0 ;
31625 bool result;
31626 void *argp1 = 0 ;
31627 int res1 = 0 ;
31628 void *argp2 = 0 ;
31629 int res2 = 0 ;
31630
31631 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31633 if (!SWIG_IsOK(res1)) {
31634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31635 }
31636 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31637 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31638 if (!SWIG_IsOK(res2)) {
31639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31640 }
31641 if (!argp2) {
31642 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31643 }
31644 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31645 {
31646 PyThreadState* __tstate = wxPyBeginAllowThreads();
31647 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31648 wxPyEndAllowThreads(__tstate);
31649 if (PyErr_Occurred()) SWIG_fail;
31650 }
31651 {
31652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31653 }
31654 return resultobj;
31655 fail:
31656 return NULL;
31657 }
31658
31659
31660 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31661 int argc;
31662 PyObject *argv[3];
31663
31664 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31665 --argc;
31666 if (argc == 2) {
31667 int _v = 0;
31668 {
31669 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31670 _v = SWIG_CheckState(res);
31671 }
31672 if (!_v) goto check_1;
31673 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31674 }
31675 check_1:
31676
31677 if (argc == 2) {
31678 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31679 }
31680
31681 fail:
31682 Py_INCREF(Py_NotImplemented);
31683 return Py_NotImplemented;
31684 }
31685
31686
31687 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31688 PyObject *resultobj = 0;
31689 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31690 wxDataFormat *arg2 = 0 ;
31691 bool result;
31692 void *argp1 = 0 ;
31693 int res1 = 0 ;
31694 void *argp2 = 0 ;
31695 int res2 = 0 ;
31696
31697 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31699 if (!SWIG_IsOK(res1)) {
31700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31701 }
31702 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31703 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31704 if (!SWIG_IsOK(res2)) {
31705 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31706 }
31707 if (!argp2) {
31708 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31709 }
31710 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31711 {
31712 PyThreadState* __tstate = wxPyBeginAllowThreads();
31713 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31714 wxPyEndAllowThreads(__tstate);
31715 if (PyErr_Occurred()) SWIG_fail;
31716 }
31717 {
31718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31719 }
31720 return resultobj;
31721 fail:
31722 return NULL;
31723 }
31724
31725
31726 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31727 int argc;
31728 PyObject *argv[3];
31729
31730 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31731 --argc;
31732 if (argc == 2) {
31733 int _v = 0;
31734 {
31735 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31736 _v = SWIG_CheckState(res);
31737 }
31738 if (!_v) goto check_1;
31739 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31740 }
31741 check_1:
31742
31743 if (argc == 2) {
31744 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31745 }
31746
31747 fail:
31748 Py_INCREF(Py_NotImplemented);
31749 return Py_NotImplemented;
31750 }
31751
31752
31753 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31754 PyObject *resultobj = 0;
31755 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31756 wxDataFormatId arg2 ;
31757 void *argp1 = 0 ;
31758 int res1 = 0 ;
31759 int val2 ;
31760 int ecode2 = 0 ;
31761 PyObject * obj0 = 0 ;
31762 PyObject * obj1 = 0 ;
31763 char * kwnames[] = {
31764 (char *) "self",(char *) "format", NULL
31765 };
31766
31767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31769 if (!SWIG_IsOK(res1)) {
31770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31771 }
31772 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31773 ecode2 = SWIG_AsVal_int(obj1, &val2);
31774 if (!SWIG_IsOK(ecode2)) {
31775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31776 }
31777 arg2 = static_cast< wxDataFormatId >(val2);
31778 {
31779 PyThreadState* __tstate = wxPyBeginAllowThreads();
31780 (arg1)->SetType(arg2);
31781 wxPyEndAllowThreads(__tstate);
31782 if (PyErr_Occurred()) SWIG_fail;
31783 }
31784 resultobj = SWIG_Py_Void();
31785 return resultobj;
31786 fail:
31787 return NULL;
31788 }
31789
31790
31791 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31792 PyObject *resultobj = 0;
31793 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31794 wxDataFormatId result;
31795 void *argp1 = 0 ;
31796 int res1 = 0 ;
31797 PyObject *swig_obj[1] ;
31798
31799 if (!args) SWIG_fail;
31800 swig_obj[0] = args;
31801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31802 if (!SWIG_IsOK(res1)) {
31803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31804 }
31805 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31806 {
31807 PyThreadState* __tstate = wxPyBeginAllowThreads();
31808 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31809 wxPyEndAllowThreads(__tstate);
31810 if (PyErr_Occurred()) SWIG_fail;
31811 }
31812 resultobj = SWIG_From_int(static_cast< int >(result));
31813 return resultobj;
31814 fail:
31815 return NULL;
31816 }
31817
31818
31819 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31820 PyObject *resultobj = 0;
31821 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31822 wxString result;
31823 void *argp1 = 0 ;
31824 int res1 = 0 ;
31825 PyObject *swig_obj[1] ;
31826
31827 if (!args) SWIG_fail;
31828 swig_obj[0] = args;
31829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31830 if (!SWIG_IsOK(res1)) {
31831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31832 }
31833 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31834 {
31835 PyThreadState* __tstate = wxPyBeginAllowThreads();
31836 result = ((wxDataFormat const *)arg1)->GetId();
31837 wxPyEndAllowThreads(__tstate);
31838 if (PyErr_Occurred()) SWIG_fail;
31839 }
31840 {
31841 #if wxUSE_UNICODE
31842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31843 #else
31844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31845 #endif
31846 }
31847 return resultobj;
31848 fail:
31849 return NULL;
31850 }
31851
31852
31853 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31854 PyObject *resultobj = 0;
31855 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31856 wxString *arg2 = 0 ;
31857 void *argp1 = 0 ;
31858 int res1 = 0 ;
31859 bool temp2 = false ;
31860 PyObject * obj0 = 0 ;
31861 PyObject * obj1 = 0 ;
31862 char * kwnames[] = {
31863 (char *) "self",(char *) "format", NULL
31864 };
31865
31866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31868 if (!SWIG_IsOK(res1)) {
31869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31870 }
31871 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31872 {
31873 arg2 = wxString_in_helper(obj1);
31874 if (arg2 == NULL) SWIG_fail;
31875 temp2 = true;
31876 }
31877 {
31878 PyThreadState* __tstate = wxPyBeginAllowThreads();
31879 (arg1)->SetId((wxString const &)*arg2);
31880 wxPyEndAllowThreads(__tstate);
31881 if (PyErr_Occurred()) SWIG_fail;
31882 }
31883 resultobj = SWIG_Py_Void();
31884 {
31885 if (temp2)
31886 delete arg2;
31887 }
31888 return resultobj;
31889 fail:
31890 {
31891 if (temp2)
31892 delete arg2;
31893 }
31894 return NULL;
31895 }
31896
31897
31898 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31899 PyObject *obj;
31900 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31901 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31902 return SWIG_Py_Void();
31903 }
31904
31905 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31906 return SWIG_Python_InitShadowInstance(args);
31907 }
31908
31909 SWIGINTERN int FormatInvalid_set(PyObject *) {
31910 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31911 return 1;
31912 }
31913
31914
31915 SWIGINTERN PyObject *FormatInvalid_get(void) {
31916 PyObject *pyobj = 0;
31917
31918 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
31919 return pyobj;
31920 }
31921
31922
31923 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31924 PyObject *resultobj = 0;
31925 wxDataObject *arg1 = (wxDataObject *) 0 ;
31926 void *argp1 = 0 ;
31927 int res1 = 0 ;
31928 PyObject *swig_obj[1] ;
31929
31930 if (!args) SWIG_fail;
31931 swig_obj[0] = args;
31932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
31933 if (!SWIG_IsOK(res1)) {
31934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
31935 }
31936 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31937 {
31938 PyThreadState* __tstate = wxPyBeginAllowThreads();
31939 delete arg1;
31940
31941 wxPyEndAllowThreads(__tstate);
31942 if (PyErr_Occurred()) SWIG_fail;
31943 }
31944 resultobj = SWIG_Py_Void();
31945 return resultobj;
31946 fail:
31947 return NULL;
31948 }
31949
31950
31951 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31952 PyObject *resultobj = 0;
31953 wxDataObject *arg1 = (wxDataObject *) 0 ;
31954 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31955 SwigValueWrapper<wxDataFormat > result;
31956 void *argp1 = 0 ;
31957 int res1 = 0 ;
31958 int val2 ;
31959 int ecode2 = 0 ;
31960 PyObject * obj0 = 0 ;
31961 PyObject * obj1 = 0 ;
31962 char * kwnames[] = {
31963 (char *) "self",(char *) "dir", NULL
31964 };
31965
31966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31968 if (!SWIG_IsOK(res1)) {
31969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31970 }
31971 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31972 if (obj1) {
31973 ecode2 = SWIG_AsVal_int(obj1, &val2);
31974 if (!SWIG_IsOK(ecode2)) {
31975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31976 }
31977 arg2 = static_cast< wxDataObject::Direction >(val2);
31978 }
31979 {
31980 PyThreadState* __tstate = wxPyBeginAllowThreads();
31981 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
31982 wxPyEndAllowThreads(__tstate);
31983 if (PyErr_Occurred()) SWIG_fail;
31984 }
31985 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31986 return resultobj;
31987 fail:
31988 return NULL;
31989 }
31990
31991
31992 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31993 PyObject *resultobj = 0;
31994 wxDataObject *arg1 = (wxDataObject *) 0 ;
31995 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31996 size_t result;
31997 void *argp1 = 0 ;
31998 int res1 = 0 ;
31999 int val2 ;
32000 int ecode2 = 0 ;
32001 PyObject * obj0 = 0 ;
32002 PyObject * obj1 = 0 ;
32003 char * kwnames[] = {
32004 (char *) "self",(char *) "dir", NULL
32005 };
32006
32007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32009 if (!SWIG_IsOK(res1)) {
32010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32011 }
32012 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32013 if (obj1) {
32014 ecode2 = SWIG_AsVal_int(obj1, &val2);
32015 if (!SWIG_IsOK(ecode2)) {
32016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32017 }
32018 arg2 = static_cast< wxDataObject::Direction >(val2);
32019 }
32020 {
32021 PyThreadState* __tstate = wxPyBeginAllowThreads();
32022 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32023 wxPyEndAllowThreads(__tstate);
32024 if (PyErr_Occurred()) SWIG_fail;
32025 }
32026 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32027 return resultobj;
32028 fail:
32029 return NULL;
32030 }
32031
32032
32033 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32034 PyObject *resultobj = 0;
32035 wxDataObject *arg1 = (wxDataObject *) 0 ;
32036 wxDataFormat *arg2 = 0 ;
32037 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32038 bool result;
32039 void *argp1 = 0 ;
32040 int res1 = 0 ;
32041 void *argp2 = 0 ;
32042 int res2 = 0 ;
32043 int val3 ;
32044 int ecode3 = 0 ;
32045 PyObject * obj0 = 0 ;
32046 PyObject * obj1 = 0 ;
32047 PyObject * obj2 = 0 ;
32048 char * kwnames[] = {
32049 (char *) "self",(char *) "format",(char *) "dir", NULL
32050 };
32051
32052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32054 if (!SWIG_IsOK(res1)) {
32055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32056 }
32057 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32058 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32059 if (!SWIG_IsOK(res2)) {
32060 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32061 }
32062 if (!argp2) {
32063 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32064 }
32065 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32066 if (obj2) {
32067 ecode3 = SWIG_AsVal_int(obj2, &val3);
32068 if (!SWIG_IsOK(ecode3)) {
32069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32070 }
32071 arg3 = static_cast< wxDataObject::Direction >(val3);
32072 }
32073 {
32074 PyThreadState* __tstate = wxPyBeginAllowThreads();
32075 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32076 wxPyEndAllowThreads(__tstate);
32077 if (PyErr_Occurred()) SWIG_fail;
32078 }
32079 {
32080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32081 }
32082 return resultobj;
32083 fail:
32084 return NULL;
32085 }
32086
32087
32088 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32089 PyObject *resultobj = 0;
32090 wxDataObject *arg1 = (wxDataObject *) 0 ;
32091 wxDataFormat *arg2 = 0 ;
32092 size_t result;
32093 void *argp1 = 0 ;
32094 int res1 = 0 ;
32095 void *argp2 = 0 ;
32096 int res2 = 0 ;
32097 PyObject * obj0 = 0 ;
32098 PyObject * obj1 = 0 ;
32099 char * kwnames[] = {
32100 (char *) "self",(char *) "format", NULL
32101 };
32102
32103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",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_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32107 }
32108 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32109 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32110 if (!SWIG_IsOK(res2)) {
32111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32112 }
32113 if (!argp2) {
32114 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32115 }
32116 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32117 {
32118 PyThreadState* __tstate = wxPyBeginAllowThreads();
32119 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32120 wxPyEndAllowThreads(__tstate);
32121 if (PyErr_Occurred()) SWIG_fail;
32122 }
32123 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32124 return resultobj;
32125 fail:
32126 return NULL;
32127 }
32128
32129
32130 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32131 PyObject *resultobj = 0;
32132 wxDataObject *arg1 = (wxDataObject *) 0 ;
32133 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32134 PyObject *result = 0 ;
32135 void *argp1 = 0 ;
32136 int res1 = 0 ;
32137 int val2 ;
32138 int ecode2 = 0 ;
32139 PyObject * obj0 = 0 ;
32140 PyObject * obj1 = 0 ;
32141 char * kwnames[] = {
32142 (char *) "self",(char *) "dir", NULL
32143 };
32144
32145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32147 if (!SWIG_IsOK(res1)) {
32148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32149 }
32150 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32151 if (obj1) {
32152 ecode2 = SWIG_AsVal_int(obj1, &val2);
32153 if (!SWIG_IsOK(ecode2)) {
32154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32155 }
32156 arg2 = static_cast< wxDataObject::Direction >(val2);
32157 }
32158 {
32159 PyThreadState* __tstate = wxPyBeginAllowThreads();
32160 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32161 wxPyEndAllowThreads(__tstate);
32162 if (PyErr_Occurred()) SWIG_fail;
32163 }
32164 resultobj = result;
32165 return resultobj;
32166 fail:
32167 return NULL;
32168 }
32169
32170
32171 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32172 PyObject *resultobj = 0;
32173 wxDataObject *arg1 = (wxDataObject *) 0 ;
32174 wxDataFormat *arg2 = 0 ;
32175 PyObject *result = 0 ;
32176 void *argp1 = 0 ;
32177 int res1 = 0 ;
32178 void *argp2 = 0 ;
32179 int res2 = 0 ;
32180 PyObject * obj0 = 0 ;
32181 PyObject * obj1 = 0 ;
32182 char * kwnames[] = {
32183 (char *) "self",(char *) "format", NULL
32184 };
32185
32186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32188 if (!SWIG_IsOK(res1)) {
32189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32190 }
32191 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32192 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32193 if (!SWIG_IsOK(res2)) {
32194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32195 }
32196 if (!argp2) {
32197 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32198 }
32199 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32200 {
32201 PyThreadState* __tstate = wxPyBeginAllowThreads();
32202 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32203 wxPyEndAllowThreads(__tstate);
32204 if (PyErr_Occurred()) SWIG_fail;
32205 }
32206 resultobj = result;
32207 return resultobj;
32208 fail:
32209 return NULL;
32210 }
32211
32212
32213 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32214 PyObject *resultobj = 0;
32215 wxDataObject *arg1 = (wxDataObject *) 0 ;
32216 wxDataFormat *arg2 = 0 ;
32217 PyObject *arg3 = (PyObject *) 0 ;
32218 bool result;
32219 void *argp1 = 0 ;
32220 int res1 = 0 ;
32221 void *argp2 = 0 ;
32222 int res2 = 0 ;
32223 PyObject * obj0 = 0 ;
32224 PyObject * obj1 = 0 ;
32225 PyObject * obj2 = 0 ;
32226 char * kwnames[] = {
32227 (char *) "self",(char *) "format",(char *) "data", NULL
32228 };
32229
32230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32232 if (!SWIG_IsOK(res1)) {
32233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32234 }
32235 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32236 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32237 if (!SWIG_IsOK(res2)) {
32238 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32239 }
32240 if (!argp2) {
32241 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32242 }
32243 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32244 arg3 = obj2;
32245 {
32246 PyThreadState* __tstate = wxPyBeginAllowThreads();
32247 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32248 wxPyEndAllowThreads(__tstate);
32249 if (PyErr_Occurred()) SWIG_fail;
32250 }
32251 {
32252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32253 }
32254 return resultobj;
32255 fail:
32256 return NULL;
32257 }
32258
32259
32260 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32261 PyObject *obj;
32262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32263 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32264 return SWIG_Py_Void();
32265 }
32266
32267 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32268 PyObject *resultobj = 0;
32269 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32270 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32271 wxDataObjectSimple *result = 0 ;
32272 void *argp1 = 0 ;
32273 int res1 = 0 ;
32274 PyObject * obj0 = 0 ;
32275 char * kwnames[] = {
32276 (char *) "format", NULL
32277 };
32278
32279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32280 if (obj0) {
32281 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32282 if (!SWIG_IsOK(res1)) {
32283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32284 }
32285 if (!argp1) {
32286 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32287 }
32288 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32289 }
32290 {
32291 PyThreadState* __tstate = wxPyBeginAllowThreads();
32292 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32293 wxPyEndAllowThreads(__tstate);
32294 if (PyErr_Occurred()) SWIG_fail;
32295 }
32296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32297 return resultobj;
32298 fail:
32299 return NULL;
32300 }
32301
32302
32303 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32304 PyObject *resultobj = 0;
32305 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32306 wxDataFormat *result = 0 ;
32307 void *argp1 = 0 ;
32308 int res1 = 0 ;
32309 PyObject *swig_obj[1] ;
32310
32311 if (!args) SWIG_fail;
32312 swig_obj[0] = args;
32313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32314 if (!SWIG_IsOK(res1)) {
32315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32316 }
32317 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32318 {
32319 PyThreadState* __tstate = wxPyBeginAllowThreads();
32320 {
32321 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32322 result = (wxDataFormat *) &_result_ref;
32323 }
32324 wxPyEndAllowThreads(__tstate);
32325 if (PyErr_Occurred()) SWIG_fail;
32326 }
32327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32328 return resultobj;
32329 fail:
32330 return NULL;
32331 }
32332
32333
32334 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32335 PyObject *resultobj = 0;
32336 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32337 wxDataFormat *arg2 = 0 ;
32338 void *argp1 = 0 ;
32339 int res1 = 0 ;
32340 void *argp2 = 0 ;
32341 int res2 = 0 ;
32342 PyObject * obj0 = 0 ;
32343 PyObject * obj1 = 0 ;
32344 char * kwnames[] = {
32345 (char *) "self",(char *) "format", NULL
32346 };
32347
32348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32350 if (!SWIG_IsOK(res1)) {
32351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32352 }
32353 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32354 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32355 if (!SWIG_IsOK(res2)) {
32356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32357 }
32358 if (!argp2) {
32359 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32360 }
32361 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32362 {
32363 PyThreadState* __tstate = wxPyBeginAllowThreads();
32364 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32365 wxPyEndAllowThreads(__tstate);
32366 if (PyErr_Occurred()) SWIG_fail;
32367 }
32368 resultobj = SWIG_Py_Void();
32369 return resultobj;
32370 fail:
32371 return NULL;
32372 }
32373
32374
32375 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32376 PyObject *resultobj = 0;
32377 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32378 size_t result;
32379 void *argp1 = 0 ;
32380 int res1 = 0 ;
32381 PyObject *swig_obj[1] ;
32382
32383 if (!args) SWIG_fail;
32384 swig_obj[0] = args;
32385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32386 if (!SWIG_IsOK(res1)) {
32387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32388 }
32389 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32390 {
32391 PyThreadState* __tstate = wxPyBeginAllowThreads();
32392 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32393 wxPyEndAllowThreads(__tstate);
32394 if (PyErr_Occurred()) SWIG_fail;
32395 }
32396 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32397 return resultobj;
32398 fail:
32399 return NULL;
32400 }
32401
32402
32403 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32404 PyObject *resultobj = 0;
32405 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32406 PyObject *result = 0 ;
32407 void *argp1 = 0 ;
32408 int res1 = 0 ;
32409 PyObject *swig_obj[1] ;
32410
32411 if (!args) SWIG_fail;
32412 swig_obj[0] = args;
32413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32414 if (!SWIG_IsOK(res1)) {
32415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32416 }
32417 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32418 {
32419 PyThreadState* __tstate = wxPyBeginAllowThreads();
32420 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32421 wxPyEndAllowThreads(__tstate);
32422 if (PyErr_Occurred()) SWIG_fail;
32423 }
32424 resultobj = result;
32425 return resultobj;
32426 fail:
32427 return NULL;
32428 }
32429
32430
32431 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32432 PyObject *resultobj = 0;
32433 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32434 PyObject *arg2 = (PyObject *) 0 ;
32435 bool result;
32436 void *argp1 = 0 ;
32437 int res1 = 0 ;
32438 PyObject * obj0 = 0 ;
32439 PyObject * obj1 = 0 ;
32440 char * kwnames[] = {
32441 (char *) "self",(char *) "data", NULL
32442 };
32443
32444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",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_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32448 }
32449 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32450 arg2 = obj1;
32451 {
32452 PyThreadState* __tstate = wxPyBeginAllowThreads();
32453 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32454 wxPyEndAllowThreads(__tstate);
32455 if (PyErr_Occurred()) SWIG_fail;
32456 }
32457 {
32458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32459 }
32460 return resultobj;
32461 fail:
32462 return NULL;
32463 }
32464
32465
32466 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32467 PyObject *obj;
32468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32469 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32470 return SWIG_Py_Void();
32471 }
32472
32473 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32474 return SWIG_Python_InitShadowInstance(args);
32475 }
32476
32477 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32478 PyObject *resultobj = 0;
32479 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32480 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32481 wxPyDataObjectSimple *result = 0 ;
32482 void *argp1 = 0 ;
32483 int res1 = 0 ;
32484 PyObject * obj0 = 0 ;
32485 char * kwnames[] = {
32486 (char *) "format", NULL
32487 };
32488
32489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32490 if (obj0) {
32491 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32492 if (!SWIG_IsOK(res1)) {
32493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32494 }
32495 if (!argp1) {
32496 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32497 }
32498 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32499 }
32500 {
32501 PyThreadState* __tstate = wxPyBeginAllowThreads();
32502 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32503 wxPyEndAllowThreads(__tstate);
32504 if (PyErr_Occurred()) SWIG_fail;
32505 }
32506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32507 return resultobj;
32508 fail:
32509 return NULL;
32510 }
32511
32512
32513 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32514 PyObject *resultobj = 0;
32515 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32516 PyObject *arg2 = (PyObject *) 0 ;
32517 PyObject *arg3 = (PyObject *) 0 ;
32518 void *argp1 = 0 ;
32519 int res1 = 0 ;
32520 PyObject * obj0 = 0 ;
32521 PyObject * obj1 = 0 ;
32522 PyObject * obj2 = 0 ;
32523 char * kwnames[] = {
32524 (char *) "self",(char *) "self",(char *) "_class", NULL
32525 };
32526
32527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32529 if (!SWIG_IsOK(res1)) {
32530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32531 }
32532 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32533 arg2 = obj1;
32534 arg3 = obj2;
32535 {
32536 PyThreadState* __tstate = wxPyBeginAllowThreads();
32537 (arg1)->_setCallbackInfo(arg2,arg3);
32538 wxPyEndAllowThreads(__tstate);
32539 if (PyErr_Occurred()) SWIG_fail;
32540 }
32541 resultobj = SWIG_Py_Void();
32542 return resultobj;
32543 fail:
32544 return NULL;
32545 }
32546
32547
32548 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32549 PyObject *obj;
32550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32551 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32552 return SWIG_Py_Void();
32553 }
32554
32555 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32556 return SWIG_Python_InitShadowInstance(args);
32557 }
32558
32559 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32560 PyObject *resultobj = 0;
32561 wxDataObjectComposite *result = 0 ;
32562
32563 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32564 {
32565 PyThreadState* __tstate = wxPyBeginAllowThreads();
32566 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32567 wxPyEndAllowThreads(__tstate);
32568 if (PyErr_Occurred()) SWIG_fail;
32569 }
32570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32571 return resultobj;
32572 fail:
32573 return NULL;
32574 }
32575
32576
32577 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32578 PyObject *resultobj = 0;
32579 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32580 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32581 bool arg3 = (bool) false ;
32582 void *argp1 = 0 ;
32583 int res1 = 0 ;
32584 int res2 = 0 ;
32585 bool val3 ;
32586 int ecode3 = 0 ;
32587 PyObject * obj0 = 0 ;
32588 PyObject * obj1 = 0 ;
32589 PyObject * obj2 = 0 ;
32590 char * kwnames[] = {
32591 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32592 };
32593
32594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32596 if (!SWIG_IsOK(res1)) {
32597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32598 }
32599 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32600 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32601 if (!SWIG_IsOK(res2)) {
32602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32603 }
32604 if (obj2) {
32605 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32606 if (!SWIG_IsOK(ecode3)) {
32607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32608 }
32609 arg3 = static_cast< bool >(val3);
32610 }
32611 {
32612 PyThreadState* __tstate = wxPyBeginAllowThreads();
32613 (arg1)->Add(arg2,arg3);
32614 wxPyEndAllowThreads(__tstate);
32615 if (PyErr_Occurred()) SWIG_fail;
32616 }
32617 resultobj = SWIG_Py_Void();
32618 return resultobj;
32619 fail:
32620 return NULL;
32621 }
32622
32623
32624 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32625 PyObject *resultobj = 0;
32626 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32627 SwigValueWrapper<wxDataFormat > result;
32628 void *argp1 = 0 ;
32629 int res1 = 0 ;
32630 PyObject *swig_obj[1] ;
32631
32632 if (!args) SWIG_fail;
32633 swig_obj[0] = args;
32634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32635 if (!SWIG_IsOK(res1)) {
32636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32637 }
32638 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32639 {
32640 PyThreadState* __tstate = wxPyBeginAllowThreads();
32641 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32642 wxPyEndAllowThreads(__tstate);
32643 if (PyErr_Occurred()) SWIG_fail;
32644 }
32645 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32646 return resultobj;
32647 fail:
32648 return NULL;
32649 }
32650
32651
32652 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32653 PyObject *obj;
32654 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32655 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32656 return SWIG_Py_Void();
32657 }
32658
32659 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32660 return SWIG_Python_InitShadowInstance(args);
32661 }
32662
32663 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32664 PyObject *resultobj = 0;
32665 wxString const &arg1_defvalue = wxPyEmptyString ;
32666 wxString *arg1 = (wxString *) &arg1_defvalue ;
32667 wxTextDataObject *result = 0 ;
32668 bool temp1 = false ;
32669 PyObject * obj0 = 0 ;
32670 char * kwnames[] = {
32671 (char *) "text", NULL
32672 };
32673
32674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32675 if (obj0) {
32676 {
32677 arg1 = wxString_in_helper(obj0);
32678 if (arg1 == NULL) SWIG_fail;
32679 temp1 = true;
32680 }
32681 }
32682 {
32683 PyThreadState* __tstate = wxPyBeginAllowThreads();
32684 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32685 wxPyEndAllowThreads(__tstate);
32686 if (PyErr_Occurred()) SWIG_fail;
32687 }
32688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32689 {
32690 if (temp1)
32691 delete arg1;
32692 }
32693 return resultobj;
32694 fail:
32695 {
32696 if (temp1)
32697 delete arg1;
32698 }
32699 return NULL;
32700 }
32701
32702
32703 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32704 PyObject *resultobj = 0;
32705 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32706 size_t result;
32707 void *argp1 = 0 ;
32708 int res1 = 0 ;
32709 PyObject *swig_obj[1] ;
32710
32711 if (!args) SWIG_fail;
32712 swig_obj[0] = args;
32713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32714 if (!SWIG_IsOK(res1)) {
32715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32716 }
32717 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32718 {
32719 PyThreadState* __tstate = wxPyBeginAllowThreads();
32720 result = (size_t)(arg1)->GetTextLength();
32721 wxPyEndAllowThreads(__tstate);
32722 if (PyErr_Occurred()) SWIG_fail;
32723 }
32724 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32725 return resultobj;
32726 fail:
32727 return NULL;
32728 }
32729
32730
32731 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32732 PyObject *resultobj = 0;
32733 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32734 wxString result;
32735 void *argp1 = 0 ;
32736 int res1 = 0 ;
32737 PyObject *swig_obj[1] ;
32738
32739 if (!args) SWIG_fail;
32740 swig_obj[0] = args;
32741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32742 if (!SWIG_IsOK(res1)) {
32743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32744 }
32745 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32746 {
32747 PyThreadState* __tstate = wxPyBeginAllowThreads();
32748 result = (arg1)->GetText();
32749 wxPyEndAllowThreads(__tstate);
32750 if (PyErr_Occurred()) SWIG_fail;
32751 }
32752 {
32753 #if wxUSE_UNICODE
32754 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32755 #else
32756 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32757 #endif
32758 }
32759 return resultobj;
32760 fail:
32761 return NULL;
32762 }
32763
32764
32765 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32766 PyObject *resultobj = 0;
32767 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32768 wxString *arg2 = 0 ;
32769 void *argp1 = 0 ;
32770 int res1 = 0 ;
32771 bool temp2 = false ;
32772 PyObject * obj0 = 0 ;
32773 PyObject * obj1 = 0 ;
32774 char * kwnames[] = {
32775 (char *) "self",(char *) "text", NULL
32776 };
32777
32778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32780 if (!SWIG_IsOK(res1)) {
32781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32782 }
32783 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32784 {
32785 arg2 = wxString_in_helper(obj1);
32786 if (arg2 == NULL) SWIG_fail;
32787 temp2 = true;
32788 }
32789 {
32790 PyThreadState* __tstate = wxPyBeginAllowThreads();
32791 (arg1)->SetText((wxString const &)*arg2);
32792 wxPyEndAllowThreads(__tstate);
32793 if (PyErr_Occurred()) SWIG_fail;
32794 }
32795 resultobj = SWIG_Py_Void();
32796 {
32797 if (temp2)
32798 delete arg2;
32799 }
32800 return resultobj;
32801 fail:
32802 {
32803 if (temp2)
32804 delete arg2;
32805 }
32806 return NULL;
32807 }
32808
32809
32810 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32811 PyObject *obj;
32812 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32813 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32814 return SWIG_Py_Void();
32815 }
32816
32817 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32818 return SWIG_Python_InitShadowInstance(args);
32819 }
32820
32821 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32822 PyObject *resultobj = 0;
32823 wxString const &arg1_defvalue = wxPyEmptyString ;
32824 wxString *arg1 = (wxString *) &arg1_defvalue ;
32825 wxPyTextDataObject *result = 0 ;
32826 bool temp1 = false ;
32827 PyObject * obj0 = 0 ;
32828 char * kwnames[] = {
32829 (char *) "text", NULL
32830 };
32831
32832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32833 if (obj0) {
32834 {
32835 arg1 = wxString_in_helper(obj0);
32836 if (arg1 == NULL) SWIG_fail;
32837 temp1 = true;
32838 }
32839 }
32840 {
32841 PyThreadState* __tstate = wxPyBeginAllowThreads();
32842 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32843 wxPyEndAllowThreads(__tstate);
32844 if (PyErr_Occurred()) SWIG_fail;
32845 }
32846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32847 {
32848 if (temp1)
32849 delete arg1;
32850 }
32851 return resultobj;
32852 fail:
32853 {
32854 if (temp1)
32855 delete arg1;
32856 }
32857 return NULL;
32858 }
32859
32860
32861 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32862 PyObject *resultobj = 0;
32863 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32864 PyObject *arg2 = (PyObject *) 0 ;
32865 PyObject *arg3 = (PyObject *) 0 ;
32866 void *argp1 = 0 ;
32867 int res1 = 0 ;
32868 PyObject * obj0 = 0 ;
32869 PyObject * obj1 = 0 ;
32870 PyObject * obj2 = 0 ;
32871 char * kwnames[] = {
32872 (char *) "self",(char *) "self",(char *) "_class", NULL
32873 };
32874
32875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32877 if (!SWIG_IsOK(res1)) {
32878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32879 }
32880 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32881 arg2 = obj1;
32882 arg3 = obj2;
32883 {
32884 PyThreadState* __tstate = wxPyBeginAllowThreads();
32885 (arg1)->_setCallbackInfo(arg2,arg3);
32886 wxPyEndAllowThreads(__tstate);
32887 if (PyErr_Occurred()) SWIG_fail;
32888 }
32889 resultobj = SWIG_Py_Void();
32890 return resultobj;
32891 fail:
32892 return NULL;
32893 }
32894
32895
32896 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32897 PyObject *obj;
32898 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32899 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32900 return SWIG_Py_Void();
32901 }
32902
32903 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32904 return SWIG_Python_InitShadowInstance(args);
32905 }
32906
32907 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32908 PyObject *resultobj = 0;
32909 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32910 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32911 wxBitmapDataObject *result = 0 ;
32912 void *argp1 = 0 ;
32913 int res1 = 0 ;
32914 PyObject * obj0 = 0 ;
32915 char * kwnames[] = {
32916 (char *) "bitmap", NULL
32917 };
32918
32919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
32920 if (obj0) {
32921 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32922 if (!SWIG_IsOK(res1)) {
32923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32924 }
32925 if (!argp1) {
32926 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32927 }
32928 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32929 }
32930 {
32931 PyThreadState* __tstate = wxPyBeginAllowThreads();
32932 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
32933 wxPyEndAllowThreads(__tstate);
32934 if (PyErr_Occurred()) SWIG_fail;
32935 }
32936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
32937 return resultobj;
32938 fail:
32939 return NULL;
32940 }
32941
32942
32943 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32944 PyObject *resultobj = 0;
32945 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32946 wxBitmap result;
32947 void *argp1 = 0 ;
32948 int res1 = 0 ;
32949 PyObject *swig_obj[1] ;
32950
32951 if (!args) SWIG_fail;
32952 swig_obj[0] = args;
32953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32954 if (!SWIG_IsOK(res1)) {
32955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
32956 }
32957 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32958 {
32959 PyThreadState* __tstate = wxPyBeginAllowThreads();
32960 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
32961 wxPyEndAllowThreads(__tstate);
32962 if (PyErr_Occurred()) SWIG_fail;
32963 }
32964 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
32965 return resultobj;
32966 fail:
32967 return NULL;
32968 }
32969
32970
32971 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32972 PyObject *resultobj = 0;
32973 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32974 wxBitmap *arg2 = 0 ;
32975 void *argp1 = 0 ;
32976 int res1 = 0 ;
32977 void *argp2 = 0 ;
32978 int res2 = 0 ;
32979 PyObject * obj0 = 0 ;
32980 PyObject * obj1 = 0 ;
32981 char * kwnames[] = {
32982 (char *) "self",(char *) "bitmap", NULL
32983 };
32984
32985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
32986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32987 if (!SWIG_IsOK(res1)) {
32988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
32989 }
32990 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32991 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
32992 if (!SWIG_IsOK(res2)) {
32993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32994 }
32995 if (!argp2) {
32996 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32997 }
32998 arg2 = reinterpret_cast< wxBitmap * >(argp2);
32999 {
33000 PyThreadState* __tstate = wxPyBeginAllowThreads();
33001 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33002 wxPyEndAllowThreads(__tstate);
33003 if (PyErr_Occurred()) SWIG_fail;
33004 }
33005 resultobj = SWIG_Py_Void();
33006 return resultobj;
33007 fail:
33008 return NULL;
33009 }
33010
33011
33012 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33013 PyObject *obj;
33014 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33015 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33016 return SWIG_Py_Void();
33017 }
33018
33019 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33020 return SWIG_Python_InitShadowInstance(args);
33021 }
33022
33023 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33024 PyObject *resultobj = 0;
33025 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33026 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33027 wxPyBitmapDataObject *result = 0 ;
33028 void *argp1 = 0 ;
33029 int res1 = 0 ;
33030 PyObject * obj0 = 0 ;
33031 char * kwnames[] = {
33032 (char *) "bitmap", NULL
33033 };
33034
33035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33036 if (obj0) {
33037 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33038 if (!SWIG_IsOK(res1)) {
33039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33040 }
33041 if (!argp1) {
33042 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33043 }
33044 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33045 }
33046 {
33047 PyThreadState* __tstate = wxPyBeginAllowThreads();
33048 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33049 wxPyEndAllowThreads(__tstate);
33050 if (PyErr_Occurred()) SWIG_fail;
33051 }
33052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33053 return resultobj;
33054 fail:
33055 return NULL;
33056 }
33057
33058
33059 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33060 PyObject *resultobj = 0;
33061 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33062 PyObject *arg2 = (PyObject *) 0 ;
33063 PyObject *arg3 = (PyObject *) 0 ;
33064 void *argp1 = 0 ;
33065 int res1 = 0 ;
33066 PyObject * obj0 = 0 ;
33067 PyObject * obj1 = 0 ;
33068 PyObject * obj2 = 0 ;
33069 char * kwnames[] = {
33070 (char *) "self",(char *) "self",(char *) "_class", NULL
33071 };
33072
33073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33075 if (!SWIG_IsOK(res1)) {
33076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33077 }
33078 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33079 arg2 = obj1;
33080 arg3 = obj2;
33081 {
33082 PyThreadState* __tstate = wxPyBeginAllowThreads();
33083 (arg1)->_setCallbackInfo(arg2,arg3);
33084 wxPyEndAllowThreads(__tstate);
33085 if (PyErr_Occurred()) SWIG_fail;
33086 }
33087 resultobj = SWIG_Py_Void();
33088 return resultobj;
33089 fail:
33090 return NULL;
33091 }
33092
33093
33094 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33095 PyObject *obj;
33096 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33097 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33098 return SWIG_Py_Void();
33099 }
33100
33101 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33102 return SWIG_Python_InitShadowInstance(args);
33103 }
33104
33105 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33106 PyObject *resultobj = 0;
33107 wxFileDataObject *result = 0 ;
33108
33109 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33110 {
33111 PyThreadState* __tstate = wxPyBeginAllowThreads();
33112 result = (wxFileDataObject *)new wxFileDataObject();
33113 wxPyEndAllowThreads(__tstate);
33114 if (PyErr_Occurred()) SWIG_fail;
33115 }
33116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33117 return resultobj;
33118 fail:
33119 return NULL;
33120 }
33121
33122
33123 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33124 PyObject *resultobj = 0;
33125 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33126 wxArrayString *result = 0 ;
33127 void *argp1 = 0 ;
33128 int res1 = 0 ;
33129 PyObject *swig_obj[1] ;
33130
33131 if (!args) SWIG_fail;
33132 swig_obj[0] = args;
33133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33134 if (!SWIG_IsOK(res1)) {
33135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33136 }
33137 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33138 {
33139 PyThreadState* __tstate = wxPyBeginAllowThreads();
33140 {
33141 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33142 result = (wxArrayString *) &_result_ref;
33143 }
33144 wxPyEndAllowThreads(__tstate);
33145 if (PyErr_Occurred()) SWIG_fail;
33146 }
33147 {
33148 resultobj = wxArrayString2PyList_helper(*result);
33149 }
33150 return resultobj;
33151 fail:
33152 return NULL;
33153 }
33154
33155
33156 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33157 PyObject *resultobj = 0;
33158 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33159 wxString *arg2 = 0 ;
33160 void *argp1 = 0 ;
33161 int res1 = 0 ;
33162 bool temp2 = false ;
33163 PyObject * obj0 = 0 ;
33164 PyObject * obj1 = 0 ;
33165 char * kwnames[] = {
33166 (char *) "self",(char *) "filename", NULL
33167 };
33168
33169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33171 if (!SWIG_IsOK(res1)) {
33172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33173 }
33174 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33175 {
33176 arg2 = wxString_in_helper(obj1);
33177 if (arg2 == NULL) SWIG_fail;
33178 temp2 = true;
33179 }
33180 {
33181 PyThreadState* __tstate = wxPyBeginAllowThreads();
33182 (arg1)->AddFile((wxString const &)*arg2);
33183 wxPyEndAllowThreads(__tstate);
33184 if (PyErr_Occurred()) SWIG_fail;
33185 }
33186 resultobj = SWIG_Py_Void();
33187 {
33188 if (temp2)
33189 delete arg2;
33190 }
33191 return resultobj;
33192 fail:
33193 {
33194 if (temp2)
33195 delete arg2;
33196 }
33197 return NULL;
33198 }
33199
33200
33201 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33202 PyObject *obj;
33203 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33204 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33205 return SWIG_Py_Void();
33206 }
33207
33208 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33209 return SWIG_Python_InitShadowInstance(args);
33210 }
33211
33212 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33213 PyObject *resultobj = 0;
33214 wxDataFormat *arg1 = 0 ;
33215 wxCustomDataObject *result = 0 ;
33216 void *argp1 = 0 ;
33217 int res1 = 0 ;
33218
33219 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33221 if (!SWIG_IsOK(res1)) {
33222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33223 }
33224 if (!argp1) {
33225 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33226 }
33227 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33228 {
33229 PyThreadState* __tstate = wxPyBeginAllowThreads();
33230 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33231 wxPyEndAllowThreads(__tstate);
33232 if (PyErr_Occurred()) SWIG_fail;
33233 }
33234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33235 return resultobj;
33236 fail:
33237 return NULL;
33238 }
33239
33240
33241 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33242 PyObject *resultobj = 0;
33243 wxString *arg1 = 0 ;
33244 wxCustomDataObject *result = 0 ;
33245 bool temp1 = false ;
33246
33247 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33248 {
33249 arg1 = wxString_in_helper(swig_obj[0]);
33250 if (arg1 == NULL) SWIG_fail;
33251 temp1 = true;
33252 }
33253 {
33254 PyThreadState* __tstate = wxPyBeginAllowThreads();
33255 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33256 wxPyEndAllowThreads(__tstate);
33257 if (PyErr_Occurred()) SWIG_fail;
33258 }
33259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33260 {
33261 if (temp1)
33262 delete arg1;
33263 }
33264 return resultobj;
33265 fail:
33266 {
33267 if (temp1)
33268 delete arg1;
33269 }
33270 return NULL;
33271 }
33272
33273
33274 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33275 PyObject *resultobj = 0;
33276 wxCustomDataObject *result = 0 ;
33277
33278 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33279 {
33280 PyThreadState* __tstate = wxPyBeginAllowThreads();
33281 result = (wxCustomDataObject *)new wxCustomDataObject();
33282 wxPyEndAllowThreads(__tstate);
33283 if (PyErr_Occurred()) SWIG_fail;
33284 }
33285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33286 return resultobj;
33287 fail:
33288 return NULL;
33289 }
33290
33291
33292 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33293 int argc;
33294 PyObject *argv[2];
33295
33296 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33297 --argc;
33298 if (argc == 0) {
33299 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33300 }
33301 if (argc == 1) {
33302 int _v = 0;
33303 {
33304 {
33305 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33306 }
33307 }
33308 if (!_v) goto check_2;
33309 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33310 }
33311 check_2:
33312
33313 if (argc == 1) {
33314 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33315 }
33316
33317 fail:
33318 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33319 return NULL;
33320 }
33321
33322
33323 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33324 PyObject *resultobj = 0;
33325 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33326 PyObject *arg2 = (PyObject *) 0 ;
33327 bool result;
33328 void *argp1 = 0 ;
33329 int res1 = 0 ;
33330 PyObject * obj0 = 0 ;
33331 PyObject * obj1 = 0 ;
33332 char * kwnames[] = {
33333 (char *) "self",(char *) "data", NULL
33334 };
33335
33336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33338 if (!SWIG_IsOK(res1)) {
33339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33340 }
33341 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33342 arg2 = obj1;
33343 {
33344 PyThreadState* __tstate = wxPyBeginAllowThreads();
33345 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33346 wxPyEndAllowThreads(__tstate);
33347 if (PyErr_Occurred()) SWIG_fail;
33348 }
33349 {
33350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33351 }
33352 return resultobj;
33353 fail:
33354 return NULL;
33355 }
33356
33357
33358 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33359 PyObject *resultobj = 0;
33360 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33361 size_t result;
33362 void *argp1 = 0 ;
33363 int res1 = 0 ;
33364 PyObject *swig_obj[1] ;
33365
33366 if (!args) SWIG_fail;
33367 swig_obj[0] = args;
33368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33369 if (!SWIG_IsOK(res1)) {
33370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33371 }
33372 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33373 {
33374 PyThreadState* __tstate = wxPyBeginAllowThreads();
33375 result = (size_t)(arg1)->GetSize();
33376 wxPyEndAllowThreads(__tstate);
33377 if (PyErr_Occurred()) SWIG_fail;
33378 }
33379 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33380 return resultobj;
33381 fail:
33382 return NULL;
33383 }
33384
33385
33386 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33387 PyObject *resultobj = 0;
33388 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33389 PyObject *result = 0 ;
33390 void *argp1 = 0 ;
33391 int res1 = 0 ;
33392 PyObject *swig_obj[1] ;
33393
33394 if (!args) SWIG_fail;
33395 swig_obj[0] = args;
33396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33397 if (!SWIG_IsOK(res1)) {
33398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33399 }
33400 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33401 {
33402 PyThreadState* __tstate = wxPyBeginAllowThreads();
33403 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33404 wxPyEndAllowThreads(__tstate);
33405 if (PyErr_Occurred()) SWIG_fail;
33406 }
33407 resultobj = result;
33408 return resultobj;
33409 fail:
33410 return NULL;
33411 }
33412
33413
33414 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33415 PyObject *obj;
33416 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33417 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33418 return SWIG_Py_Void();
33419 }
33420
33421 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33422 return SWIG_Python_InitShadowInstance(args);
33423 }
33424
33425 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33426 PyObject *resultobj = 0;
33427 wxString const &arg1_defvalue = wxPyEmptyString ;
33428 wxString *arg1 = (wxString *) &arg1_defvalue ;
33429 wxURLDataObject *result = 0 ;
33430 bool temp1 = false ;
33431 PyObject * obj0 = 0 ;
33432 char * kwnames[] = {
33433 (char *) "url", NULL
33434 };
33435
33436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33437 if (obj0) {
33438 {
33439 arg1 = wxString_in_helper(obj0);
33440 if (arg1 == NULL) SWIG_fail;
33441 temp1 = true;
33442 }
33443 }
33444 {
33445 PyThreadState* __tstate = wxPyBeginAllowThreads();
33446 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33447 wxPyEndAllowThreads(__tstate);
33448 if (PyErr_Occurred()) SWIG_fail;
33449 }
33450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33451 {
33452 if (temp1)
33453 delete arg1;
33454 }
33455 return resultobj;
33456 fail:
33457 {
33458 if (temp1)
33459 delete arg1;
33460 }
33461 return NULL;
33462 }
33463
33464
33465 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33466 PyObject *resultobj = 0;
33467 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33468 wxString result;
33469 void *argp1 = 0 ;
33470 int res1 = 0 ;
33471 PyObject *swig_obj[1] ;
33472
33473 if (!args) SWIG_fail;
33474 swig_obj[0] = args;
33475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33476 if (!SWIG_IsOK(res1)) {
33477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33478 }
33479 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33480 {
33481 PyThreadState* __tstate = wxPyBeginAllowThreads();
33482 result = (arg1)->GetURL();
33483 wxPyEndAllowThreads(__tstate);
33484 if (PyErr_Occurred()) SWIG_fail;
33485 }
33486 {
33487 #if wxUSE_UNICODE
33488 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33489 #else
33490 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33491 #endif
33492 }
33493 return resultobj;
33494 fail:
33495 return NULL;
33496 }
33497
33498
33499 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33500 PyObject *resultobj = 0;
33501 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33502 wxString *arg2 = 0 ;
33503 void *argp1 = 0 ;
33504 int res1 = 0 ;
33505 bool temp2 = false ;
33506 PyObject * obj0 = 0 ;
33507 PyObject * obj1 = 0 ;
33508 char * kwnames[] = {
33509 (char *) "self",(char *) "url", NULL
33510 };
33511
33512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33514 if (!SWIG_IsOK(res1)) {
33515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33516 }
33517 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33518 {
33519 arg2 = wxString_in_helper(obj1);
33520 if (arg2 == NULL) SWIG_fail;
33521 temp2 = true;
33522 }
33523 {
33524 PyThreadState* __tstate = wxPyBeginAllowThreads();
33525 (arg1)->SetURL((wxString const &)*arg2);
33526 wxPyEndAllowThreads(__tstate);
33527 if (PyErr_Occurred()) SWIG_fail;
33528 }
33529 resultobj = SWIG_Py_Void();
33530 {
33531 if (temp2)
33532 delete arg2;
33533 }
33534 return resultobj;
33535 fail:
33536 {
33537 if (temp2)
33538 delete arg2;
33539 }
33540 return NULL;
33541 }
33542
33543
33544 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33545 PyObject *obj;
33546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33547 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33548 return SWIG_Py_Void();
33549 }
33550
33551 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33552 return SWIG_Python_InitShadowInstance(args);
33553 }
33554
33555 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33556 PyObject *resultobj = 0;
33557 wxMetafileDataObject *result = 0 ;
33558
33559 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33560 {
33561 PyThreadState* __tstate = wxPyBeginAllowThreads();
33562 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33563 wxPyEndAllowThreads(__tstate);
33564 if (PyErr_Occurred()) SWIG_fail;
33565 }
33566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33567 return resultobj;
33568 fail:
33569 return NULL;
33570 }
33571
33572
33573 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33574 PyObject *obj;
33575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33576 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33577 return SWIG_Py_Void();
33578 }
33579
33580 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33581 return SWIG_Python_InitShadowInstance(args);
33582 }
33583
33584 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33585 PyObject *resultobj = 0;
33586 wxDragResult arg1 ;
33587 bool result;
33588 int val1 ;
33589 int ecode1 = 0 ;
33590 PyObject * obj0 = 0 ;
33591 char * kwnames[] = {
33592 (char *) "res", NULL
33593 };
33594
33595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33596 ecode1 = SWIG_AsVal_int(obj0, &val1);
33597 if (!SWIG_IsOK(ecode1)) {
33598 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33599 }
33600 arg1 = static_cast< wxDragResult >(val1);
33601 {
33602 PyThreadState* __tstate = wxPyBeginAllowThreads();
33603 result = (bool)wxIsDragResultOk(arg1);
33604 wxPyEndAllowThreads(__tstate);
33605 if (PyErr_Occurred()) SWIG_fail;
33606 }
33607 {
33608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33609 }
33610 return resultobj;
33611 fail:
33612 return NULL;
33613 }
33614
33615
33616 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33617 PyObject *resultobj = 0;
33618 wxWindow *arg1 = (wxWindow *) 0 ;
33619 wxIcon const &arg2_defvalue = wxNullIcon ;
33620 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
33621 wxIcon const &arg3_defvalue = wxNullIcon ;
33622 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
33623 wxIcon const &arg4_defvalue = wxNullIcon ;
33624 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
33625 wxPyDropSource *result = 0 ;
33626 void *argp1 = 0 ;
33627 int res1 = 0 ;
33628 void *argp2 = 0 ;
33629 int res2 = 0 ;
33630 void *argp3 = 0 ;
33631 int res3 = 0 ;
33632 void *argp4 = 0 ;
33633 int res4 = 0 ;
33634 PyObject * obj0 = 0 ;
33635 PyObject * obj1 = 0 ;
33636 PyObject * obj2 = 0 ;
33637 PyObject * obj3 = 0 ;
33638 char * kwnames[] = {
33639 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33640 };
33641
33642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33644 if (!SWIG_IsOK(res1)) {
33645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33646 }
33647 arg1 = reinterpret_cast< wxWindow * >(argp1);
33648 if (obj1) {
33649 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
33650 if (!SWIG_IsOK(res2)) {
33651 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33652 }
33653 if (!argp2) {
33654 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33655 }
33656 arg2 = reinterpret_cast< wxIcon * >(argp2);
33657 }
33658 if (obj2) {
33659 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
33660 if (!SWIG_IsOK(res3)) {
33661 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33662 }
33663 if (!argp3) {
33664 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33665 }
33666 arg3 = reinterpret_cast< wxIcon * >(argp3);
33667 }
33668 if (obj3) {
33669 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
33670 if (!SWIG_IsOK(res4)) {
33671 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33672 }
33673 if (!argp4) {
33674 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33675 }
33676 arg4 = reinterpret_cast< wxIcon * >(argp4);
33677 }
33678 {
33679 PyThreadState* __tstate = wxPyBeginAllowThreads();
33680 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
33681 wxPyEndAllowThreads(__tstate);
33682 if (PyErr_Occurred()) SWIG_fail;
33683 }
33684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33685 return resultobj;
33686 fail:
33687 return NULL;
33688 }
33689
33690
33691 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33692 PyObject *resultobj = 0;
33693 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33694 PyObject *arg2 = (PyObject *) 0 ;
33695 PyObject *arg3 = (PyObject *) 0 ;
33696 int arg4 ;
33697 void *argp1 = 0 ;
33698 int res1 = 0 ;
33699 int val4 ;
33700 int ecode4 = 0 ;
33701 PyObject * obj0 = 0 ;
33702 PyObject * obj1 = 0 ;
33703 PyObject * obj2 = 0 ;
33704 PyObject * obj3 = 0 ;
33705 char * kwnames[] = {
33706 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33707 };
33708
33709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33711 if (!SWIG_IsOK(res1)) {
33712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33713 }
33714 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33715 arg2 = obj1;
33716 arg3 = obj2;
33717 ecode4 = SWIG_AsVal_int(obj3, &val4);
33718 if (!SWIG_IsOK(ecode4)) {
33719 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33720 }
33721 arg4 = static_cast< int >(val4);
33722 {
33723 PyThreadState* __tstate = wxPyBeginAllowThreads();
33724 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33725 wxPyEndAllowThreads(__tstate);
33726 if (PyErr_Occurred()) SWIG_fail;
33727 }
33728 resultobj = SWIG_Py_Void();
33729 return resultobj;
33730 fail:
33731 return NULL;
33732 }
33733
33734
33735 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33736 PyObject *resultobj = 0;
33737 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33738 void *argp1 = 0 ;
33739 int res1 = 0 ;
33740 PyObject *swig_obj[1] ;
33741
33742 if (!args) SWIG_fail;
33743 swig_obj[0] = args;
33744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33745 if (!SWIG_IsOK(res1)) {
33746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33747 }
33748 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33749 {
33750 PyThreadState* __tstate = wxPyBeginAllowThreads();
33751 delete arg1;
33752
33753 wxPyEndAllowThreads(__tstate);
33754 if (PyErr_Occurred()) SWIG_fail;
33755 }
33756 resultobj = SWIG_Py_Void();
33757 return resultobj;
33758 fail:
33759 return NULL;
33760 }
33761
33762
33763 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33764 PyObject *resultobj = 0;
33765 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33766 wxDataObject *arg2 = 0 ;
33767 void *argp1 = 0 ;
33768 int res1 = 0 ;
33769 void *argp2 = 0 ;
33770 int res2 = 0 ;
33771 PyObject * obj0 = 0 ;
33772 PyObject * obj1 = 0 ;
33773 char * kwnames[] = {
33774 (char *) "self",(char *) "data", NULL
33775 };
33776
33777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33779 if (!SWIG_IsOK(res1)) {
33780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33781 }
33782 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33783 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33784 if (!SWIG_IsOK(res2)) {
33785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33786 }
33787 if (!argp2) {
33788 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33789 }
33790 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33791 {
33792 PyThreadState* __tstate = wxPyBeginAllowThreads();
33793 (arg1)->SetData(*arg2);
33794 wxPyEndAllowThreads(__tstate);
33795 if (PyErr_Occurred()) SWIG_fail;
33796 }
33797 resultobj = SWIG_Py_Void();
33798 return resultobj;
33799 fail:
33800 return NULL;
33801 }
33802
33803
33804 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33805 PyObject *resultobj = 0;
33806 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33807 wxDataObject *result = 0 ;
33808 void *argp1 = 0 ;
33809 int res1 = 0 ;
33810 PyObject *swig_obj[1] ;
33811
33812 if (!args) SWIG_fail;
33813 swig_obj[0] = args;
33814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33815 if (!SWIG_IsOK(res1)) {
33816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33817 }
33818 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33819 {
33820 PyThreadState* __tstate = wxPyBeginAllowThreads();
33821 result = (wxDataObject *)(arg1)->GetDataObject();
33822 wxPyEndAllowThreads(__tstate);
33823 if (PyErr_Occurred()) SWIG_fail;
33824 }
33825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33826 return resultobj;
33827 fail:
33828 return NULL;
33829 }
33830
33831
33832 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33833 PyObject *resultobj = 0;
33834 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33835 wxDragResult arg2 ;
33836 wxCursor *arg3 = 0 ;
33837 void *argp1 = 0 ;
33838 int res1 = 0 ;
33839 int val2 ;
33840 int ecode2 = 0 ;
33841 void *argp3 = 0 ;
33842 int res3 = 0 ;
33843 PyObject * obj0 = 0 ;
33844 PyObject * obj1 = 0 ;
33845 PyObject * obj2 = 0 ;
33846 char * kwnames[] = {
33847 (char *) "self",(char *) "res",(char *) "cursor", NULL
33848 };
33849
33850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33852 if (!SWIG_IsOK(res1)) {
33853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33854 }
33855 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33856 ecode2 = SWIG_AsVal_int(obj1, &val2);
33857 if (!SWIG_IsOK(ecode2)) {
33858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33859 }
33860 arg2 = static_cast< wxDragResult >(val2);
33861 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33862 if (!SWIG_IsOK(res3)) {
33863 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33864 }
33865 if (!argp3) {
33866 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33867 }
33868 arg3 = reinterpret_cast< wxCursor * >(argp3);
33869 {
33870 PyThreadState* __tstate = wxPyBeginAllowThreads();
33871 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33872 wxPyEndAllowThreads(__tstate);
33873 if (PyErr_Occurred()) SWIG_fail;
33874 }
33875 resultobj = SWIG_Py_Void();
33876 return resultobj;
33877 fail:
33878 return NULL;
33879 }
33880
33881
33882 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33883 PyObject *resultobj = 0;
33884 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33885 int arg2 = (int) wxDrag_CopyOnly ;
33886 wxDragResult result;
33887 void *argp1 = 0 ;
33888 int res1 = 0 ;
33889 int val2 ;
33890 int ecode2 = 0 ;
33891 PyObject * obj0 = 0 ;
33892 PyObject * obj1 = 0 ;
33893 char * kwnames[] = {
33894 (char *) "self",(char *) "flags", NULL
33895 };
33896
33897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
33898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33899 if (!SWIG_IsOK(res1)) {
33900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33901 }
33902 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33903 if (obj1) {
33904 ecode2 = SWIG_AsVal_int(obj1, &val2);
33905 if (!SWIG_IsOK(ecode2)) {
33906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
33907 }
33908 arg2 = static_cast< int >(val2);
33909 }
33910 {
33911 PyThreadState* __tstate = wxPyBeginAllowThreads();
33912 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
33913 wxPyEndAllowThreads(__tstate);
33914 if (PyErr_Occurred()) SWIG_fail;
33915 }
33916 resultobj = SWIG_From_int(static_cast< int >(result));
33917 return resultobj;
33918 fail:
33919 return NULL;
33920 }
33921
33922
33923 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33924 PyObject *resultobj = 0;
33925 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33926 wxDragResult arg2 ;
33927 bool result;
33928 void *argp1 = 0 ;
33929 int res1 = 0 ;
33930 int val2 ;
33931 int ecode2 = 0 ;
33932 PyObject * obj0 = 0 ;
33933 PyObject * obj1 = 0 ;
33934 char * kwnames[] = {
33935 (char *) "self",(char *) "effect", NULL
33936 };
33937
33938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
33939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33940 if (!SWIG_IsOK(res1)) {
33941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33942 }
33943 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33944 ecode2 = SWIG_AsVal_int(obj1, &val2);
33945 if (!SWIG_IsOK(ecode2)) {
33946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
33947 }
33948 arg2 = static_cast< wxDragResult >(val2);
33949 {
33950 PyThreadState* __tstate = wxPyBeginAllowThreads();
33951 result = (bool)(arg1)->GiveFeedback(arg2);
33952 wxPyEndAllowThreads(__tstate);
33953 if (PyErr_Occurred()) SWIG_fail;
33954 }
33955 {
33956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33957 }
33958 return resultobj;
33959 fail:
33960 return NULL;
33961 }
33962
33963
33964 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33965 PyObject *obj;
33966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33967 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
33968 return SWIG_Py_Void();
33969 }
33970
33971 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33972 return SWIG_Python_InitShadowInstance(args);
33973 }
33974
33975 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33976 PyObject *resultobj = 0;
33977 wxDataObject *arg1 = (wxDataObject *) NULL ;
33978 wxPyDropTarget *result = 0 ;
33979 int res1 = 0 ;
33980 PyObject * obj0 = 0 ;
33981 char * kwnames[] = {
33982 (char *) "dataObject", NULL
33983 };
33984
33985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
33986 if (obj0) {
33987 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
33988 if (!SWIG_IsOK(res1)) {
33989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
33990 }
33991 }
33992 {
33993 PyThreadState* __tstate = wxPyBeginAllowThreads();
33994 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
33995 wxPyEndAllowThreads(__tstate);
33996 if (PyErr_Occurred()) SWIG_fail;
33997 }
33998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
33999 return resultobj;
34000 fail:
34001 return NULL;
34002 }
34003
34004
34005 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34006 PyObject *resultobj = 0;
34007 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34008 PyObject *arg2 = (PyObject *) 0 ;
34009 PyObject *arg3 = (PyObject *) 0 ;
34010 void *argp1 = 0 ;
34011 int res1 = 0 ;
34012 PyObject * obj0 = 0 ;
34013 PyObject * obj1 = 0 ;
34014 PyObject * obj2 = 0 ;
34015 char * kwnames[] = {
34016 (char *) "self",(char *) "self",(char *) "_class", NULL
34017 };
34018
34019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34021 if (!SWIG_IsOK(res1)) {
34022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34023 }
34024 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34025 arg2 = obj1;
34026 arg3 = obj2;
34027 {
34028 PyThreadState* __tstate = wxPyBeginAllowThreads();
34029 (arg1)->_setCallbackInfo(arg2,arg3);
34030 wxPyEndAllowThreads(__tstate);
34031 if (PyErr_Occurred()) SWIG_fail;
34032 }
34033 resultobj = SWIG_Py_Void();
34034 return resultobj;
34035 fail:
34036 return NULL;
34037 }
34038
34039
34040 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34041 PyObject *resultobj = 0;
34042 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34043 void *argp1 = 0 ;
34044 int res1 = 0 ;
34045 PyObject *swig_obj[1] ;
34046
34047 if (!args) SWIG_fail;
34048 swig_obj[0] = args;
34049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34050 if (!SWIG_IsOK(res1)) {
34051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34052 }
34053 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34054 {
34055 PyThreadState* __tstate = wxPyBeginAllowThreads();
34056 delete arg1;
34057
34058 wxPyEndAllowThreads(__tstate);
34059 if (PyErr_Occurred()) SWIG_fail;
34060 }
34061 resultobj = SWIG_Py_Void();
34062 return resultobj;
34063 fail:
34064 return NULL;
34065 }
34066
34067
34068 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34069 PyObject *resultobj = 0;
34070 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34071 wxDataObject *result = 0 ;
34072 void *argp1 = 0 ;
34073 int res1 = 0 ;
34074 PyObject *swig_obj[1] ;
34075
34076 if (!args) SWIG_fail;
34077 swig_obj[0] = args;
34078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34079 if (!SWIG_IsOK(res1)) {
34080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34081 }
34082 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34083 {
34084 PyThreadState* __tstate = wxPyBeginAllowThreads();
34085 result = (wxDataObject *)(arg1)->GetDataObject();
34086 wxPyEndAllowThreads(__tstate);
34087 if (PyErr_Occurred()) SWIG_fail;
34088 }
34089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34090 return resultobj;
34091 fail:
34092 return NULL;
34093 }
34094
34095
34096 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34097 PyObject *resultobj = 0;
34098 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34099 wxDataObject *arg2 = (wxDataObject *) 0 ;
34100 void *argp1 = 0 ;
34101 int res1 = 0 ;
34102 int res2 = 0 ;
34103 PyObject * obj0 = 0 ;
34104 PyObject * obj1 = 0 ;
34105 char * kwnames[] = {
34106 (char *) "self",(char *) "dataObject", NULL
34107 };
34108
34109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34111 if (!SWIG_IsOK(res1)) {
34112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34113 }
34114 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34115 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34116 if (!SWIG_IsOK(res2)) {
34117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34118 }
34119 {
34120 PyThreadState* __tstate = wxPyBeginAllowThreads();
34121 (arg1)->SetDataObject(arg2);
34122 wxPyEndAllowThreads(__tstate);
34123 if (PyErr_Occurred()) SWIG_fail;
34124 }
34125 resultobj = SWIG_Py_Void();
34126 return resultobj;
34127 fail:
34128 return NULL;
34129 }
34130
34131
34132 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34133 PyObject *resultobj = 0;
34134 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34135 int arg2 ;
34136 int arg3 ;
34137 wxDragResult arg4 ;
34138 wxDragResult result;
34139 void *argp1 = 0 ;
34140 int res1 = 0 ;
34141 int val2 ;
34142 int ecode2 = 0 ;
34143 int val3 ;
34144 int ecode3 = 0 ;
34145 int val4 ;
34146 int ecode4 = 0 ;
34147 PyObject * obj0 = 0 ;
34148 PyObject * obj1 = 0 ;
34149 PyObject * obj2 = 0 ;
34150 PyObject * obj3 = 0 ;
34151 char * kwnames[] = {
34152 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34153 };
34154
34155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34157 if (!SWIG_IsOK(res1)) {
34158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34159 }
34160 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34161 ecode2 = SWIG_AsVal_int(obj1, &val2);
34162 if (!SWIG_IsOK(ecode2)) {
34163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34164 }
34165 arg2 = static_cast< int >(val2);
34166 ecode3 = SWIG_AsVal_int(obj2, &val3);
34167 if (!SWIG_IsOK(ecode3)) {
34168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34169 }
34170 arg3 = static_cast< int >(val3);
34171 ecode4 = SWIG_AsVal_int(obj3, &val4);
34172 if (!SWIG_IsOK(ecode4)) {
34173 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34174 }
34175 arg4 = static_cast< wxDragResult >(val4);
34176 {
34177 PyThreadState* __tstate = wxPyBeginAllowThreads();
34178 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34179 wxPyEndAllowThreads(__tstate);
34180 if (PyErr_Occurred()) SWIG_fail;
34181 }
34182 resultobj = SWIG_From_int(static_cast< int >(result));
34183 return resultobj;
34184 fail:
34185 return NULL;
34186 }
34187
34188
34189 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34190 PyObject *resultobj = 0;
34191 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34192 int arg2 ;
34193 int arg3 ;
34194 wxDragResult arg4 ;
34195 wxDragResult result;
34196 void *argp1 = 0 ;
34197 int res1 = 0 ;
34198 int val2 ;
34199 int ecode2 = 0 ;
34200 int val3 ;
34201 int ecode3 = 0 ;
34202 int val4 ;
34203 int ecode4 = 0 ;
34204 PyObject * obj0 = 0 ;
34205 PyObject * obj1 = 0 ;
34206 PyObject * obj2 = 0 ;
34207 PyObject * obj3 = 0 ;
34208 char * kwnames[] = {
34209 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34210 };
34211
34212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34214 if (!SWIG_IsOK(res1)) {
34215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34216 }
34217 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34218 ecode2 = SWIG_AsVal_int(obj1, &val2);
34219 if (!SWIG_IsOK(ecode2)) {
34220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34221 }
34222 arg2 = static_cast< int >(val2);
34223 ecode3 = SWIG_AsVal_int(obj2, &val3);
34224 if (!SWIG_IsOK(ecode3)) {
34225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34226 }
34227 arg3 = static_cast< int >(val3);
34228 ecode4 = SWIG_AsVal_int(obj3, &val4);
34229 if (!SWIG_IsOK(ecode4)) {
34230 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34231 }
34232 arg4 = static_cast< wxDragResult >(val4);
34233 {
34234 PyThreadState* __tstate = wxPyBeginAllowThreads();
34235 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34236 wxPyEndAllowThreads(__tstate);
34237 if (PyErr_Occurred()) SWIG_fail;
34238 }
34239 resultobj = SWIG_From_int(static_cast< int >(result));
34240 return resultobj;
34241 fail:
34242 return NULL;
34243 }
34244
34245
34246 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34247 PyObject *resultobj = 0;
34248 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34249 void *argp1 = 0 ;
34250 int res1 = 0 ;
34251 PyObject *swig_obj[1] ;
34252
34253 if (!args) SWIG_fail;
34254 swig_obj[0] = args;
34255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34256 if (!SWIG_IsOK(res1)) {
34257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34258 }
34259 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34260 {
34261 PyThreadState* __tstate = wxPyBeginAllowThreads();
34262 (arg1)->OnLeave();
34263 wxPyEndAllowThreads(__tstate);
34264 if (PyErr_Occurred()) SWIG_fail;
34265 }
34266 resultobj = SWIG_Py_Void();
34267 return resultobj;
34268 fail:
34269 return NULL;
34270 }
34271
34272
34273 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34274 PyObject *resultobj = 0;
34275 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34276 int arg2 ;
34277 int arg3 ;
34278 bool result;
34279 void *argp1 = 0 ;
34280 int res1 = 0 ;
34281 int val2 ;
34282 int ecode2 = 0 ;
34283 int val3 ;
34284 int ecode3 = 0 ;
34285 PyObject * obj0 = 0 ;
34286 PyObject * obj1 = 0 ;
34287 PyObject * obj2 = 0 ;
34288 char * kwnames[] = {
34289 (char *) "self",(char *) "x",(char *) "y", NULL
34290 };
34291
34292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34294 if (!SWIG_IsOK(res1)) {
34295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34296 }
34297 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34298 ecode2 = SWIG_AsVal_int(obj1, &val2);
34299 if (!SWIG_IsOK(ecode2)) {
34300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34301 }
34302 arg2 = static_cast< int >(val2);
34303 ecode3 = SWIG_AsVal_int(obj2, &val3);
34304 if (!SWIG_IsOK(ecode3)) {
34305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34306 }
34307 arg3 = static_cast< int >(val3);
34308 {
34309 PyThreadState* __tstate = wxPyBeginAllowThreads();
34310 result = (bool)(arg1)->OnDrop(arg2,arg3);
34311 wxPyEndAllowThreads(__tstate);
34312 if (PyErr_Occurred()) SWIG_fail;
34313 }
34314 {
34315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34316 }
34317 return resultobj;
34318 fail:
34319 return NULL;
34320 }
34321
34322
34323 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34324 PyObject *resultobj = 0;
34325 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34326 bool result;
34327 void *argp1 = 0 ;
34328 int res1 = 0 ;
34329 PyObject *swig_obj[1] ;
34330
34331 if (!args) SWIG_fail;
34332 swig_obj[0] = args;
34333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34334 if (!SWIG_IsOK(res1)) {
34335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34336 }
34337 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34338 {
34339 PyThreadState* __tstate = wxPyBeginAllowThreads();
34340 result = (bool)(arg1)->GetData();
34341 wxPyEndAllowThreads(__tstate);
34342 if (PyErr_Occurred()) SWIG_fail;
34343 }
34344 {
34345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34346 }
34347 return resultobj;
34348 fail:
34349 return NULL;
34350 }
34351
34352
34353 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34354 PyObject *resultobj = 0;
34355 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34356 wxDragResult arg2 ;
34357 void *argp1 = 0 ;
34358 int res1 = 0 ;
34359 int val2 ;
34360 int ecode2 = 0 ;
34361 PyObject * obj0 = 0 ;
34362 PyObject * obj1 = 0 ;
34363 char * kwnames[] = {
34364 (char *) "self",(char *) "action", NULL
34365 };
34366
34367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34369 if (!SWIG_IsOK(res1)) {
34370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34371 }
34372 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34373 ecode2 = SWIG_AsVal_int(obj1, &val2);
34374 if (!SWIG_IsOK(ecode2)) {
34375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34376 }
34377 arg2 = static_cast< wxDragResult >(val2);
34378 {
34379 PyThreadState* __tstate = wxPyBeginAllowThreads();
34380 (arg1)->SetDefaultAction(arg2);
34381 wxPyEndAllowThreads(__tstate);
34382 if (PyErr_Occurred()) SWIG_fail;
34383 }
34384 resultobj = SWIG_Py_Void();
34385 return resultobj;
34386 fail:
34387 return NULL;
34388 }
34389
34390
34391 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34392 PyObject *resultobj = 0;
34393 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34394 wxDragResult result;
34395 void *argp1 = 0 ;
34396 int res1 = 0 ;
34397 PyObject *swig_obj[1] ;
34398
34399 if (!args) SWIG_fail;
34400 swig_obj[0] = args;
34401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34402 if (!SWIG_IsOK(res1)) {
34403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34404 }
34405 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34406 {
34407 PyThreadState* __tstate = wxPyBeginAllowThreads();
34408 result = (wxDragResult)(arg1)->GetDefaultAction();
34409 wxPyEndAllowThreads(__tstate);
34410 if (PyErr_Occurred()) SWIG_fail;
34411 }
34412 resultobj = SWIG_From_int(static_cast< int >(result));
34413 return resultobj;
34414 fail:
34415 return NULL;
34416 }
34417
34418
34419 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34420 PyObject *obj;
34421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34422 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34423 return SWIG_Py_Void();
34424 }
34425
34426 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34427 return SWIG_Python_InitShadowInstance(args);
34428 }
34429
34430 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34431 PyObject *resultobj = 0;
34432 wxPyTextDropTarget *result = 0 ;
34433
34434 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34435 {
34436 PyThreadState* __tstate = wxPyBeginAllowThreads();
34437 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34438 wxPyEndAllowThreads(__tstate);
34439 if (PyErr_Occurred()) SWIG_fail;
34440 }
34441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34442 return resultobj;
34443 fail:
34444 return NULL;
34445 }
34446
34447
34448 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34449 PyObject *resultobj = 0;
34450 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34451 PyObject *arg2 = (PyObject *) 0 ;
34452 PyObject *arg3 = (PyObject *) 0 ;
34453 void *argp1 = 0 ;
34454 int res1 = 0 ;
34455 PyObject * obj0 = 0 ;
34456 PyObject * obj1 = 0 ;
34457 PyObject * obj2 = 0 ;
34458 char * kwnames[] = {
34459 (char *) "self",(char *) "self",(char *) "_class", NULL
34460 };
34461
34462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34464 if (!SWIG_IsOK(res1)) {
34465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34466 }
34467 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34468 arg2 = obj1;
34469 arg3 = obj2;
34470 {
34471 PyThreadState* __tstate = wxPyBeginAllowThreads();
34472 (arg1)->_setCallbackInfo(arg2,arg3);
34473 wxPyEndAllowThreads(__tstate);
34474 if (PyErr_Occurred()) SWIG_fail;
34475 }
34476 resultobj = SWIG_Py_Void();
34477 return resultobj;
34478 fail:
34479 return NULL;
34480 }
34481
34482
34483 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34484 PyObject *resultobj = 0;
34485 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34486 int arg2 ;
34487 int arg3 ;
34488 wxString *arg4 = 0 ;
34489 bool result;
34490 void *argp1 = 0 ;
34491 int res1 = 0 ;
34492 int val2 ;
34493 int ecode2 = 0 ;
34494 int val3 ;
34495 int ecode3 = 0 ;
34496 bool temp4 = false ;
34497 PyObject * obj0 = 0 ;
34498 PyObject * obj1 = 0 ;
34499 PyObject * obj2 = 0 ;
34500 PyObject * obj3 = 0 ;
34501 char * kwnames[] = {
34502 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34503 };
34504
34505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34507 if (!SWIG_IsOK(res1)) {
34508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34509 }
34510 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34511 ecode2 = SWIG_AsVal_int(obj1, &val2);
34512 if (!SWIG_IsOK(ecode2)) {
34513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34514 }
34515 arg2 = static_cast< int >(val2);
34516 ecode3 = SWIG_AsVal_int(obj2, &val3);
34517 if (!SWIG_IsOK(ecode3)) {
34518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34519 }
34520 arg3 = static_cast< int >(val3);
34521 {
34522 arg4 = wxString_in_helper(obj3);
34523 if (arg4 == NULL) SWIG_fail;
34524 temp4 = true;
34525 }
34526 {
34527 PyThreadState* __tstate = wxPyBeginAllowThreads();
34528 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34529 wxPyEndAllowThreads(__tstate);
34530 if (PyErr_Occurred()) SWIG_fail;
34531 }
34532 {
34533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34534 }
34535 {
34536 if (temp4)
34537 delete arg4;
34538 }
34539 return resultobj;
34540 fail:
34541 {
34542 if (temp4)
34543 delete arg4;
34544 }
34545 return NULL;
34546 }
34547
34548
34549 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34550 PyObject *resultobj = 0;
34551 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34552 int arg2 ;
34553 int arg3 ;
34554 wxDragResult arg4 ;
34555 wxDragResult result;
34556 void *argp1 = 0 ;
34557 int res1 = 0 ;
34558 int val2 ;
34559 int ecode2 = 0 ;
34560 int val3 ;
34561 int ecode3 = 0 ;
34562 int val4 ;
34563 int ecode4 = 0 ;
34564 PyObject * obj0 = 0 ;
34565 PyObject * obj1 = 0 ;
34566 PyObject * obj2 = 0 ;
34567 PyObject * obj3 = 0 ;
34568 char * kwnames[] = {
34569 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34570 };
34571
34572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34574 if (!SWIG_IsOK(res1)) {
34575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34576 }
34577 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34578 ecode2 = SWIG_AsVal_int(obj1, &val2);
34579 if (!SWIG_IsOK(ecode2)) {
34580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34581 }
34582 arg2 = static_cast< int >(val2);
34583 ecode3 = SWIG_AsVal_int(obj2, &val3);
34584 if (!SWIG_IsOK(ecode3)) {
34585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34586 }
34587 arg3 = static_cast< int >(val3);
34588 ecode4 = SWIG_AsVal_int(obj3, &val4);
34589 if (!SWIG_IsOK(ecode4)) {
34590 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34591 }
34592 arg4 = static_cast< wxDragResult >(val4);
34593 {
34594 PyThreadState* __tstate = wxPyBeginAllowThreads();
34595 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34596 wxPyEndAllowThreads(__tstate);
34597 if (PyErr_Occurred()) SWIG_fail;
34598 }
34599 resultobj = SWIG_From_int(static_cast< int >(result));
34600 return resultobj;
34601 fail:
34602 return NULL;
34603 }
34604
34605
34606 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34607 PyObject *resultobj = 0;
34608 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34609 int arg2 ;
34610 int arg3 ;
34611 wxDragResult arg4 ;
34612 wxDragResult result;
34613 void *argp1 = 0 ;
34614 int res1 = 0 ;
34615 int val2 ;
34616 int ecode2 = 0 ;
34617 int val3 ;
34618 int ecode3 = 0 ;
34619 int val4 ;
34620 int ecode4 = 0 ;
34621 PyObject * obj0 = 0 ;
34622 PyObject * obj1 = 0 ;
34623 PyObject * obj2 = 0 ;
34624 PyObject * obj3 = 0 ;
34625 char * kwnames[] = {
34626 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34627 };
34628
34629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34631 if (!SWIG_IsOK(res1)) {
34632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34633 }
34634 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34635 ecode2 = SWIG_AsVal_int(obj1, &val2);
34636 if (!SWIG_IsOK(ecode2)) {
34637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34638 }
34639 arg2 = static_cast< int >(val2);
34640 ecode3 = SWIG_AsVal_int(obj2, &val3);
34641 if (!SWIG_IsOK(ecode3)) {
34642 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34643 }
34644 arg3 = static_cast< int >(val3);
34645 ecode4 = SWIG_AsVal_int(obj3, &val4);
34646 if (!SWIG_IsOK(ecode4)) {
34647 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34648 }
34649 arg4 = static_cast< wxDragResult >(val4);
34650 {
34651 PyThreadState* __tstate = wxPyBeginAllowThreads();
34652 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34653 wxPyEndAllowThreads(__tstate);
34654 if (PyErr_Occurred()) SWIG_fail;
34655 }
34656 resultobj = SWIG_From_int(static_cast< int >(result));
34657 return resultobj;
34658 fail:
34659 return NULL;
34660 }
34661
34662
34663 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34664 PyObject *resultobj = 0;
34665 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34666 void *argp1 = 0 ;
34667 int res1 = 0 ;
34668 PyObject *swig_obj[1] ;
34669
34670 if (!args) SWIG_fail;
34671 swig_obj[0] = args;
34672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34673 if (!SWIG_IsOK(res1)) {
34674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34675 }
34676 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34677 {
34678 PyThreadState* __tstate = wxPyBeginAllowThreads();
34679 (arg1)->OnLeave();
34680 wxPyEndAllowThreads(__tstate);
34681 if (PyErr_Occurred()) SWIG_fail;
34682 }
34683 resultobj = SWIG_Py_Void();
34684 return resultobj;
34685 fail:
34686 return NULL;
34687 }
34688
34689
34690 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34691 PyObject *resultobj = 0;
34692 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34693 int arg2 ;
34694 int arg3 ;
34695 bool result;
34696 void *argp1 = 0 ;
34697 int res1 = 0 ;
34698 int val2 ;
34699 int ecode2 = 0 ;
34700 int val3 ;
34701 int ecode3 = 0 ;
34702 PyObject * obj0 = 0 ;
34703 PyObject * obj1 = 0 ;
34704 PyObject * obj2 = 0 ;
34705 char * kwnames[] = {
34706 (char *) "self",(char *) "x",(char *) "y", NULL
34707 };
34708
34709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34711 if (!SWIG_IsOK(res1)) {
34712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34713 }
34714 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34715 ecode2 = SWIG_AsVal_int(obj1, &val2);
34716 if (!SWIG_IsOK(ecode2)) {
34717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34718 }
34719 arg2 = static_cast< int >(val2);
34720 ecode3 = SWIG_AsVal_int(obj2, &val3);
34721 if (!SWIG_IsOK(ecode3)) {
34722 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34723 }
34724 arg3 = static_cast< int >(val3);
34725 {
34726 PyThreadState* __tstate = wxPyBeginAllowThreads();
34727 result = (bool)(arg1)->OnDrop(arg2,arg3);
34728 wxPyEndAllowThreads(__tstate);
34729 if (PyErr_Occurred()) SWIG_fail;
34730 }
34731 {
34732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34733 }
34734 return resultobj;
34735 fail:
34736 return NULL;
34737 }
34738
34739
34740 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34741 PyObject *resultobj = 0;
34742 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34743 int arg2 ;
34744 int arg3 ;
34745 wxDragResult arg4 ;
34746 wxDragResult result;
34747 void *argp1 = 0 ;
34748 int res1 = 0 ;
34749 int val2 ;
34750 int ecode2 = 0 ;
34751 int val3 ;
34752 int ecode3 = 0 ;
34753 int val4 ;
34754 int ecode4 = 0 ;
34755 PyObject * obj0 = 0 ;
34756 PyObject * obj1 = 0 ;
34757 PyObject * obj2 = 0 ;
34758 PyObject * obj3 = 0 ;
34759 char * kwnames[] = {
34760 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34761 };
34762
34763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34765 if (!SWIG_IsOK(res1)) {
34766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34767 }
34768 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34769 ecode2 = SWIG_AsVal_int(obj1, &val2);
34770 if (!SWIG_IsOK(ecode2)) {
34771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34772 }
34773 arg2 = static_cast< int >(val2);
34774 ecode3 = SWIG_AsVal_int(obj2, &val3);
34775 if (!SWIG_IsOK(ecode3)) {
34776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34777 }
34778 arg3 = static_cast< int >(val3);
34779 ecode4 = SWIG_AsVal_int(obj3, &val4);
34780 if (!SWIG_IsOK(ecode4)) {
34781 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34782 }
34783 arg4 = static_cast< wxDragResult >(val4);
34784 {
34785 PyThreadState* __tstate = wxPyBeginAllowThreads();
34786 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34787 wxPyEndAllowThreads(__tstate);
34788 if (PyErr_Occurred()) SWIG_fail;
34789 }
34790 resultobj = SWIG_From_int(static_cast< int >(result));
34791 return resultobj;
34792 fail:
34793 return NULL;
34794 }
34795
34796
34797 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34798 PyObject *obj;
34799 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34800 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34801 return SWIG_Py_Void();
34802 }
34803
34804 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34805 return SWIG_Python_InitShadowInstance(args);
34806 }
34807
34808 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34809 PyObject *resultobj = 0;
34810 wxPyFileDropTarget *result = 0 ;
34811
34812 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34813 {
34814 PyThreadState* __tstate = wxPyBeginAllowThreads();
34815 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34816 wxPyEndAllowThreads(__tstate);
34817 if (PyErr_Occurred()) SWIG_fail;
34818 }
34819 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34820 return resultobj;
34821 fail:
34822 return NULL;
34823 }
34824
34825
34826 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34827 PyObject *resultobj = 0;
34828 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34829 PyObject *arg2 = (PyObject *) 0 ;
34830 PyObject *arg3 = (PyObject *) 0 ;
34831 void *argp1 = 0 ;
34832 int res1 = 0 ;
34833 PyObject * obj0 = 0 ;
34834 PyObject * obj1 = 0 ;
34835 PyObject * obj2 = 0 ;
34836 char * kwnames[] = {
34837 (char *) "self",(char *) "self",(char *) "_class", NULL
34838 };
34839
34840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34842 if (!SWIG_IsOK(res1)) {
34843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34844 }
34845 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34846 arg2 = obj1;
34847 arg3 = obj2;
34848 {
34849 PyThreadState* __tstate = wxPyBeginAllowThreads();
34850 (arg1)->_setCallbackInfo(arg2,arg3);
34851 wxPyEndAllowThreads(__tstate);
34852 if (PyErr_Occurred()) SWIG_fail;
34853 }
34854 resultobj = SWIG_Py_Void();
34855 return resultobj;
34856 fail:
34857 return NULL;
34858 }
34859
34860
34861 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34862 PyObject *resultobj = 0;
34863 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34864 int arg2 ;
34865 int arg3 ;
34866 wxArrayString *arg4 = 0 ;
34867 bool result;
34868 void *argp1 = 0 ;
34869 int res1 = 0 ;
34870 int val2 ;
34871 int ecode2 = 0 ;
34872 int val3 ;
34873 int ecode3 = 0 ;
34874 bool temp4 = false ;
34875 PyObject * obj0 = 0 ;
34876 PyObject * obj1 = 0 ;
34877 PyObject * obj2 = 0 ;
34878 PyObject * obj3 = 0 ;
34879 char * kwnames[] = {
34880 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
34881 };
34882
34883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34885 if (!SWIG_IsOK(res1)) {
34886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34887 }
34888 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34889 ecode2 = SWIG_AsVal_int(obj1, &val2);
34890 if (!SWIG_IsOK(ecode2)) {
34891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
34892 }
34893 arg2 = static_cast< int >(val2);
34894 ecode3 = SWIG_AsVal_int(obj2, &val3);
34895 if (!SWIG_IsOK(ecode3)) {
34896 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
34897 }
34898 arg3 = static_cast< int >(val3);
34899 {
34900 if (! PySequence_Check(obj3)) {
34901 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
34902 SWIG_fail;
34903 }
34904 arg4 = new wxArrayString;
34905 temp4 = true;
34906 int i, len=PySequence_Length(obj3);
34907 for (i=0; i<len; i++) {
34908 PyObject* item = PySequence_GetItem(obj3, i);
34909 wxString* s = wxString_in_helper(item);
34910 if (PyErr_Occurred()) SWIG_fail;
34911 arg4->Add(*s);
34912 delete s;
34913 Py_DECREF(item);
34914 }
34915 }
34916 {
34917 PyThreadState* __tstate = wxPyBeginAllowThreads();
34918 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
34919 wxPyEndAllowThreads(__tstate);
34920 if (PyErr_Occurred()) SWIG_fail;
34921 }
34922 {
34923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34924 }
34925 {
34926 if (temp4) delete arg4;
34927 }
34928 return resultobj;
34929 fail:
34930 {
34931 if (temp4) delete arg4;
34932 }
34933 return NULL;
34934 }
34935
34936
34937 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34938 PyObject *resultobj = 0;
34939 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34940 int arg2 ;
34941 int arg3 ;
34942 wxDragResult arg4 ;
34943 wxDragResult result;
34944 void *argp1 = 0 ;
34945 int res1 = 0 ;
34946 int val2 ;
34947 int ecode2 = 0 ;
34948 int val3 ;
34949 int ecode3 = 0 ;
34950 int val4 ;
34951 int ecode4 = 0 ;
34952 PyObject * obj0 = 0 ;
34953 PyObject * obj1 = 0 ;
34954 PyObject * obj2 = 0 ;
34955 PyObject * obj3 = 0 ;
34956 char * kwnames[] = {
34957 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34958 };
34959
34960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34962 if (!SWIG_IsOK(res1)) {
34963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34964 }
34965 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34966 ecode2 = SWIG_AsVal_int(obj1, &val2);
34967 if (!SWIG_IsOK(ecode2)) {
34968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34969 }
34970 arg2 = static_cast< int >(val2);
34971 ecode3 = SWIG_AsVal_int(obj2, &val3);
34972 if (!SWIG_IsOK(ecode3)) {
34973 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34974 }
34975 arg3 = static_cast< int >(val3);
34976 ecode4 = SWIG_AsVal_int(obj3, &val4);
34977 if (!SWIG_IsOK(ecode4)) {
34978 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34979 }
34980 arg4 = static_cast< wxDragResult >(val4);
34981 {
34982 PyThreadState* __tstate = wxPyBeginAllowThreads();
34983 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34984 wxPyEndAllowThreads(__tstate);
34985 if (PyErr_Occurred()) SWIG_fail;
34986 }
34987 resultobj = SWIG_From_int(static_cast< int >(result));
34988 return resultobj;
34989 fail:
34990 return NULL;
34991 }
34992
34993
34994 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34995 PyObject *resultobj = 0;
34996 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34997 int arg2 ;
34998 int arg3 ;
34999 wxDragResult arg4 ;
35000 wxDragResult result;
35001 void *argp1 = 0 ;
35002 int res1 = 0 ;
35003 int val2 ;
35004 int ecode2 = 0 ;
35005 int val3 ;
35006 int ecode3 = 0 ;
35007 int val4 ;
35008 int ecode4 = 0 ;
35009 PyObject * obj0 = 0 ;
35010 PyObject * obj1 = 0 ;
35011 PyObject * obj2 = 0 ;
35012 PyObject * obj3 = 0 ;
35013 char * kwnames[] = {
35014 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35015 };
35016
35017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35019 if (!SWIG_IsOK(res1)) {
35020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35021 }
35022 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35023 ecode2 = SWIG_AsVal_int(obj1, &val2);
35024 if (!SWIG_IsOK(ecode2)) {
35025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35026 }
35027 arg2 = static_cast< int >(val2);
35028 ecode3 = SWIG_AsVal_int(obj2, &val3);
35029 if (!SWIG_IsOK(ecode3)) {
35030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35031 }
35032 arg3 = static_cast< int >(val3);
35033 ecode4 = SWIG_AsVal_int(obj3, &val4);
35034 if (!SWIG_IsOK(ecode4)) {
35035 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35036 }
35037 arg4 = static_cast< wxDragResult >(val4);
35038 {
35039 PyThreadState* __tstate = wxPyBeginAllowThreads();
35040 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35041 wxPyEndAllowThreads(__tstate);
35042 if (PyErr_Occurred()) SWIG_fail;
35043 }
35044 resultobj = SWIG_From_int(static_cast< int >(result));
35045 return resultobj;
35046 fail:
35047 return NULL;
35048 }
35049
35050
35051 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35052 PyObject *resultobj = 0;
35053 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35054 void *argp1 = 0 ;
35055 int res1 = 0 ;
35056 PyObject *swig_obj[1] ;
35057
35058 if (!args) SWIG_fail;
35059 swig_obj[0] = args;
35060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35061 if (!SWIG_IsOK(res1)) {
35062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35063 }
35064 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35065 {
35066 PyThreadState* __tstate = wxPyBeginAllowThreads();
35067 (arg1)->OnLeave();
35068 wxPyEndAllowThreads(__tstate);
35069 if (PyErr_Occurred()) SWIG_fail;
35070 }
35071 resultobj = SWIG_Py_Void();
35072 return resultobj;
35073 fail:
35074 return NULL;
35075 }
35076
35077
35078 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35079 PyObject *resultobj = 0;
35080 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35081 int arg2 ;
35082 int arg3 ;
35083 bool result;
35084 void *argp1 = 0 ;
35085 int res1 = 0 ;
35086 int val2 ;
35087 int ecode2 = 0 ;
35088 int val3 ;
35089 int ecode3 = 0 ;
35090 PyObject * obj0 = 0 ;
35091 PyObject * obj1 = 0 ;
35092 PyObject * obj2 = 0 ;
35093 char * kwnames[] = {
35094 (char *) "self",(char *) "x",(char *) "y", NULL
35095 };
35096
35097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35099 if (!SWIG_IsOK(res1)) {
35100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35101 }
35102 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35103 ecode2 = SWIG_AsVal_int(obj1, &val2);
35104 if (!SWIG_IsOK(ecode2)) {
35105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35106 }
35107 arg2 = static_cast< int >(val2);
35108 ecode3 = SWIG_AsVal_int(obj2, &val3);
35109 if (!SWIG_IsOK(ecode3)) {
35110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35111 }
35112 arg3 = static_cast< int >(val3);
35113 {
35114 PyThreadState* __tstate = wxPyBeginAllowThreads();
35115 result = (bool)(arg1)->OnDrop(arg2,arg3);
35116 wxPyEndAllowThreads(__tstate);
35117 if (PyErr_Occurred()) SWIG_fail;
35118 }
35119 {
35120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35121 }
35122 return resultobj;
35123 fail:
35124 return NULL;
35125 }
35126
35127
35128 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35129 PyObject *resultobj = 0;
35130 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35131 int arg2 ;
35132 int arg3 ;
35133 wxDragResult arg4 ;
35134 wxDragResult result;
35135 void *argp1 = 0 ;
35136 int res1 = 0 ;
35137 int val2 ;
35138 int ecode2 = 0 ;
35139 int val3 ;
35140 int ecode3 = 0 ;
35141 int val4 ;
35142 int ecode4 = 0 ;
35143 PyObject * obj0 = 0 ;
35144 PyObject * obj1 = 0 ;
35145 PyObject * obj2 = 0 ;
35146 PyObject * obj3 = 0 ;
35147 char * kwnames[] = {
35148 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35149 };
35150
35151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35153 if (!SWIG_IsOK(res1)) {
35154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35155 }
35156 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35157 ecode2 = SWIG_AsVal_int(obj1, &val2);
35158 if (!SWIG_IsOK(ecode2)) {
35159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35160 }
35161 arg2 = static_cast< int >(val2);
35162 ecode3 = SWIG_AsVal_int(obj2, &val3);
35163 if (!SWIG_IsOK(ecode3)) {
35164 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35165 }
35166 arg3 = static_cast< int >(val3);
35167 ecode4 = SWIG_AsVal_int(obj3, &val4);
35168 if (!SWIG_IsOK(ecode4)) {
35169 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35170 }
35171 arg4 = static_cast< wxDragResult >(val4);
35172 {
35173 PyThreadState* __tstate = wxPyBeginAllowThreads();
35174 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35175 wxPyEndAllowThreads(__tstate);
35176 if (PyErr_Occurred()) SWIG_fail;
35177 }
35178 resultobj = SWIG_From_int(static_cast< int >(result));
35179 return resultobj;
35180 fail:
35181 return NULL;
35182 }
35183
35184
35185 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35186 PyObject *obj;
35187 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35188 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35189 return SWIG_Py_Void();
35190 }
35191
35192 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35193 return SWIG_Python_InitShadowInstance(args);
35194 }
35195
35196 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35197 PyObject *resultobj = 0;
35198 wxClipboard *result = 0 ;
35199
35200 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35201 {
35202 PyThreadState* __tstate = wxPyBeginAllowThreads();
35203 result = (wxClipboard *)new wxClipboard();
35204 wxPyEndAllowThreads(__tstate);
35205 if (PyErr_Occurred()) SWIG_fail;
35206 }
35207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35208 return resultobj;
35209 fail:
35210 return NULL;
35211 }
35212
35213
35214 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35215 PyObject *resultobj = 0;
35216 wxClipboard *arg1 = (wxClipboard *) 0 ;
35217 void *argp1 = 0 ;
35218 int res1 = 0 ;
35219 PyObject *swig_obj[1] ;
35220
35221 if (!args) SWIG_fail;
35222 swig_obj[0] = args;
35223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35224 if (!SWIG_IsOK(res1)) {
35225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35226 }
35227 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35228 {
35229 PyThreadState* __tstate = wxPyBeginAllowThreads();
35230 delete arg1;
35231
35232 wxPyEndAllowThreads(__tstate);
35233 if (PyErr_Occurred()) SWIG_fail;
35234 }
35235 resultobj = SWIG_Py_Void();
35236 return resultobj;
35237 fail:
35238 return NULL;
35239 }
35240
35241
35242 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35243 PyObject *resultobj = 0;
35244 wxClipboard *arg1 = (wxClipboard *) 0 ;
35245 bool result;
35246 void *argp1 = 0 ;
35247 int res1 = 0 ;
35248 PyObject *swig_obj[1] ;
35249
35250 if (!args) SWIG_fail;
35251 swig_obj[0] = args;
35252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35253 if (!SWIG_IsOK(res1)) {
35254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35255 }
35256 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35257 {
35258 PyThreadState* __tstate = wxPyBeginAllowThreads();
35259 result = (bool)(arg1)->Open();
35260 wxPyEndAllowThreads(__tstate);
35261 if (PyErr_Occurred()) SWIG_fail;
35262 }
35263 {
35264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35265 }
35266 return resultobj;
35267 fail:
35268 return NULL;
35269 }
35270
35271
35272 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35273 PyObject *resultobj = 0;
35274 wxClipboard *arg1 = (wxClipboard *) 0 ;
35275 void *argp1 = 0 ;
35276 int res1 = 0 ;
35277 PyObject *swig_obj[1] ;
35278
35279 if (!args) SWIG_fail;
35280 swig_obj[0] = args;
35281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35282 if (!SWIG_IsOK(res1)) {
35283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35284 }
35285 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35286 {
35287 PyThreadState* __tstate = wxPyBeginAllowThreads();
35288 (arg1)->Close();
35289 wxPyEndAllowThreads(__tstate);
35290 if (PyErr_Occurred()) SWIG_fail;
35291 }
35292 resultobj = SWIG_Py_Void();
35293 return resultobj;
35294 fail:
35295 return NULL;
35296 }
35297
35298
35299 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35300 PyObject *resultobj = 0;
35301 wxClipboard *arg1 = (wxClipboard *) 0 ;
35302 bool result;
35303 void *argp1 = 0 ;
35304 int res1 = 0 ;
35305 PyObject *swig_obj[1] ;
35306
35307 if (!args) SWIG_fail;
35308 swig_obj[0] = args;
35309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35310 if (!SWIG_IsOK(res1)) {
35311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35312 }
35313 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35314 {
35315 PyThreadState* __tstate = wxPyBeginAllowThreads();
35316 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35317 wxPyEndAllowThreads(__tstate);
35318 if (PyErr_Occurred()) SWIG_fail;
35319 }
35320 {
35321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35322 }
35323 return resultobj;
35324 fail:
35325 return NULL;
35326 }
35327
35328
35329 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35330 PyObject *resultobj = 0;
35331 wxClipboard *arg1 = (wxClipboard *) 0 ;
35332 wxDataObject *arg2 = (wxDataObject *) 0 ;
35333 bool result;
35334 void *argp1 = 0 ;
35335 int res1 = 0 ;
35336 int res2 = 0 ;
35337 PyObject * obj0 = 0 ;
35338 PyObject * obj1 = 0 ;
35339 char * kwnames[] = {
35340 (char *) "self",(char *) "data", NULL
35341 };
35342
35343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35345 if (!SWIG_IsOK(res1)) {
35346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35347 }
35348 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35349 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35350 if (!SWIG_IsOK(res2)) {
35351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35352 }
35353 {
35354 PyThreadState* __tstate = wxPyBeginAllowThreads();
35355 result = (bool)(arg1)->AddData(arg2);
35356 wxPyEndAllowThreads(__tstate);
35357 if (PyErr_Occurred()) SWIG_fail;
35358 }
35359 {
35360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35361 }
35362 return resultobj;
35363 fail:
35364 return NULL;
35365 }
35366
35367
35368 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35369 PyObject *resultobj = 0;
35370 wxClipboard *arg1 = (wxClipboard *) 0 ;
35371 wxDataObject *arg2 = (wxDataObject *) 0 ;
35372 bool result;
35373 void *argp1 = 0 ;
35374 int res1 = 0 ;
35375 int res2 = 0 ;
35376 PyObject * obj0 = 0 ;
35377 PyObject * obj1 = 0 ;
35378 char * kwnames[] = {
35379 (char *) "self",(char *) "data", NULL
35380 };
35381
35382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35384 if (!SWIG_IsOK(res1)) {
35385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35386 }
35387 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35388 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35389 if (!SWIG_IsOK(res2)) {
35390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35391 }
35392 {
35393 PyThreadState* __tstate = wxPyBeginAllowThreads();
35394 result = (bool)(arg1)->SetData(arg2);
35395 wxPyEndAllowThreads(__tstate);
35396 if (PyErr_Occurred()) SWIG_fail;
35397 }
35398 {
35399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35400 }
35401 return resultobj;
35402 fail:
35403 return NULL;
35404 }
35405
35406
35407 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35408 PyObject *resultobj = 0;
35409 wxClipboard *arg1 = (wxClipboard *) 0 ;
35410 wxDataFormat *arg2 = 0 ;
35411 bool result;
35412 void *argp1 = 0 ;
35413 int res1 = 0 ;
35414 void *argp2 = 0 ;
35415 int res2 = 0 ;
35416 PyObject * obj0 = 0 ;
35417 PyObject * obj1 = 0 ;
35418 char * kwnames[] = {
35419 (char *) "self",(char *) "format", NULL
35420 };
35421
35422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35424 if (!SWIG_IsOK(res1)) {
35425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35426 }
35427 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35428 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35429 if (!SWIG_IsOK(res2)) {
35430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35431 }
35432 if (!argp2) {
35433 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35434 }
35435 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35436 {
35437 PyThreadState* __tstate = wxPyBeginAllowThreads();
35438 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35439 wxPyEndAllowThreads(__tstate);
35440 if (PyErr_Occurred()) SWIG_fail;
35441 }
35442 {
35443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35444 }
35445 return resultobj;
35446 fail:
35447 return NULL;
35448 }
35449
35450
35451 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35452 PyObject *resultobj = 0;
35453 wxClipboard *arg1 = (wxClipboard *) 0 ;
35454 wxDataObject *arg2 = 0 ;
35455 bool result;
35456 void *argp1 = 0 ;
35457 int res1 = 0 ;
35458 void *argp2 = 0 ;
35459 int res2 = 0 ;
35460 PyObject * obj0 = 0 ;
35461 PyObject * obj1 = 0 ;
35462 char * kwnames[] = {
35463 (char *) "self",(char *) "data", NULL
35464 };
35465
35466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35468 if (!SWIG_IsOK(res1)) {
35469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35470 }
35471 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35472 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35473 if (!SWIG_IsOK(res2)) {
35474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35475 }
35476 if (!argp2) {
35477 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35478 }
35479 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35480 {
35481 PyThreadState* __tstate = wxPyBeginAllowThreads();
35482 result = (bool)(arg1)->GetData(*arg2);
35483 wxPyEndAllowThreads(__tstate);
35484 if (PyErr_Occurred()) SWIG_fail;
35485 }
35486 {
35487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35488 }
35489 return resultobj;
35490 fail:
35491 return NULL;
35492 }
35493
35494
35495 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35496 PyObject *resultobj = 0;
35497 wxClipboard *arg1 = (wxClipboard *) 0 ;
35498 void *argp1 = 0 ;
35499 int res1 = 0 ;
35500 PyObject *swig_obj[1] ;
35501
35502 if (!args) SWIG_fail;
35503 swig_obj[0] = args;
35504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35505 if (!SWIG_IsOK(res1)) {
35506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35507 }
35508 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35509 {
35510 PyThreadState* __tstate = wxPyBeginAllowThreads();
35511 (arg1)->Clear();
35512 wxPyEndAllowThreads(__tstate);
35513 if (PyErr_Occurred()) SWIG_fail;
35514 }
35515 resultobj = SWIG_Py_Void();
35516 return resultobj;
35517 fail:
35518 return NULL;
35519 }
35520
35521
35522 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35523 PyObject *resultobj = 0;
35524 wxClipboard *arg1 = (wxClipboard *) 0 ;
35525 bool result;
35526 void *argp1 = 0 ;
35527 int res1 = 0 ;
35528 PyObject *swig_obj[1] ;
35529
35530 if (!args) SWIG_fail;
35531 swig_obj[0] = args;
35532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35533 if (!SWIG_IsOK(res1)) {
35534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35535 }
35536 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35537 {
35538 PyThreadState* __tstate = wxPyBeginAllowThreads();
35539 result = (bool)(arg1)->Flush();
35540 wxPyEndAllowThreads(__tstate);
35541 if (PyErr_Occurred()) SWIG_fail;
35542 }
35543 {
35544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35545 }
35546 return resultobj;
35547 fail:
35548 return NULL;
35549 }
35550
35551
35552 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35553 PyObject *resultobj = 0;
35554 wxClipboard *arg1 = (wxClipboard *) 0 ;
35555 bool arg2 = (bool) true ;
35556 void *argp1 = 0 ;
35557 int res1 = 0 ;
35558 bool val2 ;
35559 int ecode2 = 0 ;
35560 PyObject * obj0 = 0 ;
35561 PyObject * obj1 = 0 ;
35562 char * kwnames[] = {
35563 (char *) "self",(char *) "primary", NULL
35564 };
35565
35566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35568 if (!SWIG_IsOK(res1)) {
35569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35570 }
35571 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35572 if (obj1) {
35573 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35574 if (!SWIG_IsOK(ecode2)) {
35575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35576 }
35577 arg2 = static_cast< bool >(val2);
35578 }
35579 {
35580 PyThreadState* __tstate = wxPyBeginAllowThreads();
35581 (arg1)->UsePrimarySelection(arg2);
35582 wxPyEndAllowThreads(__tstate);
35583 if (PyErr_Occurred()) SWIG_fail;
35584 }
35585 resultobj = SWIG_Py_Void();
35586 return resultobj;
35587 fail:
35588 return NULL;
35589 }
35590
35591
35592 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35593 PyObject *resultobj = 0;
35594 wxClipboard *result = 0 ;
35595
35596 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35597 {
35598 PyThreadState* __tstate = wxPyBeginAllowThreads();
35599 result = (wxClipboard *)wxClipboard::Get();
35600 wxPyEndAllowThreads(__tstate);
35601 if (PyErr_Occurred()) SWIG_fail;
35602 }
35603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35604 return resultobj;
35605 fail:
35606 return NULL;
35607 }
35608
35609
35610 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35611 PyObject *obj;
35612 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35613 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35614 return SWIG_Py_Void();
35615 }
35616
35617 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35618 return SWIG_Python_InitShadowInstance(args);
35619 }
35620
35621 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35622 PyObject *resultobj = 0;
35623 wxClipboard *arg1 = (wxClipboard *) NULL ;
35624 wxClipboardLocker *result = 0 ;
35625 void *argp1 = 0 ;
35626 int res1 = 0 ;
35627 PyObject * obj0 = 0 ;
35628 char * kwnames[] = {
35629 (char *) "clipboard", NULL
35630 };
35631
35632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35633 if (obj0) {
35634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35635 if (!SWIG_IsOK(res1)) {
35636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35637 }
35638 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35639 }
35640 {
35641 PyThreadState* __tstate = wxPyBeginAllowThreads();
35642 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35643 wxPyEndAllowThreads(__tstate);
35644 if (PyErr_Occurred()) SWIG_fail;
35645 }
35646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35647 return resultobj;
35648 fail:
35649 return NULL;
35650 }
35651
35652
35653 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35654 PyObject *resultobj = 0;
35655 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35656 void *argp1 = 0 ;
35657 int res1 = 0 ;
35658 PyObject *swig_obj[1] ;
35659
35660 if (!args) SWIG_fail;
35661 swig_obj[0] = args;
35662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35663 if (!SWIG_IsOK(res1)) {
35664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35665 }
35666 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35667 {
35668 PyThreadState* __tstate = wxPyBeginAllowThreads();
35669 delete arg1;
35670
35671 wxPyEndAllowThreads(__tstate);
35672 if (PyErr_Occurred()) SWIG_fail;
35673 }
35674 resultobj = SWIG_Py_Void();
35675 return resultobj;
35676 fail:
35677 return NULL;
35678 }
35679
35680
35681 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35682 PyObject *resultobj = 0;
35683 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35684 bool result;
35685 void *argp1 = 0 ;
35686 int res1 = 0 ;
35687 PyObject *swig_obj[1] ;
35688
35689 if (!args) SWIG_fail;
35690 swig_obj[0] = args;
35691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35692 if (!SWIG_IsOK(res1)) {
35693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35694 }
35695 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35696 {
35697 PyThreadState* __tstate = wxPyBeginAllowThreads();
35698 result = (bool)wxClipboardLocker___nonzero__(arg1);
35699 wxPyEndAllowThreads(__tstate);
35700 if (PyErr_Occurred()) SWIG_fail;
35701 }
35702 {
35703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35704 }
35705 return resultobj;
35706 fail:
35707 return NULL;
35708 }
35709
35710
35711 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35712 PyObject *obj;
35713 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35714 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35715 return SWIG_Py_Void();
35716 }
35717
35718 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35719 return SWIG_Python_InitShadowInstance(args);
35720 }
35721
35722 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35723 PyObject *resultobj = 0;
35724 int arg1 = (int) 0 ;
35725 int arg2 = (int) 0 ;
35726 int arg3 = (int) 0 ;
35727 int arg4 = (int) 0 ;
35728 wxVideoMode *result = 0 ;
35729 int val1 ;
35730 int ecode1 = 0 ;
35731 int val2 ;
35732 int ecode2 = 0 ;
35733 int val3 ;
35734 int ecode3 = 0 ;
35735 int val4 ;
35736 int ecode4 = 0 ;
35737 PyObject * obj0 = 0 ;
35738 PyObject * obj1 = 0 ;
35739 PyObject * obj2 = 0 ;
35740 PyObject * obj3 = 0 ;
35741 char * kwnames[] = {
35742 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35743 };
35744
35745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35746 if (obj0) {
35747 ecode1 = SWIG_AsVal_int(obj0, &val1);
35748 if (!SWIG_IsOK(ecode1)) {
35749 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35750 }
35751 arg1 = static_cast< int >(val1);
35752 }
35753 if (obj1) {
35754 ecode2 = SWIG_AsVal_int(obj1, &val2);
35755 if (!SWIG_IsOK(ecode2)) {
35756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35757 }
35758 arg2 = static_cast< int >(val2);
35759 }
35760 if (obj2) {
35761 ecode3 = SWIG_AsVal_int(obj2, &val3);
35762 if (!SWIG_IsOK(ecode3)) {
35763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35764 }
35765 arg3 = static_cast< int >(val3);
35766 }
35767 if (obj3) {
35768 ecode4 = SWIG_AsVal_int(obj3, &val4);
35769 if (!SWIG_IsOK(ecode4)) {
35770 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35771 }
35772 arg4 = static_cast< int >(val4);
35773 }
35774 {
35775 PyThreadState* __tstate = wxPyBeginAllowThreads();
35776 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35777 wxPyEndAllowThreads(__tstate);
35778 if (PyErr_Occurred()) SWIG_fail;
35779 }
35780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35781 return resultobj;
35782 fail:
35783 return NULL;
35784 }
35785
35786
35787 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35788 PyObject *resultobj = 0;
35789 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35790 void *argp1 = 0 ;
35791 int res1 = 0 ;
35792 PyObject *swig_obj[1] ;
35793
35794 if (!args) SWIG_fail;
35795 swig_obj[0] = args;
35796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35797 if (!SWIG_IsOK(res1)) {
35798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35799 }
35800 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35801 {
35802 PyThreadState* __tstate = wxPyBeginAllowThreads();
35803 delete arg1;
35804
35805 wxPyEndAllowThreads(__tstate);
35806 if (PyErr_Occurred()) SWIG_fail;
35807 }
35808 resultobj = SWIG_Py_Void();
35809 return resultobj;
35810 fail:
35811 return NULL;
35812 }
35813
35814
35815 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35816 PyObject *resultobj = 0;
35817 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35818 wxVideoMode *arg2 = 0 ;
35819 bool result;
35820 void *argp1 = 0 ;
35821 int res1 = 0 ;
35822 void *argp2 = 0 ;
35823 int res2 = 0 ;
35824 PyObject * obj0 = 0 ;
35825 PyObject * obj1 = 0 ;
35826 char * kwnames[] = {
35827 (char *) "self",(char *) "other", NULL
35828 };
35829
35830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35832 if (!SWIG_IsOK(res1)) {
35833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35834 }
35835 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35836 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35837 if (!SWIG_IsOK(res2)) {
35838 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35839 }
35840 if (!argp2) {
35841 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35842 }
35843 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35844 {
35845 PyThreadState* __tstate = wxPyBeginAllowThreads();
35846 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35847 wxPyEndAllowThreads(__tstate);
35848 if (PyErr_Occurred()) SWIG_fail;
35849 }
35850 {
35851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35852 }
35853 return resultobj;
35854 fail:
35855 return NULL;
35856 }
35857
35858
35859 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35860 PyObject *resultobj = 0;
35861 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35862 int result;
35863 void *argp1 = 0 ;
35864 int res1 = 0 ;
35865 PyObject *swig_obj[1] ;
35866
35867 if (!args) SWIG_fail;
35868 swig_obj[0] = args;
35869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35870 if (!SWIG_IsOK(res1)) {
35871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35872 }
35873 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35874 {
35875 PyThreadState* __tstate = wxPyBeginAllowThreads();
35876 result = (int)((wxVideoMode const *)arg1)->GetWidth();
35877 wxPyEndAllowThreads(__tstate);
35878 if (PyErr_Occurred()) SWIG_fail;
35879 }
35880 resultobj = SWIG_From_int(static_cast< int >(result));
35881 return resultobj;
35882 fail:
35883 return NULL;
35884 }
35885
35886
35887 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35888 PyObject *resultobj = 0;
35889 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35890 int result;
35891 void *argp1 = 0 ;
35892 int res1 = 0 ;
35893 PyObject *swig_obj[1] ;
35894
35895 if (!args) SWIG_fail;
35896 swig_obj[0] = args;
35897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35898 if (!SWIG_IsOK(res1)) {
35899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35900 }
35901 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35902 {
35903 PyThreadState* __tstate = wxPyBeginAllowThreads();
35904 result = (int)((wxVideoMode const *)arg1)->GetHeight();
35905 wxPyEndAllowThreads(__tstate);
35906 if (PyErr_Occurred()) SWIG_fail;
35907 }
35908 resultobj = SWIG_From_int(static_cast< int >(result));
35909 return resultobj;
35910 fail:
35911 return NULL;
35912 }
35913
35914
35915 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35916 PyObject *resultobj = 0;
35917 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35918 int result;
35919 void *argp1 = 0 ;
35920 int res1 = 0 ;
35921 PyObject *swig_obj[1] ;
35922
35923 if (!args) SWIG_fail;
35924 swig_obj[0] = args;
35925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35926 if (!SWIG_IsOK(res1)) {
35927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35928 }
35929 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35930 {
35931 PyThreadState* __tstate = wxPyBeginAllowThreads();
35932 result = (int)((wxVideoMode const *)arg1)->GetDepth();
35933 wxPyEndAllowThreads(__tstate);
35934 if (PyErr_Occurred()) SWIG_fail;
35935 }
35936 resultobj = SWIG_From_int(static_cast< int >(result));
35937 return resultobj;
35938 fail:
35939 return NULL;
35940 }
35941
35942
35943 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35944 PyObject *resultobj = 0;
35945 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35946 bool result;
35947 void *argp1 = 0 ;
35948 int res1 = 0 ;
35949 PyObject *swig_obj[1] ;
35950
35951 if (!args) SWIG_fail;
35952 swig_obj[0] = args;
35953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35954 if (!SWIG_IsOK(res1)) {
35955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35956 }
35957 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35958 {
35959 PyThreadState* __tstate = wxPyBeginAllowThreads();
35960 result = (bool)((wxVideoMode const *)arg1)->IsOk();
35961 wxPyEndAllowThreads(__tstate);
35962 if (PyErr_Occurred()) SWIG_fail;
35963 }
35964 {
35965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35966 }
35967 return resultobj;
35968 fail:
35969 return NULL;
35970 }
35971
35972
35973 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35974 PyObject *resultobj = 0;
35975 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35976 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
35977 bool result;
35978 void *argp1 = 0 ;
35979 int res1 = 0 ;
35980 void *argp2 = 0 ;
35981 int res2 = 0 ;
35982 PyObject * obj0 = 0 ;
35983 PyObject * obj1 = 0 ;
35984 char * kwnames[] = {
35985 (char *) "self",(char *) "other", NULL
35986 };
35987
35988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
35989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35990 if (!SWIG_IsOK(res1)) {
35991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35992 }
35993 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35994 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35995 if (!SWIG_IsOK(res2)) {
35996 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
35997 }
35998 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35999 {
36000 PyThreadState* __tstate = wxPyBeginAllowThreads();
36001 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36002 wxPyEndAllowThreads(__tstate);
36003 if (PyErr_Occurred()) SWIG_fail;
36004 }
36005 {
36006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36007 }
36008 return resultobj;
36009 fail:
36010 return NULL;
36011 }
36012
36013
36014 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36015 PyObject *resultobj = 0;
36016 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36017 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36018 bool result;
36019 void *argp1 = 0 ;
36020 int res1 = 0 ;
36021 void *argp2 = 0 ;
36022 int res2 = 0 ;
36023 PyObject * obj0 = 0 ;
36024 PyObject * obj1 = 0 ;
36025 char * kwnames[] = {
36026 (char *) "self",(char *) "other", NULL
36027 };
36028
36029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36031 if (!SWIG_IsOK(res1)) {
36032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36033 }
36034 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36035 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36036 if (!SWIG_IsOK(res2)) {
36037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36038 }
36039 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36040 {
36041 PyThreadState* __tstate = wxPyBeginAllowThreads();
36042 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36043 wxPyEndAllowThreads(__tstate);
36044 if (PyErr_Occurred()) SWIG_fail;
36045 }
36046 {
36047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36048 }
36049 return resultobj;
36050 fail:
36051 return NULL;
36052 }
36053
36054
36055 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36056 PyObject *resultobj = 0;
36057 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36058 int arg2 ;
36059 void *argp1 = 0 ;
36060 int res1 = 0 ;
36061 int val2 ;
36062 int ecode2 = 0 ;
36063 PyObject *swig_obj[2] ;
36064
36065 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36067 if (!SWIG_IsOK(res1)) {
36068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36069 }
36070 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36071 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36072 if (!SWIG_IsOK(ecode2)) {
36073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36074 }
36075 arg2 = static_cast< int >(val2);
36076 if (arg1) (arg1)->w = arg2;
36077
36078 resultobj = SWIG_Py_Void();
36079 return resultobj;
36080 fail:
36081 return NULL;
36082 }
36083
36084
36085 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36086 PyObject *resultobj = 0;
36087 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36088 int result;
36089 void *argp1 = 0 ;
36090 int res1 = 0 ;
36091 PyObject *swig_obj[1] ;
36092
36093 if (!args) SWIG_fail;
36094 swig_obj[0] = args;
36095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36096 if (!SWIG_IsOK(res1)) {
36097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36098 }
36099 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36100 result = (int) ((arg1)->w);
36101 resultobj = SWIG_From_int(static_cast< int >(result));
36102 return resultobj;
36103 fail:
36104 return NULL;
36105 }
36106
36107
36108 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36109 PyObject *resultobj = 0;
36110 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36111 int arg2 ;
36112 void *argp1 = 0 ;
36113 int res1 = 0 ;
36114 int val2 ;
36115 int ecode2 = 0 ;
36116 PyObject *swig_obj[2] ;
36117
36118 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36120 if (!SWIG_IsOK(res1)) {
36121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36122 }
36123 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36124 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36125 if (!SWIG_IsOK(ecode2)) {
36126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36127 }
36128 arg2 = static_cast< int >(val2);
36129 if (arg1) (arg1)->h = arg2;
36130
36131 resultobj = SWIG_Py_Void();
36132 return resultobj;
36133 fail:
36134 return NULL;
36135 }
36136
36137
36138 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36139 PyObject *resultobj = 0;
36140 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36141 int result;
36142 void *argp1 = 0 ;
36143 int res1 = 0 ;
36144 PyObject *swig_obj[1] ;
36145
36146 if (!args) SWIG_fail;
36147 swig_obj[0] = args;
36148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36149 if (!SWIG_IsOK(res1)) {
36150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36151 }
36152 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36153 result = (int) ((arg1)->h);
36154 resultobj = SWIG_From_int(static_cast< int >(result));
36155 return resultobj;
36156 fail:
36157 return NULL;
36158 }
36159
36160
36161 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36162 PyObject *resultobj = 0;
36163 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36164 int arg2 ;
36165 void *argp1 = 0 ;
36166 int res1 = 0 ;
36167 int val2 ;
36168 int ecode2 = 0 ;
36169 PyObject *swig_obj[2] ;
36170
36171 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36173 if (!SWIG_IsOK(res1)) {
36174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36175 }
36176 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36177 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36178 if (!SWIG_IsOK(ecode2)) {
36179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36180 }
36181 arg2 = static_cast< int >(val2);
36182 if (arg1) (arg1)->bpp = arg2;
36183
36184 resultobj = SWIG_Py_Void();
36185 return resultobj;
36186 fail:
36187 return NULL;
36188 }
36189
36190
36191 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36192 PyObject *resultobj = 0;
36193 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36194 int result;
36195 void *argp1 = 0 ;
36196 int res1 = 0 ;
36197 PyObject *swig_obj[1] ;
36198
36199 if (!args) SWIG_fail;
36200 swig_obj[0] = args;
36201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36202 if (!SWIG_IsOK(res1)) {
36203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36204 }
36205 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36206 result = (int) ((arg1)->bpp);
36207 resultobj = SWIG_From_int(static_cast< int >(result));
36208 return resultobj;
36209 fail:
36210 return NULL;
36211 }
36212
36213
36214 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36215 PyObject *resultobj = 0;
36216 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36217 int arg2 ;
36218 void *argp1 = 0 ;
36219 int res1 = 0 ;
36220 int val2 ;
36221 int ecode2 = 0 ;
36222 PyObject *swig_obj[2] ;
36223
36224 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36226 if (!SWIG_IsOK(res1)) {
36227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36228 }
36229 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36230 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36231 if (!SWIG_IsOK(ecode2)) {
36232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36233 }
36234 arg2 = static_cast< int >(val2);
36235 if (arg1) (arg1)->refresh = arg2;
36236
36237 resultobj = SWIG_Py_Void();
36238 return resultobj;
36239 fail:
36240 return NULL;
36241 }
36242
36243
36244 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36245 PyObject *resultobj = 0;
36246 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36247 int result;
36248 void *argp1 = 0 ;
36249 int res1 = 0 ;
36250 PyObject *swig_obj[1] ;
36251
36252 if (!args) SWIG_fail;
36253 swig_obj[0] = args;
36254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36255 if (!SWIG_IsOK(res1)) {
36256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36257 }
36258 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36259 result = (int) ((arg1)->refresh);
36260 resultobj = SWIG_From_int(static_cast< int >(result));
36261 return resultobj;
36262 fail:
36263 return NULL;
36264 }
36265
36266
36267 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36268 PyObject *obj;
36269 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36270 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36271 return SWIG_Py_Void();
36272 }
36273
36274 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36275 return SWIG_Python_InitShadowInstance(args);
36276 }
36277
36278 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36279 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36280 return 1;
36281 }
36282
36283
36284 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36285 PyObject *pyobj = 0;
36286
36287 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36288 return pyobj;
36289 }
36290
36291
36292 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36293 PyObject *resultobj = 0;
36294 unsigned int arg1 = (unsigned int) 0 ;
36295 wxDisplay *result = 0 ;
36296 unsigned int val1 ;
36297 int ecode1 = 0 ;
36298 PyObject * obj0 = 0 ;
36299 char * kwnames[] = {
36300 (char *) "index", NULL
36301 };
36302
36303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36304 if (obj0) {
36305 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36306 if (!SWIG_IsOK(ecode1)) {
36307 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36308 }
36309 arg1 = static_cast< unsigned int >(val1);
36310 }
36311 {
36312 PyThreadState* __tstate = wxPyBeginAllowThreads();
36313 result = (wxDisplay *)new wxDisplay(arg1);
36314 wxPyEndAllowThreads(__tstate);
36315 if (PyErr_Occurred()) SWIG_fail;
36316 }
36317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36318 return resultobj;
36319 fail:
36320 return NULL;
36321 }
36322
36323
36324 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36325 PyObject *resultobj = 0;
36326 wxDisplay *arg1 = (wxDisplay *) 0 ;
36327 void *argp1 = 0 ;
36328 int res1 = 0 ;
36329 PyObject *swig_obj[1] ;
36330
36331 if (!args) SWIG_fail;
36332 swig_obj[0] = args;
36333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36334 if (!SWIG_IsOK(res1)) {
36335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36336 }
36337 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36338 {
36339 PyThreadState* __tstate = wxPyBeginAllowThreads();
36340 delete arg1;
36341
36342 wxPyEndAllowThreads(__tstate);
36343 if (PyErr_Occurred()) SWIG_fail;
36344 }
36345 resultobj = SWIG_Py_Void();
36346 return resultobj;
36347 fail:
36348 return NULL;
36349 }
36350
36351
36352 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36353 PyObject *resultobj = 0;
36354 unsigned int result;
36355
36356 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36357 {
36358 PyThreadState* __tstate = wxPyBeginAllowThreads();
36359 result = (unsigned int)wxDisplay::GetCount();
36360 wxPyEndAllowThreads(__tstate);
36361 if (PyErr_Occurred()) SWIG_fail;
36362 }
36363 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36364 return resultobj;
36365 fail:
36366 return NULL;
36367 }
36368
36369
36370 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36371 PyObject *resultobj = 0;
36372 wxPoint *arg1 = 0 ;
36373 int result;
36374 wxPoint temp1 ;
36375 PyObject * obj0 = 0 ;
36376 char * kwnames[] = {
36377 (char *) "pt", NULL
36378 };
36379
36380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36381 {
36382 arg1 = &temp1;
36383 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36384 }
36385 {
36386 PyThreadState* __tstate = wxPyBeginAllowThreads();
36387 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36388 wxPyEndAllowThreads(__tstate);
36389 if (PyErr_Occurred()) SWIG_fail;
36390 }
36391 resultobj = SWIG_From_int(static_cast< int >(result));
36392 return resultobj;
36393 fail:
36394 return NULL;
36395 }
36396
36397
36398 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36399 PyObject *resultobj = 0;
36400 wxWindow *arg1 = (wxWindow *) 0 ;
36401 int result;
36402 void *argp1 = 0 ;
36403 int res1 = 0 ;
36404 PyObject * obj0 = 0 ;
36405 char * kwnames[] = {
36406 (char *) "window", NULL
36407 };
36408
36409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36411 if (!SWIG_IsOK(res1)) {
36412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36413 }
36414 arg1 = reinterpret_cast< wxWindow * >(argp1);
36415 {
36416 PyThreadState* __tstate = wxPyBeginAllowThreads();
36417 result = (int)wxDisplay::GetFromWindow(arg1);
36418 wxPyEndAllowThreads(__tstate);
36419 if (PyErr_Occurred()) SWIG_fail;
36420 }
36421 resultobj = SWIG_From_int(static_cast< int >(result));
36422 return resultobj;
36423 fail:
36424 return NULL;
36425 }
36426
36427
36428 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36429 PyObject *resultobj = 0;
36430 wxDisplay *arg1 = (wxDisplay *) 0 ;
36431 bool result;
36432 void *argp1 = 0 ;
36433 int res1 = 0 ;
36434 PyObject *swig_obj[1] ;
36435
36436 if (!args) SWIG_fail;
36437 swig_obj[0] = args;
36438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36439 if (!SWIG_IsOK(res1)) {
36440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36441 }
36442 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36443 {
36444 PyThreadState* __tstate = wxPyBeginAllowThreads();
36445 result = (bool)((wxDisplay const *)arg1)->IsOk();
36446 wxPyEndAllowThreads(__tstate);
36447 if (PyErr_Occurred()) SWIG_fail;
36448 }
36449 {
36450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36451 }
36452 return resultobj;
36453 fail:
36454 return NULL;
36455 }
36456
36457
36458 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36459 PyObject *resultobj = 0;
36460 wxDisplay *arg1 = (wxDisplay *) 0 ;
36461 wxRect result;
36462 void *argp1 = 0 ;
36463 int res1 = 0 ;
36464 PyObject *swig_obj[1] ;
36465
36466 if (!args) SWIG_fail;
36467 swig_obj[0] = args;
36468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36469 if (!SWIG_IsOK(res1)) {
36470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36471 }
36472 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36473 {
36474 PyThreadState* __tstate = wxPyBeginAllowThreads();
36475 result = ((wxDisplay const *)arg1)->GetGeometry();
36476 wxPyEndAllowThreads(__tstate);
36477 if (PyErr_Occurred()) SWIG_fail;
36478 }
36479 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36480 return resultobj;
36481 fail:
36482 return NULL;
36483 }
36484
36485
36486 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36487 PyObject *resultobj = 0;
36488 wxDisplay *arg1 = (wxDisplay *) 0 ;
36489 wxRect result;
36490 void *argp1 = 0 ;
36491 int res1 = 0 ;
36492 PyObject *swig_obj[1] ;
36493
36494 if (!args) SWIG_fail;
36495 swig_obj[0] = args;
36496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36497 if (!SWIG_IsOK(res1)) {
36498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36499 }
36500 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36501 {
36502 PyThreadState* __tstate = wxPyBeginAllowThreads();
36503 result = ((wxDisplay const *)arg1)->GetClientArea();
36504 wxPyEndAllowThreads(__tstate);
36505 if (PyErr_Occurred()) SWIG_fail;
36506 }
36507 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36508 return resultobj;
36509 fail:
36510 return NULL;
36511 }
36512
36513
36514 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36515 PyObject *resultobj = 0;
36516 wxDisplay *arg1 = (wxDisplay *) 0 ;
36517 wxString result;
36518 void *argp1 = 0 ;
36519 int res1 = 0 ;
36520 PyObject *swig_obj[1] ;
36521
36522 if (!args) SWIG_fail;
36523 swig_obj[0] = args;
36524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36525 if (!SWIG_IsOK(res1)) {
36526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36527 }
36528 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36529 {
36530 PyThreadState* __tstate = wxPyBeginAllowThreads();
36531 result = ((wxDisplay const *)arg1)->GetName();
36532 wxPyEndAllowThreads(__tstate);
36533 if (PyErr_Occurred()) SWIG_fail;
36534 }
36535 {
36536 #if wxUSE_UNICODE
36537 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36538 #else
36539 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36540 #endif
36541 }
36542 return resultobj;
36543 fail:
36544 return NULL;
36545 }
36546
36547
36548 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36549 PyObject *resultobj = 0;
36550 wxDisplay *arg1 = (wxDisplay *) 0 ;
36551 bool result;
36552 void *argp1 = 0 ;
36553 int res1 = 0 ;
36554 PyObject *swig_obj[1] ;
36555
36556 if (!args) SWIG_fail;
36557 swig_obj[0] = args;
36558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36559 if (!SWIG_IsOK(res1)) {
36560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36561 }
36562 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36563 {
36564 PyThreadState* __tstate = wxPyBeginAllowThreads();
36565 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36566 wxPyEndAllowThreads(__tstate);
36567 if (PyErr_Occurred()) SWIG_fail;
36568 }
36569 {
36570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36571 }
36572 return resultobj;
36573 fail:
36574 return NULL;
36575 }
36576
36577
36578 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36579 PyObject *resultobj = 0;
36580 wxDisplay *arg1 = (wxDisplay *) 0 ;
36581 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36582 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36583 PyObject *result = 0 ;
36584 void *argp1 = 0 ;
36585 int res1 = 0 ;
36586 void *argp2 = 0 ;
36587 int res2 = 0 ;
36588 PyObject * obj0 = 0 ;
36589 PyObject * obj1 = 0 ;
36590 char * kwnames[] = {
36591 (char *) "self",(char *) "mode", NULL
36592 };
36593
36594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36596 if (!SWIG_IsOK(res1)) {
36597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36598 }
36599 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36600 if (obj1) {
36601 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36602 if (!SWIG_IsOK(res2)) {
36603 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36604 }
36605 if (!argp2) {
36606 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36607 }
36608 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36609 }
36610 {
36611 PyThreadState* __tstate = wxPyBeginAllowThreads();
36612 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36613 wxPyEndAllowThreads(__tstate);
36614 if (PyErr_Occurred()) SWIG_fail;
36615 }
36616 resultobj = result;
36617 return resultobj;
36618 fail:
36619 return NULL;
36620 }
36621
36622
36623 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36624 PyObject *resultobj = 0;
36625 wxDisplay *arg1 = (wxDisplay *) 0 ;
36626 wxVideoMode result;
36627 void *argp1 = 0 ;
36628 int res1 = 0 ;
36629 PyObject *swig_obj[1] ;
36630
36631 if (!args) SWIG_fail;
36632 swig_obj[0] = args;
36633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36634 if (!SWIG_IsOK(res1)) {
36635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36636 }
36637 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36638 {
36639 PyThreadState* __tstate = wxPyBeginAllowThreads();
36640 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36641 wxPyEndAllowThreads(__tstate);
36642 if (PyErr_Occurred()) SWIG_fail;
36643 }
36644 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36645 return resultobj;
36646 fail:
36647 return NULL;
36648 }
36649
36650
36651 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36652 PyObject *resultobj = 0;
36653 wxDisplay *arg1 = (wxDisplay *) 0 ;
36654 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36655 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36656 bool result;
36657 void *argp1 = 0 ;
36658 int res1 = 0 ;
36659 void *argp2 = 0 ;
36660 int res2 = 0 ;
36661 PyObject * obj0 = 0 ;
36662 PyObject * obj1 = 0 ;
36663 char * kwnames[] = {
36664 (char *) "self",(char *) "mode", NULL
36665 };
36666
36667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36669 if (!SWIG_IsOK(res1)) {
36670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36671 }
36672 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36673 if (obj1) {
36674 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36675 if (!SWIG_IsOK(res2)) {
36676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36677 }
36678 if (!argp2) {
36679 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36680 }
36681 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36682 }
36683 {
36684 PyThreadState* __tstate = wxPyBeginAllowThreads();
36685 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36686 wxPyEndAllowThreads(__tstate);
36687 if (PyErr_Occurred()) SWIG_fail;
36688 }
36689 {
36690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36691 }
36692 return resultobj;
36693 fail:
36694 return NULL;
36695 }
36696
36697
36698 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36699 PyObject *resultobj = 0;
36700 wxDisplay *arg1 = (wxDisplay *) 0 ;
36701 void *argp1 = 0 ;
36702 int res1 = 0 ;
36703 PyObject *swig_obj[1] ;
36704
36705 if (!args) SWIG_fail;
36706 swig_obj[0] = args;
36707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36708 if (!SWIG_IsOK(res1)) {
36709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36710 }
36711 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36712 {
36713 PyThreadState* __tstate = wxPyBeginAllowThreads();
36714 wxDisplay_ResetMode(arg1);
36715 wxPyEndAllowThreads(__tstate);
36716 if (PyErr_Occurred()) SWIG_fail;
36717 }
36718 resultobj = SWIG_Py_Void();
36719 return resultobj;
36720 fail:
36721 return NULL;
36722 }
36723
36724
36725 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36726 PyObject *obj;
36727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36728 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36729 return SWIG_Py_Void();
36730 }
36731
36732 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36733 return SWIG_Python_InitShadowInstance(args);
36734 }
36735
36736 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36737 PyObject *resultobj = 0;
36738 wxStandardPaths *result = 0 ;
36739
36740 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36741 {
36742 PyThreadState* __tstate = wxPyBeginAllowThreads();
36743 result = (wxStandardPaths *)wxStandardPaths_Get();
36744 wxPyEndAllowThreads(__tstate);
36745 if (PyErr_Occurred()) SWIG_fail;
36746 }
36747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36748 return resultobj;
36749 fail:
36750 return NULL;
36751 }
36752
36753
36754 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36755 PyObject *resultobj = 0;
36756 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36757 wxString result;
36758 void *argp1 = 0 ;
36759 int res1 = 0 ;
36760 PyObject *swig_obj[1] ;
36761
36762 if (!args) SWIG_fail;
36763 swig_obj[0] = args;
36764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36765 if (!SWIG_IsOK(res1)) {
36766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36767 }
36768 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36769 {
36770 PyThreadState* __tstate = wxPyBeginAllowThreads();
36771 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36772 wxPyEndAllowThreads(__tstate);
36773 if (PyErr_Occurred()) SWIG_fail;
36774 }
36775 {
36776 #if wxUSE_UNICODE
36777 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36778 #else
36779 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36780 #endif
36781 }
36782 return resultobj;
36783 fail:
36784 return NULL;
36785 }
36786
36787
36788 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36789 PyObject *resultobj = 0;
36790 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36791 wxString result;
36792 void *argp1 = 0 ;
36793 int res1 = 0 ;
36794 PyObject *swig_obj[1] ;
36795
36796 if (!args) SWIG_fail;
36797 swig_obj[0] = args;
36798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36799 if (!SWIG_IsOK(res1)) {
36800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36801 }
36802 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36803 {
36804 PyThreadState* __tstate = wxPyBeginAllowThreads();
36805 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36806 wxPyEndAllowThreads(__tstate);
36807 if (PyErr_Occurred()) SWIG_fail;
36808 }
36809 {
36810 #if wxUSE_UNICODE
36811 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36812 #else
36813 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36814 #endif
36815 }
36816 return resultobj;
36817 fail:
36818 return NULL;
36819 }
36820
36821
36822 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36823 PyObject *resultobj = 0;
36824 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36825 wxString result;
36826 void *argp1 = 0 ;
36827 int res1 = 0 ;
36828 PyObject *swig_obj[1] ;
36829
36830 if (!args) SWIG_fail;
36831 swig_obj[0] = args;
36832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36833 if (!SWIG_IsOK(res1)) {
36834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36835 }
36836 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36837 {
36838 PyThreadState* __tstate = wxPyBeginAllowThreads();
36839 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36840 wxPyEndAllowThreads(__tstate);
36841 if (PyErr_Occurred()) SWIG_fail;
36842 }
36843 {
36844 #if wxUSE_UNICODE
36845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36846 #else
36847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36848 #endif
36849 }
36850 return resultobj;
36851 fail:
36852 return NULL;
36853 }
36854
36855
36856 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36857 PyObject *resultobj = 0;
36858 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36859 wxString result;
36860 void *argp1 = 0 ;
36861 int res1 = 0 ;
36862 PyObject *swig_obj[1] ;
36863
36864 if (!args) SWIG_fail;
36865 swig_obj[0] = args;
36866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36867 if (!SWIG_IsOK(res1)) {
36868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36869 }
36870 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36871 {
36872 PyThreadState* __tstate = wxPyBeginAllowThreads();
36873 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
36874 wxPyEndAllowThreads(__tstate);
36875 if (PyErr_Occurred()) SWIG_fail;
36876 }
36877 {
36878 #if wxUSE_UNICODE
36879 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36880 #else
36881 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36882 #endif
36883 }
36884 return resultobj;
36885 fail:
36886 return NULL;
36887 }
36888
36889
36890 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36891 PyObject *resultobj = 0;
36892 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36893 wxString result;
36894 void *argp1 = 0 ;
36895 int res1 = 0 ;
36896 PyObject *swig_obj[1] ;
36897
36898 if (!args) SWIG_fail;
36899 swig_obj[0] = args;
36900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36901 if (!SWIG_IsOK(res1)) {
36902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36903 }
36904 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36905 {
36906 PyThreadState* __tstate = wxPyBeginAllowThreads();
36907 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
36908 wxPyEndAllowThreads(__tstate);
36909 if (PyErr_Occurred()) SWIG_fail;
36910 }
36911 {
36912 #if wxUSE_UNICODE
36913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36914 #else
36915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36916 #endif
36917 }
36918 return resultobj;
36919 fail:
36920 return NULL;
36921 }
36922
36923
36924 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36925 PyObject *resultobj = 0;
36926 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36927 wxString result;
36928 void *argp1 = 0 ;
36929 int res1 = 0 ;
36930 PyObject *swig_obj[1] ;
36931
36932 if (!args) SWIG_fail;
36933 swig_obj[0] = args;
36934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36935 if (!SWIG_IsOK(res1)) {
36936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36937 }
36938 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36939 {
36940 PyThreadState* __tstate = wxPyBeginAllowThreads();
36941 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
36942 wxPyEndAllowThreads(__tstate);
36943 if (PyErr_Occurred()) SWIG_fail;
36944 }
36945 {
36946 #if wxUSE_UNICODE
36947 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36948 #else
36949 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36950 #endif
36951 }
36952 return resultobj;
36953 fail:
36954 return NULL;
36955 }
36956
36957
36958 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36959 PyObject *resultobj = 0;
36960 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36961 wxString result;
36962 void *argp1 = 0 ;
36963 int res1 = 0 ;
36964 PyObject *swig_obj[1] ;
36965
36966 if (!args) SWIG_fail;
36967 swig_obj[0] = args;
36968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36969 if (!SWIG_IsOK(res1)) {
36970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36971 }
36972 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36973 {
36974 PyThreadState* __tstate = wxPyBeginAllowThreads();
36975 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
36976 wxPyEndAllowThreads(__tstate);
36977 if (PyErr_Occurred()) SWIG_fail;
36978 }
36979 {
36980 #if wxUSE_UNICODE
36981 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36982 #else
36983 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36984 #endif
36985 }
36986 return resultobj;
36987 fail:
36988 return NULL;
36989 }
36990
36991
36992 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36993 PyObject *resultobj = 0;
36994 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36995 wxString result;
36996 void *argp1 = 0 ;
36997 int res1 = 0 ;
36998 PyObject *swig_obj[1] ;
36999
37000 if (!args) SWIG_fail;
37001 swig_obj[0] = args;
37002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37003 if (!SWIG_IsOK(res1)) {
37004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37005 }
37006 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37007 {
37008 PyThreadState* __tstate = wxPyBeginAllowThreads();
37009 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37010 wxPyEndAllowThreads(__tstate);
37011 if (PyErr_Occurred()) SWIG_fail;
37012 }
37013 {
37014 #if wxUSE_UNICODE
37015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37016 #else
37017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37018 #endif
37019 }
37020 return resultobj;
37021 fail:
37022 return NULL;
37023 }
37024
37025
37026 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37027 PyObject *resultobj = 0;
37028 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37029 wxString *arg2 = 0 ;
37030 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37031 wxString result;
37032 void *argp1 = 0 ;
37033 int res1 = 0 ;
37034 bool temp2 = false ;
37035 int val3 ;
37036 int ecode3 = 0 ;
37037 PyObject * obj0 = 0 ;
37038 PyObject * obj1 = 0 ;
37039 PyObject * obj2 = 0 ;
37040 char * kwnames[] = {
37041 (char *) "self",(char *) "lang",(char *) "category", NULL
37042 };
37043
37044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37046 if (!SWIG_IsOK(res1)) {
37047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37048 }
37049 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37050 {
37051 arg2 = wxString_in_helper(obj1);
37052 if (arg2 == NULL) SWIG_fail;
37053 temp2 = true;
37054 }
37055 if (obj2) {
37056 ecode3 = SWIG_AsVal_int(obj2, &val3);
37057 if (!SWIG_IsOK(ecode3)) {
37058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37059 }
37060 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37061 }
37062 {
37063 PyThreadState* __tstate = wxPyBeginAllowThreads();
37064 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37065 wxPyEndAllowThreads(__tstate);
37066 if (PyErr_Occurred()) SWIG_fail;
37067 }
37068 {
37069 #if wxUSE_UNICODE
37070 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37071 #else
37072 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37073 #endif
37074 }
37075 {
37076 if (temp2)
37077 delete arg2;
37078 }
37079 return resultobj;
37080 fail:
37081 {
37082 if (temp2)
37083 delete arg2;
37084 }
37085 return NULL;
37086 }
37087
37088
37089 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37090 PyObject *resultobj = 0;
37091 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37092 wxString result;
37093 void *argp1 = 0 ;
37094 int res1 = 0 ;
37095 PyObject *swig_obj[1] ;
37096
37097 if (!args) SWIG_fail;
37098 swig_obj[0] = args;
37099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37100 if (!SWIG_IsOK(res1)) {
37101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37102 }
37103 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37104 {
37105 PyThreadState* __tstate = wxPyBeginAllowThreads();
37106 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37107 wxPyEndAllowThreads(__tstate);
37108 if (PyErr_Occurred()) SWIG_fail;
37109 }
37110 {
37111 #if wxUSE_UNICODE
37112 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37113 #else
37114 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37115 #endif
37116 }
37117 return resultobj;
37118 fail:
37119 return NULL;
37120 }
37121
37122
37123 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37124 PyObject *resultobj = 0;
37125 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37126 wxString *arg2 = 0 ;
37127 void *argp1 = 0 ;
37128 int res1 = 0 ;
37129 bool temp2 = false ;
37130 PyObject * obj0 = 0 ;
37131 PyObject * obj1 = 0 ;
37132 char * kwnames[] = {
37133 (char *) "self",(char *) "prefix", NULL
37134 };
37135
37136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37138 if (!SWIG_IsOK(res1)) {
37139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37140 }
37141 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37142 {
37143 arg2 = wxString_in_helper(obj1);
37144 if (arg2 == NULL) SWIG_fail;
37145 temp2 = true;
37146 }
37147 {
37148 PyThreadState* __tstate = wxPyBeginAllowThreads();
37149 (arg1)->SetInstallPrefix((wxString const &)*arg2);
37150 wxPyEndAllowThreads(__tstate);
37151 if (PyErr_Occurred()) SWIG_fail;
37152 }
37153 resultobj = SWIG_Py_Void();
37154 {
37155 if (temp2)
37156 delete arg2;
37157 }
37158 return resultobj;
37159 fail:
37160 {
37161 if (temp2)
37162 delete arg2;
37163 }
37164 return NULL;
37165 }
37166
37167
37168 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37169 PyObject *resultobj = 0;
37170 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37171 wxString result;
37172 void *argp1 = 0 ;
37173 int res1 = 0 ;
37174 PyObject *swig_obj[1] ;
37175
37176 if (!args) SWIG_fail;
37177 swig_obj[0] = args;
37178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37179 if (!SWIG_IsOK(res1)) {
37180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37181 }
37182 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37183 {
37184 PyThreadState* __tstate = wxPyBeginAllowThreads();
37185 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
37186 wxPyEndAllowThreads(__tstate);
37187 if (PyErr_Occurred()) SWIG_fail;
37188 }
37189 {
37190 #if wxUSE_UNICODE
37191 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37192 #else
37193 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37194 #endif
37195 }
37196 return resultobj;
37197 fail:
37198 return NULL;
37199 }
37200
37201
37202 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37203 PyObject *obj;
37204 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37205 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37206 return SWIG_Py_Void();
37207 }
37208
37209 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37210 PyObject *resultobj = 0;
37211 wxEventType arg1 ;
37212 wxPowerEvent *result = 0 ;
37213 int val1 ;
37214 int ecode1 = 0 ;
37215 PyObject * obj0 = 0 ;
37216 char * kwnames[] = {
37217 (char *) "evtType", NULL
37218 };
37219
37220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37221 ecode1 = SWIG_AsVal_int(obj0, &val1);
37222 if (!SWIG_IsOK(ecode1)) {
37223 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37224 }
37225 arg1 = static_cast< wxEventType >(val1);
37226 {
37227 PyThreadState* __tstate = wxPyBeginAllowThreads();
37228 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37229 wxPyEndAllowThreads(__tstate);
37230 if (PyErr_Occurred()) SWIG_fail;
37231 }
37232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37233 return resultobj;
37234 fail:
37235 return NULL;
37236 }
37237
37238
37239 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37240 PyObject *resultobj = 0;
37241 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37242 void *argp1 = 0 ;
37243 int res1 = 0 ;
37244 PyObject *swig_obj[1] ;
37245
37246 if (!args) SWIG_fail;
37247 swig_obj[0] = args;
37248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37249 if (!SWIG_IsOK(res1)) {
37250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37251 }
37252 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37253 {
37254 PyThreadState* __tstate = wxPyBeginAllowThreads();
37255 (arg1)->Veto();
37256 wxPyEndAllowThreads(__tstate);
37257 if (PyErr_Occurred()) SWIG_fail;
37258 }
37259 resultobj = SWIG_Py_Void();
37260 return resultobj;
37261 fail:
37262 return NULL;
37263 }
37264
37265
37266 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37267 PyObject *resultobj = 0;
37268 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37269 bool result;
37270 void *argp1 = 0 ;
37271 int res1 = 0 ;
37272 PyObject *swig_obj[1] ;
37273
37274 if (!args) SWIG_fail;
37275 swig_obj[0] = args;
37276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37277 if (!SWIG_IsOK(res1)) {
37278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37279 }
37280 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37281 {
37282 PyThreadState* __tstate = wxPyBeginAllowThreads();
37283 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37284 wxPyEndAllowThreads(__tstate);
37285 if (PyErr_Occurred()) SWIG_fail;
37286 }
37287 {
37288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37289 }
37290 return resultobj;
37291 fail:
37292 return NULL;
37293 }
37294
37295
37296 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37297 PyObject *obj;
37298 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37299 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37300 return SWIG_Py_Void();
37301 }
37302
37303 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37304 return SWIG_Python_InitShadowInstance(args);
37305 }
37306
37307 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37308 PyObject *resultobj = 0;
37309 wxPowerType result;
37310
37311 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37312 {
37313 PyThreadState* __tstate = wxPyBeginAllowThreads();
37314 result = (wxPowerType)wxGetPowerType();
37315 wxPyEndAllowThreads(__tstate);
37316 if (PyErr_Occurred()) SWIG_fail;
37317 }
37318 resultobj = SWIG_From_int(static_cast< int >(result));
37319 return resultobj;
37320 fail:
37321 return NULL;
37322 }
37323
37324
37325 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37326 PyObject *resultobj = 0;
37327 wxBatteryState result;
37328
37329 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37330 {
37331 PyThreadState* __tstate = wxPyBeginAllowThreads();
37332 result = (wxBatteryState)wxGetBatteryState();
37333 wxPyEndAllowThreads(__tstate);
37334 if (PyErr_Occurred()) SWIG_fail;
37335 }
37336 resultobj = SWIG_From_int(static_cast< int >(result));
37337 return resultobj;
37338 fail:
37339 return NULL;
37340 }
37341
37342
37343 static PyMethodDef SwigMethods[] = {
37344 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
37345 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
37346 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
37347 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
37348 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
37349 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
37350 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
37351 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
37352 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
37353 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
37354 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
37355 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
37356 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
37357 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
37358 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
37359 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
37360 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
37361 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
37362 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
37363 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
37364 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
37365 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
37366 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
37367 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
37368 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
37369 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
37370 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
37371 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
37372 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
37373 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
37374 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
37375 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
37376 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
37377 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
37378 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
37379 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
37380 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
37381 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
37382 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
37383 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
37384 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
37385 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
37386 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
37387 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
37388 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
37389 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
37390 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
37391 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
37392 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
37393 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
37394 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37395 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37396 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37397 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37398 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37399 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37400 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
37401 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
37402 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
37403 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37404 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
37405 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
37406 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
37407 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
37408 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
37409 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
37410 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
37411 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
37412 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
37413 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37414 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
37415 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37416 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
37417 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
37418 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
37419 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37420 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37421 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
37422 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
37423 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
37424 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
37425 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
37426 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
37427 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
37428 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
37429 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
37430 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
37431 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
37432 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
37433 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
37434 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
37435 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
37436 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
37437 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
37438 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
37439 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
37440 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
37441 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
37442 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
37443 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
37444 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
37445 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
37446 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
37447 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
37448 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
37449 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
37450 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
37451 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
37452 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
37453 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
37454 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
37455 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
37456 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
37457 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
37458 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
37459 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
37460 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
37461 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
37462 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
37463 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
37464 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
37465 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
37466 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
37467 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
37468 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
37469 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
37470 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
37471 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
37472 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
37473 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
37474 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
37475 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
37476 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
37477 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
37478 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
37479 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
37480 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
37481 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
37482 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
37483 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
37484 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
37485 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37486 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
37487 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
37488 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
37489 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
37490 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
37491 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
37492 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
37493 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37494 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
37495 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
37496 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
37497 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
37498 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37499 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
37500 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
37501 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
37502 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
37503 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
37504 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37505 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
37506 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37507 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37508 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
37509 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37510 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37511 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
37512 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
37513 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
37514 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37515 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
37516 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
37517 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
37518 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
37519 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
37520 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
37521 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
37522 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
37523 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
37524 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
37525 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
37526 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
37527 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37528 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37529 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
37530 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
37531 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37532 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
37533 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
37534 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37535 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
37536 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
37537 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
37538 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
37539 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
37540 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
37541 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
37542 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
37543 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
37544 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
37545 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
37546 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37547 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37548 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
37549 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
37550 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
37551 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
37552 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
37553 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
37554 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
37555 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
37556 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
37557 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
37558 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
37559 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
37560 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
37561 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37562 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37563 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
37564 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
37565 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
37566 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37567 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
37568 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
37569 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37570 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
37571 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
37572 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37573 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
37574 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
37575 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
37576 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
37577 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
37578 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
37579 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
37580 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
37581 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37582 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
37583 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
37584 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
37585 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
37586 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
37587 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37588 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
37589 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
37590 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
37591 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
37592 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
37593 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
37594 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
37595 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
37596 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
37597 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
37598 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
37599 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
37600 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
37601 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
37602 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
37603 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
37604 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
37605 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
37606 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37607 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37608 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37609 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
37610 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
37611 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
37612 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
37613 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
37614 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37615 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
37616 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
37617 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
37618 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
37619 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
37620 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
37621 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
37622 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
37623 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
37624 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
37625 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
37626 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
37627 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
37628 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
37629 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
37630 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37631 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
37632 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
37633 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
37634 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
37635 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
37636 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
37637 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
37638 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
37639 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
37640 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
37641 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
37642 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
37643 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
37644 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
37645 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
37646 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
37647 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
37648 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
37649 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
37650 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
37651 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
37652 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
37653 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
37654 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
37655 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37656 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
37657 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
37658 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
37659 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
37660 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
37661 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
37662 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
37663 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
37664 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
37665 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
37666 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
37667 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
37668 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
37669 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37670 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
37671 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
37672 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
37673 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
37674 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
37675 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
37676 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37677 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
37678 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
37679 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
37680 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
37681 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
37682 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
37683 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
37684 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
37685 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
37686 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
37687 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
37688 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
37689 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
37690 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37691 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
37692 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
37693 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
37694 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
37695 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
37696 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
37697 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
37698 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
37699 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
37700 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
37701 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
37702 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
37703 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
37704 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
37705 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
37706 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
37707 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
37708 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
37709 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
37710 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
37711 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
37712 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
37713 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
37714 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
37715 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
37716 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
37717 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
37718 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
37719 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
37720 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
37721 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
37722 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
37723 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
37724 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
37725 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
37726 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
37727 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
37728 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
37729 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
37730 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
37731 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
37732 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
37733 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
37734 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
37735 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
37736 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
37737 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
37738 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
37739 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
37740 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
37741 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
37742 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
37743 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
37744 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
37745 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
37746 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
37747 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37748 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
37749 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
37750 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
37751 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
37752 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
37753 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
37754 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
37755 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
37756 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
37757 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
37758 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
37759 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
37760 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
37761 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
37762 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
37763 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
37764 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
37765 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
37766 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
37767 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
37768 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
37769 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
37770 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
37771 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
37772 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
37773 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
37774 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
37775 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
37776 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
37777 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37778 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
37779 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
37780 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
37781 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37782 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
37783 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
37784 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
37785 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
37786 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
37787 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
37788 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
37789 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
37790 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
37791 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
37792 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
37793 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
37794 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
37795 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
37796 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
37797 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
37798 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
37799 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
37800 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
37801 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
37802 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37803 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37804 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
37805 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37806 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37807 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
37808 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37809 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
37810 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
37811 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
37812 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
37813 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
37814 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
37815 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
37816 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
37817 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
37818 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
37819 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
37820 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
37821 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
37822 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
37823 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
37824 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
37825 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
37826 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
37827 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
37828 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37829 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
37830 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
37831 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
37832 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
37833 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
37834 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37835 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
37836 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
37837 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
37838 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
37839 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
37840 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
37841 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
37842 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
37843 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
37844 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
37845 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
37846 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
37847 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37848 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
37849 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37850 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
37851 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
37852 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37853 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37854 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
37855 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
37856 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
37857 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
37858 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
37859 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
37860 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
37861 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
37862 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
37863 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
37864 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
37865 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37866 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37867 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37868 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37869 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
37870 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37871 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
37872 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
37873 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
37874 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37875 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
37876 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
37877 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
37878 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
37879 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
37880 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
37881 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
37882 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
37883 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
37884 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
37885 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
37886 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
37887 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
37888 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
37889 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
37890 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
37891 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
37892 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
37893 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
37894 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
37895 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37896 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
37897 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
37898 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
37899 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
37900 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
37901 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37902 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
37903 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
37904 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
37905 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37906 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
37907 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
37908 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
37909 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
37910 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
37911 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
37912 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
37913 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
37914 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
37915 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
37916 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
37917 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
37918 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
37919 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
37920 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
37921 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
37922 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
37923 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
37924 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
37925 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
37926 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
37927 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
37928 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
37929 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37930 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
37931 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
37932 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
37933 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
37934 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
37935 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37936 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37937 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37938 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37939 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37940 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37941 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37942 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37943 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37944 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37945 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37946 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37947 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
37948 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
37949 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
37950 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
37951 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
37952 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
37953 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
37954 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
37955 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
37956 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37957 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37958 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37959 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37960 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37961 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37962 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
37963 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
37964 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37965 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37966 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
37967 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
37968 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
37969 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
37970 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37971 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
37972 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37973 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
37974 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
37975 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
37976 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
37977 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37978 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37979 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37980 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
37981 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
37982 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
37983 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
37984 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
37985 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
37986 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
37987 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
37988 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
37989 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
37990 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
37991 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
37992 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
37993 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37994 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
37995 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
37996 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
37997 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
37998 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
37999 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
38000 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
38001 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
38002 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
38003 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
38004 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
38005 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38006 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
38007 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
38008 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
38009 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
38010 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
38011 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
38012 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
38013 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
38014 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
38015 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
38016 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
38017 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
38018 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
38019 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
38020 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
38021 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
38022 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
38023 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
38024 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
38025 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
38026 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
38027 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
38028 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
38029 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
38030 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
38031 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
38032 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
38033 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
38034 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
38035 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
38036 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
38037 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
38038 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
38039 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
38040 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
38041 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
38042 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
38043 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
38044 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
38045 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
38046 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
38047 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
38048 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
38049 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
38050 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
38051 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
38052 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
38053 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
38054 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
38055 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
38056 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
38057 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
38058 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
38059 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
38060 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
38061 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
38062 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
38063 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
38064 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
38065 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
38066 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
38067 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
38068 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
38069 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
38070 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
38071 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
38072 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
38073 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
38074 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
38075 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
38076 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
38077 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
38078 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
38079 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
38080 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
38081 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
38082 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
38083 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
38084 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
38085 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
38086 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
38087 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
38088 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
38089 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
38090 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
38091 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
38092 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
38093 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
38094 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
38095 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
38096 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
38097 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
38098 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
38099 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
38100 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
38101 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
38102 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
38103 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38104 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38105 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
38106 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
38107 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
38108 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
38109 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
38110 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
38111 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
38112 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
38113 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
38114 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
38115 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38116 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
38117 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
38118 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
38119 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
38120 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
38121 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38122 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
38123 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
38124 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
38125 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38126 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
38127 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
38128 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38129 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
38130 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
38131 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
38132 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38133 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
38134 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
38135 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
38136 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
38137 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
38138 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
38139 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
38140 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38141 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
38142 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
38143 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
38144 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
38145 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
38146 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38147 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38148 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
38149 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
38150 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38151 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
38152 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
38153 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
38154 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
38155 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38156 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38157 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
38158 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
38159 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
38160 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
38161 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
38162 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
38163 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
38164 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
38165 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38166 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
38167 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
38168 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
38169 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
38170 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38171 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
38172 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
38173 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
38174 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
38175 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
38176 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
38177 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
38178 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
38179 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
38180 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38181 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
38182 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38183 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
38184 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
38185 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38186 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
38187 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
38188 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
38189 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
38190 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38191 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
38192 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
38193 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38194 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38195 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38196 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
38197 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38198 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
38199 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
38200 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
38201 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
38202 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
38203 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
38204 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38205 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
38206 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38207 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38208 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
38209 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38210 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
38211 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
38212 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
38213 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
38214 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38215 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
38216 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38217 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38218 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
38219 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38220 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
38221 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
38222 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
38223 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
38224 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
38225 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
38226 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
38227 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
38228 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
38229 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38230 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
38231 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
38232 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
38233 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
38234 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
38235 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
38236 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
38237 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
38238 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
38239 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
38240 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
38241 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
38242 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
38243 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
38244 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
38245 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
38246 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
38247 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
38248 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
38249 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
38250 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
38251 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
38252 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
38253 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
38254 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
38255 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
38256 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
38257 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
38258 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
38259 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
38260 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
38261 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
38262 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
38263 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
38264 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
38265 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
38266 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
38267 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
38268 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
38269 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
38270 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
38271 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
38272 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
38273 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
38274 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
38275 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
38276 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
38277 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
38278 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
38279 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
38280 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
38281 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
38282 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
38283 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
38284 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
38285 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
38286 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
38287 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
38288 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
38289 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
38290 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
38291 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
38292 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
38293 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
38294 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
38295 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
38296 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
38297 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
38298 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
38299 { NULL, NULL, 0, NULL }
38300 };
38301
38302
38303 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
38304
38305 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
38306 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
38307 }
38308 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
38309 return (void *)((wxEvent *) ((wxMenuEvent *) x));
38310 }
38311 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
38312 return (void *)((wxEvent *) ((wxCloseEvent *) x));
38313 }
38314 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
38315 return (void *)((wxEvent *) ((wxMouseEvent *) x));
38316 }
38317 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
38318 return (void *)((wxEvent *) ((wxEraseEvent *) x));
38319 }
38320 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
38321 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
38322 }
38323 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
38324 return (void *)((wxEvent *) ((wxTimerEvent *) x));
38325 }
38326 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
38327 return (void *)((wxEvent *) ((wxPowerEvent *) x));
38328 }
38329 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
38330 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
38331 }
38332 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
38333 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
38334 }
38335 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
38336 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
38337 }
38338 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
38339 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
38340 }
38341 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
38342 return (void *)((wxEvent *) ((wxPyEvent *) x));
38343 }
38344 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
38345 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
38346 }
38347 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
38348 return (void *)((wxEvent *) ((wxIdleEvent *) x));
38349 }
38350 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
38351 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
38352 }
38353 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
38354 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
38355 }
38356 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
38357 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
38358 }
38359 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
38360 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
38361 }
38362 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
38363 return (void *)((wxEvent *) ((wxActivateEvent *) x));
38364 }
38365 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
38366 return (void *)((wxEvent *) ((wxSizeEvent *) x));
38367 }
38368 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
38369 return (void *)((wxEvent *) ((wxMoveEvent *) x));
38370 }
38371 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
38372 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
38373 }
38374 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
38375 return (void *)((wxEvent *) ((wxPaintEvent *) x));
38376 }
38377 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
38378 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
38379 }
38380 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
38381 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
38382 }
38383 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
38384 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
38385 }
38386 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
38387 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
38388 }
38389 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
38390 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
38391 }
38392 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
38393 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
38394 }
38395 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
38396 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
38397 }
38398 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
38399 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
38400 }
38401 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
38402 return (void *)((wxEvent *) ((wxFocusEvent *) x));
38403 }
38404 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
38405 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
38406 }
38407 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
38408 return (void *)((wxEvent *) ((wxProcessEvent *) x));
38409 }
38410 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
38411 return (void *)((wxEvent *) ((wxShowEvent *) x));
38412 }
38413 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
38414 return (void *)((wxEvent *) ((wxCommandEvent *) x));
38415 }
38416 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
38417 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
38418 }
38419 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
38420 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
38421 }
38422 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
38423 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
38424 }
38425 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
38426 return (void *)((wxEvent *) ((wxKeyEvent *) x));
38427 }
38428 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
38429 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
38430 }
38431 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
38432 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
38433 }
38434 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
38435 return (void *)((wxConfigBase *) ((wxConfig *) x));
38436 }
38437 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
38438 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38439 }
38440 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
38441 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
38442 }
38443 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
38444 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
38445 }
38446 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
38447 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
38448 }
38449 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
38450 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
38451 }
38452 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
38453 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
38454 }
38455 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
38456 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
38457 }
38458 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
38459 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
38460 }
38461 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
38462 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38463 }
38464 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
38465 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
38466 }
38467 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
38468 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
38469 }
38470 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
38471 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
38472 }
38473 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
38474 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
38475 }
38476 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
38477 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
38478 }
38479 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
38480 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
38481 }
38482 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
38483 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
38484 }
38485 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
38486 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
38487 }
38488 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
38489 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38490 }
38491 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
38492 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
38493 }
38494 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
38495 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
38496 }
38497 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
38498 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
38499 }
38500 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
38501 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
38502 }
38503 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
38504 return (void *)((wxEvtHandler *) ((wxWindow *) x));
38505 }
38506 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
38507 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
38508 }
38509 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
38510 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
38511 }
38512 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
38513 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
38514 }
38515 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
38516 return (void *)((wxEvtHandler *) ((wxValidator *) x));
38517 }
38518 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
38519 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
38520 }
38521 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
38522 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
38523 }
38524 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
38525 return (void *)((wxEvtHandler *) ((wxMenu *) x));
38526 }
38527 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
38528 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
38529 }
38530 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
38531 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
38532 }
38533 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
38534 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
38535 }
38536 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
38537 return (void *)((wxObject *) ((wxSizerItem *) x));
38538 }
38539 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
38540 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
38541 }
38542 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
38543 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
38544 }
38545 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
38546 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
38547 }
38548 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
38549 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
38550 }
38551 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
38552 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
38553 }
38554 static void *_p_wxSizerTo_p_wxObject(void *x) {
38555 return (void *)((wxObject *) ((wxSizer *) x));
38556 }
38557 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
38558 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
38559 }
38560 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
38561 return (void *)((wxObject *) ((wxFileHistory *) x));
38562 }
38563 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
38564 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
38565 }
38566 static void *_p_wxEventTo_p_wxObject(void *x) {
38567 return (void *)((wxObject *) ((wxEvent *) x));
38568 }
38569 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
38570 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
38571 }
38572 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
38573 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
38574 }
38575 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
38576 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
38577 }
38578 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
38579 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
38580 }
38581 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
38582 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
38583 }
38584 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
38585 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
38586 }
38587 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
38588 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
38589 }
38590 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
38591 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
38592 }
38593 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
38594 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
38595 }
38596 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
38597 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
38598 }
38599 static void *_p_wxControlTo_p_wxObject(void *x) {
38600 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
38601 }
38602 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
38603 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
38604 }
38605 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
38606 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
38607 }
38608 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
38609 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
38610 }
38611 static void *_p_wxFSFileTo_p_wxObject(void *x) {
38612 return (void *)((wxObject *) ((wxFSFile *) x));
38613 }
38614 static void *_p_wxClipboardTo_p_wxObject(void *x) {
38615 return (void *)((wxObject *) ((wxClipboard *) x));
38616 }
38617 static void *_p_wxPySizerTo_p_wxObject(void *x) {
38618 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
38619 }
38620 static void *_p_wxPyEventTo_p_wxObject(void *x) {
38621 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
38622 }
38623 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
38624 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
38625 }
38626 static void *_p_wxShowEventTo_p_wxObject(void *x) {
38627 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
38628 }
38629 static void *_p_wxToolTipTo_p_wxObject(void *x) {
38630 return (void *)((wxObject *) ((wxToolTip *) x));
38631 }
38632 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
38633 return (void *)((wxObject *) ((wxMenuItem *) x));
38634 }
38635 static void *_p_wxDateEventTo_p_wxObject(void *x) {
38636 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
38637 }
38638 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
38639 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
38640 }
38641 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
38642 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
38643 }
38644 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
38645 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
38646 }
38647 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
38648 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
38649 }
38650 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
38651 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
38652 }
38653 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
38654 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
38655 }
38656 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
38657 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
38658 }
38659 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
38660 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
38661 }
38662 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
38663 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
38664 }
38665 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
38666 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
38667 }
38668 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
38669 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
38670 }
38671 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
38672 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
38673 }
38674 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
38675 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
38676 }
38677 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
38678 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
38679 }
38680 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
38681 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
38682 }
38683 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
38684 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
38685 }
38686 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
38687 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
38688 }
38689 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
38690 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
38691 }
38692 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
38693 return (void *)((wxObject *) ((wxImageHandler *) x));
38694 }
38695 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
38696 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
38697 }
38698 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
38699 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
38700 }
38701 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
38702 return (void *)((wxObject *) ((wxEvtHandler *) x));
38703 }
38704 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
38705 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
38706 }
38707 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
38708 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
38709 }
38710 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
38711 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
38712 }
38713 static void *_p_wxImageTo_p_wxObject(void *x) {
38714 return (void *)((wxObject *) ((wxImage *) x));
38715 }
38716 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
38717 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
38718 }
38719 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
38720 return (void *)((wxObject *) ((wxSystemOptions *) x));
38721 }
38722 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
38723 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
38724 }
38725 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
38726 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
38727 }
38728 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
38729 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
38730 }
38731 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
38732 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
38733 }
38734 static void *_p_wxWindowTo_p_wxObject(void *x) {
38735 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
38736 }
38737 static void *_p_wxMenuTo_p_wxObject(void *x) {
38738 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
38739 }
38740 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
38741 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
38742 }
38743 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
38744 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
38745 }
38746 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
38747 return (void *)((wxObject *) ((wxFileSystem *) x));
38748 }
38749 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
38750 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
38751 }
38752 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
38753 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
38754 }
38755 static void *_p_wxPyAppTo_p_wxObject(void *x) {
38756 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
38757 }
38758 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
38759 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
38760 }
38761 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
38762 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
38763 }
38764 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
38765 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
38766 }
38767 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
38768 return (void *)((wxObject *) ((wxBusyInfo *) x));
38769 }
38770 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
38771 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
38772 }
38773 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
38774 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
38775 }
38776 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
38777 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
38778 }
38779 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
38780 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
38781 }
38782 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
38783 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
38784 }
38785 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
38786 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
38787 }
38788 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
38789 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
38790 }
38791 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
38792 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
38793 }
38794 static void *_p_wxValidatorTo_p_wxObject(void *x) {
38795 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
38796 }
38797 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
38798 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
38799 }
38800 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
38801 return (void *)((wxLog *) ((wxLogBuffer *) x));
38802 }
38803 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
38804 return (void *)((wxLog *) ((wxLogStderr *) x));
38805 }
38806 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
38807 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
38808 }
38809 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
38810 return (void *)((wxLog *) ((wxLogWindow *) x));
38811 }
38812 static void *_p_wxLogChainTo_p_wxLog(void *x) {
38813 return (void *)((wxLog *) ((wxLogChain *) x));
38814 }
38815 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
38816 return (void *)((wxLog *) ((wxLogGui *) x));
38817 }
38818 static void *_p_wxPyLogTo_p_wxLog(void *x) {
38819 return (void *)((wxLog *) ((wxPyLog *) x));
38820 }
38821 static void *_p_wxControlTo_p_wxWindow(void *x) {
38822 return (void *)((wxWindow *) ((wxControl *) x));
38823 }
38824 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
38825 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
38826 }
38827 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
38828 return (void *)((wxWindow *) ((wxMenuBar *) x));
38829 }
38830 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
38831 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
38832 }
38833 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
38834 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
38835 }
38836 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
38837 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};
38838 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
38839 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
38840 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
38841 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
38842 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
38843 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
38844 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
38845 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
38846 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
38847 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
38848 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
38849 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
38850 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
38851 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
38852 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
38853 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
38854 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
38855 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
38856 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
38857 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
38858 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
38859 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
38860 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
38861 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
38862 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
38863 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
38864 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
38865 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
38866 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
38867 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
38868 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
38869 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
38870 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
38871 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
38872 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
38873 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
38874 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
38875 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
38876 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
38877 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
38878 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
38879 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
38880 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
38881 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
38882 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
38883 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
38884 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
38885 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
38886 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
38887 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
38888 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
38889 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
38890 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
38891 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
38892 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
38893 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
38894 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
38895 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
38896 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
38897 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
38898 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
38899 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
38900 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
38901 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
38902 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
38903 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
38904 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
38905 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
38906 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
38907 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
38908 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
38909 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
38910 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
38911 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
38912 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
38913 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
38914 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
38915 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
38916 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
38917 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
38918 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
38919 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
38920 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
38921 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
38922 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
38923 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
38924 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
38925 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
38926 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
38927 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
38928 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
38929 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
38930 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
38931 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
38932 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
38933 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
38934 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
38935 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
38936 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
38937 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
38938 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
38939 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
38940 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
38941 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
38942 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
38943 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
38944 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
38945 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
38946 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
38947 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
38948 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
38949 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
38950 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
38951 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
38952 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
38953 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
38954 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
38955 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
38956 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
38957 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
38958 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
38959 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
38960 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
38961 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
38962 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
38963 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
38964 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
38965 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
38966 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
38967 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
38968 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
38969 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
38970 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
38971 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
38972 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
38973 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
38974 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
38975 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
38976 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
38977 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
38978 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
38979 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
38980 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
38981 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
38982 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
38983 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
38984 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
38985 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
38986 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
38987 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
38988 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
38989 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
38990 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
38991 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
38992 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
38993 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
38994 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
38995 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
38996 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
38997 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
38998 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
38999 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
39000 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
39001 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
39002 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
39003 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
39004 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
39005 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
39006 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
39007 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
39008
39009 static swig_type_info *swig_type_initial[] = {
39010 &_swigt__p_char,
39011 &_swigt__p_form_ops_t,
39012 &_swigt__p_int,
39013 &_swigt__p_unsigned_char,
39014 &_swigt__p_unsigned_int,
39015 &_swigt__p_unsigned_long,
39016 &_swigt__p_void,
39017 &_swigt__p_wxANIHandler,
39018 &_swigt__p_wxAcceleratorTable,
39019 &_swigt__p_wxActivateEvent,
39020 &_swigt__p_wxArrayString,
39021 &_swigt__p_wxBMPHandler,
39022 &_swigt__p_wxBitmap,
39023 &_swigt__p_wxBitmapDataObject,
39024 &_swigt__p_wxBoxSizer,
39025 &_swigt__p_wxBusyCursor,
39026 &_swigt__p_wxBusyInfo,
39027 &_swigt__p_wxCURHandler,
39028 &_swigt__p_wxCaret,
39029 &_swigt__p_wxChar,
39030 &_swigt__p_wxChildFocusEvent,
39031 &_swigt__p_wxClipboard,
39032 &_swigt__p_wxClipboardLocker,
39033 &_swigt__p_wxClipboardTextEvent,
39034 &_swigt__p_wxCloseEvent,
39035 &_swigt__p_wxColour,
39036 &_swigt__p_wxCommandEvent,
39037 &_swigt__p_wxConfig,
39038 &_swigt__p_wxConfigBase,
39039 &_swigt__p_wxConfigPathChanger,
39040 &_swigt__p_wxContextMenuEvent,
39041 &_swigt__p_wxControl,
39042 &_swigt__p_wxControlWithItems,
39043 &_swigt__p_wxCursor,
39044 &_swigt__p_wxCustomDataObject,
39045 &_swigt__p_wxDC,
39046 &_swigt__p_wxDataFormat,
39047 &_swigt__p_wxDataObject,
39048 &_swigt__p_wxDataObjectComposite,
39049 &_swigt__p_wxDataObjectSimple,
39050 &_swigt__p_wxDateEvent,
39051 &_swigt__p_wxDateSpan,
39052 &_swigt__p_wxDateTime,
39053 &_swigt__p_wxDateTime__TimeZone,
39054 &_swigt__p_wxDisplay,
39055 &_swigt__p_wxDisplayChangedEvent,
39056 &_swigt__p_wxDropFilesEvent,
39057 &_swigt__p_wxDuplexMode,
39058 &_swigt__p_wxEraseEvent,
39059 &_swigt__p_wxEvent,
39060 &_swigt__p_wxEvtHandler,
39061 &_swigt__p_wxFSFile,
39062 &_swigt__p_wxFileConfig,
39063 &_swigt__p_wxFileDataObject,
39064 &_swigt__p_wxFileHistory,
39065 &_swigt__p_wxFileSystem,
39066 &_swigt__p_wxFileType,
39067 &_swigt__p_wxFileTypeInfo,
39068 &_swigt__p_wxFlexGridSizer,
39069 &_swigt__p_wxFocusEvent,
39070 &_swigt__p_wxFont,
39071 &_swigt__p_wxFrame,
39072 &_swigt__p_wxGBSizerItem,
39073 &_swigt__p_wxGIFHandler,
39074 &_swigt__p_wxGridBagSizer,
39075 &_swigt__p_wxGridSizer,
39076 &_swigt__p_wxICOHandler,
39077 &_swigt__p_wxIcon,
39078 &_swigt__p_wxIconizeEvent,
39079 &_swigt__p_wxIdleEvent,
39080 &_swigt__p_wxImage,
39081 &_swigt__p_wxImageHandler,
39082 &_swigt__p_wxIndividualLayoutConstraint,
39083 &_swigt__p_wxInitDialogEvent,
39084 &_swigt__p_wxJPEGHandler,
39085 &_swigt__p_wxJoystick,
39086 &_swigt__p_wxJoystickEvent,
39087 &_swigt__p_wxKeyEvent,
39088 &_swigt__p_wxKillError,
39089 &_swigt__p_wxLayoutConstraints,
39090 &_swigt__p_wxLog,
39091 &_swigt__p_wxLogBuffer,
39092 &_swigt__p_wxLogChain,
39093 &_swigt__p_wxLogGui,
39094 &_swigt__p_wxLogNull,
39095 &_swigt__p_wxLogStderr,
39096 &_swigt__p_wxLogTextCtrl,
39097 &_swigt__p_wxLogWindow,
39098 &_swigt__p_wxMaximizeEvent,
39099 &_swigt__p_wxMenu,
39100 &_swigt__p_wxMenuBar,
39101 &_swigt__p_wxMenuEvent,
39102 &_swigt__p_wxMenuItem,
39103 &_swigt__p_wxMetafileDataObject,
39104 &_swigt__p_wxMimeTypesManager,
39105 &_swigt__p_wxMouseCaptureChangedEvent,
39106 &_swigt__p_wxMouseCaptureLostEvent,
39107 &_swigt__p_wxMouseEvent,
39108 &_swigt__p_wxMouseState,
39109 &_swigt__p_wxMoveEvent,
39110 &_swigt__p_wxMutexGuiLocker,
39111 &_swigt__p_wxNavigationKeyEvent,
39112 &_swigt__p_wxNcPaintEvent,
39113 &_swigt__p_wxNotifyEvent,
39114 &_swigt__p_wxObject,
39115 &_swigt__p_wxOutputStream,
39116 &_swigt__p_wxPCXHandler,
39117 &_swigt__p_wxPNGHandler,
39118 &_swigt__p_wxPNMHandler,
39119 &_swigt__p_wxPaintEvent,
39120 &_swigt__p_wxPaletteChangedEvent,
39121 &_swigt__p_wxPaperSize,
39122 &_swigt__p_wxPlatformInfo,
39123 &_swigt__p_wxPoint,
39124 &_swigt__p_wxPowerEvent,
39125 &_swigt__p_wxProcessEvent,
39126 &_swigt__p_wxPyApp,
39127 &_swigt__p_wxPyArtProvider,
39128 &_swigt__p_wxPyBitmapDataObject,
39129 &_swigt__p_wxPyCommandEvent,
39130 &_swigt__p_wxPyDataObjectSimple,
39131 &_swigt__p_wxPyDropSource,
39132 &_swigt__p_wxPyDropTarget,
39133 &_swigt__p_wxPyEvent,
39134 &_swigt__p_wxPyFileDropTarget,
39135 &_swigt__p_wxPyImageHandler,
39136 &_swigt__p_wxPyLog,
39137 &_swigt__p_wxPyProcess,
39138 &_swigt__p_wxPySizer,
39139 &_swigt__p_wxPyTextDataObject,
39140 &_swigt__p_wxPyTextDropTarget,
39141 &_swigt__p_wxPyTimer,
39142 &_swigt__p_wxPyTipProvider,
39143 &_swigt__p_wxPyValidator,
39144 &_swigt__p_wxQueryNewPaletteEvent,
39145 &_swigt__p_wxRect,
39146 &_swigt__p_wxScrollEvent,
39147 &_swigt__p_wxScrollWinEvent,
39148 &_swigt__p_wxSetCursorEvent,
39149 &_swigt__p_wxShowEvent,
39150 &_swigt__p_wxSingleInstanceChecker,
39151 &_swigt__p_wxSize,
39152 &_swigt__p_wxSizeEvent,
39153 &_swigt__p_wxSizer,
39154 &_swigt__p_wxSizerItem,
39155 &_swigt__p_wxSound,
39156 &_swigt__p_wxStandardPaths,
39157 &_swigt__p_wxStaticBoxSizer,
39158 &_swigt__p_wxStdDialogButtonSizer,
39159 &_swigt__p_wxStopWatch,
39160 &_swigt__p_wxString,
39161 &_swigt__p_wxSysColourChangedEvent,
39162 &_swigt__p_wxSystemOptions,
39163 &_swigt__p_wxSystemSettings,
39164 &_swigt__p_wxTIFFHandler,
39165 &_swigt__p_wxTextCtrl,
39166 &_swigt__p_wxTextDataObject,
39167 &_swigt__p_wxTimeSpan,
39168 &_swigt__p_wxTimer,
39169 &_swigt__p_wxTimerEvent,
39170 &_swigt__p_wxTimerRunner,
39171 &_swigt__p_wxTipProvider,
39172 &_swigt__p_wxToolTip,
39173 &_swigt__p_wxURLDataObject,
39174 &_swigt__p_wxUpdateUIEvent,
39175 &_swigt__p_wxValidator,
39176 &_swigt__p_wxVideoMode,
39177 &_swigt__p_wxWindow,
39178 &_swigt__p_wxWindowCreateEvent,
39179 &_swigt__p_wxWindowDestroyEvent,
39180 &_swigt__p_wxWindowDisabler,
39181 &_swigt__p_wxXPMHandler,
39182 };
39183
39184 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
39185 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
39186 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
39187 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
39188 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
39189 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
39190 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
39191 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
39192 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
39193 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}};
39194 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
39195 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
39196 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
39197 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
39198 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
39199 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
39200 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
39201 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
39202 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}};
39203 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
39204 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
39205 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
39206 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
39207 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
39208 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}};
39209 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
39210 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}};
39211 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
39212 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
39213 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
39214 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
39215 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
39216 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
39217 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
39218 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
39219 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
39220 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
39221 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
39222 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
39223 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
39224 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
39225 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
39226 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
39227 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
39228 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
39229 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
39230 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39231 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39232 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
39233 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39234 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
39235 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
39236 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
39237 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
39238 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
39239 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
39240 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39241 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39242 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39243 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39244 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
39245 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
39246 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
39247 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
39248 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
39249 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
39250 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
39251 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
39252 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
39253 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
39254 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}};
39255 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
39256 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
39257 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
39258 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
39259 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
39260 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
39261 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}};
39262 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
39263 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
39264 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
39265 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
39266 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
39267 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
39268 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
39269 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
39270 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
39271 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
39272 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
39273 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}};
39274 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
39275 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
39276 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
39277 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
39278 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
39279 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
39280 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
39281 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
39282 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
39283 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
39284 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
39285 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
39286 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
39287 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
39288 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
39289 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
39290 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
39291 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
39292 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
39293 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
39294 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
39295 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
39296 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
39297 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
39298 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
39299 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
39300 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
39301 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
39302 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
39303 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
39304 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
39305 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
39306 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
39307 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
39308 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
39309 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
39310 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
39311 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
39312 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
39313 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
39314 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
39315 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
39316 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
39317 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
39318 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
39319 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
39320 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
39321 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
39322 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
39323 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
39324 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
39325 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
39326 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
39327 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}};
39328 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
39329 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
39330 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
39331 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
39332 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
39333 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
39334 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
39335 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
39336 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
39337 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
39338 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
39339 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
39340 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
39341 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
39342 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
39343 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
39344 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
39345 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}};
39346 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
39347 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
39348 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
39349 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
39350 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}};
39351 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
39352 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
39353 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
39354 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}};
39355 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
39356
39357 static swig_cast_info *swig_cast_initial[] = {
39358 _swigc__p_char,
39359 _swigc__p_form_ops_t,
39360 _swigc__p_int,
39361 _swigc__p_unsigned_char,
39362 _swigc__p_unsigned_int,
39363 _swigc__p_unsigned_long,
39364 _swigc__p_void,
39365 _swigc__p_wxANIHandler,
39366 _swigc__p_wxAcceleratorTable,
39367 _swigc__p_wxActivateEvent,
39368 _swigc__p_wxArrayString,
39369 _swigc__p_wxBMPHandler,
39370 _swigc__p_wxBitmap,
39371 _swigc__p_wxBitmapDataObject,
39372 _swigc__p_wxBoxSizer,
39373 _swigc__p_wxBusyCursor,
39374 _swigc__p_wxBusyInfo,
39375 _swigc__p_wxCURHandler,
39376 _swigc__p_wxCaret,
39377 _swigc__p_wxChar,
39378 _swigc__p_wxChildFocusEvent,
39379 _swigc__p_wxClipboard,
39380 _swigc__p_wxClipboardLocker,
39381 _swigc__p_wxClipboardTextEvent,
39382 _swigc__p_wxCloseEvent,
39383 _swigc__p_wxColour,
39384 _swigc__p_wxCommandEvent,
39385 _swigc__p_wxConfig,
39386 _swigc__p_wxConfigBase,
39387 _swigc__p_wxConfigPathChanger,
39388 _swigc__p_wxContextMenuEvent,
39389 _swigc__p_wxControl,
39390 _swigc__p_wxControlWithItems,
39391 _swigc__p_wxCursor,
39392 _swigc__p_wxCustomDataObject,
39393 _swigc__p_wxDC,
39394 _swigc__p_wxDataFormat,
39395 _swigc__p_wxDataObject,
39396 _swigc__p_wxDataObjectComposite,
39397 _swigc__p_wxDataObjectSimple,
39398 _swigc__p_wxDateEvent,
39399 _swigc__p_wxDateSpan,
39400 _swigc__p_wxDateTime,
39401 _swigc__p_wxDateTime__TimeZone,
39402 _swigc__p_wxDisplay,
39403 _swigc__p_wxDisplayChangedEvent,
39404 _swigc__p_wxDropFilesEvent,
39405 _swigc__p_wxDuplexMode,
39406 _swigc__p_wxEraseEvent,
39407 _swigc__p_wxEvent,
39408 _swigc__p_wxEvtHandler,
39409 _swigc__p_wxFSFile,
39410 _swigc__p_wxFileConfig,
39411 _swigc__p_wxFileDataObject,
39412 _swigc__p_wxFileHistory,
39413 _swigc__p_wxFileSystem,
39414 _swigc__p_wxFileType,
39415 _swigc__p_wxFileTypeInfo,
39416 _swigc__p_wxFlexGridSizer,
39417 _swigc__p_wxFocusEvent,
39418 _swigc__p_wxFont,
39419 _swigc__p_wxFrame,
39420 _swigc__p_wxGBSizerItem,
39421 _swigc__p_wxGIFHandler,
39422 _swigc__p_wxGridBagSizer,
39423 _swigc__p_wxGridSizer,
39424 _swigc__p_wxICOHandler,
39425 _swigc__p_wxIcon,
39426 _swigc__p_wxIconizeEvent,
39427 _swigc__p_wxIdleEvent,
39428 _swigc__p_wxImage,
39429 _swigc__p_wxImageHandler,
39430 _swigc__p_wxIndividualLayoutConstraint,
39431 _swigc__p_wxInitDialogEvent,
39432 _swigc__p_wxJPEGHandler,
39433 _swigc__p_wxJoystick,
39434 _swigc__p_wxJoystickEvent,
39435 _swigc__p_wxKeyEvent,
39436 _swigc__p_wxKillError,
39437 _swigc__p_wxLayoutConstraints,
39438 _swigc__p_wxLog,
39439 _swigc__p_wxLogBuffer,
39440 _swigc__p_wxLogChain,
39441 _swigc__p_wxLogGui,
39442 _swigc__p_wxLogNull,
39443 _swigc__p_wxLogStderr,
39444 _swigc__p_wxLogTextCtrl,
39445 _swigc__p_wxLogWindow,
39446 _swigc__p_wxMaximizeEvent,
39447 _swigc__p_wxMenu,
39448 _swigc__p_wxMenuBar,
39449 _swigc__p_wxMenuEvent,
39450 _swigc__p_wxMenuItem,
39451 _swigc__p_wxMetafileDataObject,
39452 _swigc__p_wxMimeTypesManager,
39453 _swigc__p_wxMouseCaptureChangedEvent,
39454 _swigc__p_wxMouseCaptureLostEvent,
39455 _swigc__p_wxMouseEvent,
39456 _swigc__p_wxMouseState,
39457 _swigc__p_wxMoveEvent,
39458 _swigc__p_wxMutexGuiLocker,
39459 _swigc__p_wxNavigationKeyEvent,
39460 _swigc__p_wxNcPaintEvent,
39461 _swigc__p_wxNotifyEvent,
39462 _swigc__p_wxObject,
39463 _swigc__p_wxOutputStream,
39464 _swigc__p_wxPCXHandler,
39465 _swigc__p_wxPNGHandler,
39466 _swigc__p_wxPNMHandler,
39467 _swigc__p_wxPaintEvent,
39468 _swigc__p_wxPaletteChangedEvent,
39469 _swigc__p_wxPaperSize,
39470 _swigc__p_wxPlatformInfo,
39471 _swigc__p_wxPoint,
39472 _swigc__p_wxPowerEvent,
39473 _swigc__p_wxProcessEvent,
39474 _swigc__p_wxPyApp,
39475 _swigc__p_wxPyArtProvider,
39476 _swigc__p_wxPyBitmapDataObject,
39477 _swigc__p_wxPyCommandEvent,
39478 _swigc__p_wxPyDataObjectSimple,
39479 _swigc__p_wxPyDropSource,
39480 _swigc__p_wxPyDropTarget,
39481 _swigc__p_wxPyEvent,
39482 _swigc__p_wxPyFileDropTarget,
39483 _swigc__p_wxPyImageHandler,
39484 _swigc__p_wxPyLog,
39485 _swigc__p_wxPyProcess,
39486 _swigc__p_wxPySizer,
39487 _swigc__p_wxPyTextDataObject,
39488 _swigc__p_wxPyTextDropTarget,
39489 _swigc__p_wxPyTimer,
39490 _swigc__p_wxPyTipProvider,
39491 _swigc__p_wxPyValidator,
39492 _swigc__p_wxQueryNewPaletteEvent,
39493 _swigc__p_wxRect,
39494 _swigc__p_wxScrollEvent,
39495 _swigc__p_wxScrollWinEvent,
39496 _swigc__p_wxSetCursorEvent,
39497 _swigc__p_wxShowEvent,
39498 _swigc__p_wxSingleInstanceChecker,
39499 _swigc__p_wxSize,
39500 _swigc__p_wxSizeEvent,
39501 _swigc__p_wxSizer,
39502 _swigc__p_wxSizerItem,
39503 _swigc__p_wxSound,
39504 _swigc__p_wxStandardPaths,
39505 _swigc__p_wxStaticBoxSizer,
39506 _swigc__p_wxStdDialogButtonSizer,
39507 _swigc__p_wxStopWatch,
39508 _swigc__p_wxString,
39509 _swigc__p_wxSysColourChangedEvent,
39510 _swigc__p_wxSystemOptions,
39511 _swigc__p_wxSystemSettings,
39512 _swigc__p_wxTIFFHandler,
39513 _swigc__p_wxTextCtrl,
39514 _swigc__p_wxTextDataObject,
39515 _swigc__p_wxTimeSpan,
39516 _swigc__p_wxTimer,
39517 _swigc__p_wxTimerEvent,
39518 _swigc__p_wxTimerRunner,
39519 _swigc__p_wxTipProvider,
39520 _swigc__p_wxToolTip,
39521 _swigc__p_wxURLDataObject,
39522 _swigc__p_wxUpdateUIEvent,
39523 _swigc__p_wxValidator,
39524 _swigc__p_wxVideoMode,
39525 _swigc__p_wxWindow,
39526 _swigc__p_wxWindowCreateEvent,
39527 _swigc__p_wxWindowDestroyEvent,
39528 _swigc__p_wxWindowDisabler,
39529 _swigc__p_wxXPMHandler,
39530 };
39531
39532
39533 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
39534
39535 static swig_const_info swig_const_table[] = {
39536 {0, 0, 0, 0.0, 0, 0}};
39537
39538 #ifdef __cplusplus
39539 }
39540 #endif
39541 /* -----------------------------------------------------------------------------
39542 * Type initialization:
39543 * This problem is tough by the requirement that no dynamic
39544 * memory is used. Also, since swig_type_info structures store pointers to
39545 * swig_cast_info structures and swig_cast_info structures store pointers back
39546 * to swig_type_info structures, we need some lookup code at initialization.
39547 * The idea is that swig generates all the structures that are needed.
39548 * The runtime then collects these partially filled structures.
39549 * The SWIG_InitializeModule function takes these initial arrays out of
39550 * swig_module, and does all the lookup, filling in the swig_module.types
39551 * array with the correct data and linking the correct swig_cast_info
39552 * structures together.
39553 *
39554 * The generated swig_type_info structures are assigned staticly to an initial
39555 * array. We just loop though that array, and handle each type individually.
39556 * First we lookup if this type has been already loaded, and if so, use the
39557 * loaded structure instead of the generated one. Then we have to fill in the
39558 * cast linked list. The cast data is initially stored in something like a
39559 * two-dimensional array. Each row corresponds to a type (there are the same
39560 * number of rows as there are in the swig_type_initial array). Each entry in
39561 * a column is one of the swig_cast_info structures for that type.
39562 * The cast_initial array is actually an array of arrays, because each row has
39563 * a variable number of columns. So to actually build the cast linked list,
39564 * we find the array of casts associated with the type, and loop through it
39565 * adding the casts to the list. The one last trick we need to do is making
39566 * sure the type pointer in the swig_cast_info struct is correct.
39567 *
39568 * First off, we lookup the cast->type name to see if it is already loaded.
39569 * There are three cases to handle:
39570 * 1) If the cast->type has already been loaded AND the type we are adding
39571 * casting info to has not been loaded (it is in this module), THEN we
39572 * replace the cast->type pointer with the type pointer that has already
39573 * been loaded.
39574 * 2) If BOTH types (the one we are adding casting info to, and the
39575 * cast->type) are loaded, THEN the cast info has already been loaded by
39576 * the previous module so we just ignore it.
39577 * 3) Finally, if cast->type has not already been loaded, then we add that
39578 * swig_cast_info to the linked list (because the cast->type) pointer will
39579 * be correct.
39580 * ----------------------------------------------------------------------------- */
39581
39582 #ifdef __cplusplus
39583 extern "C" {
39584 #if 0
39585 } /* c-mode */
39586 #endif
39587 #endif
39588
39589 #if 0
39590 #define SWIGRUNTIME_DEBUG
39591 #endif
39592
39593 SWIGRUNTIME void
39594 SWIG_InitializeModule(void *clientdata) {
39595 size_t i;
39596 swig_module_info *module_head;
39597 static int init_run = 0;
39598
39599 clientdata = clientdata;
39600
39601 if (init_run) return;
39602 init_run = 1;
39603
39604 /* Initialize the swig_module */
39605 swig_module.type_initial = swig_type_initial;
39606 swig_module.cast_initial = swig_cast_initial;
39607
39608 /* Try and load any already created modules */
39609 module_head = SWIG_GetModule(clientdata);
39610 if (module_head) {
39611 swig_module.next = module_head->next;
39612 module_head->next = &swig_module;
39613 } else {
39614 /* This is the first module loaded */
39615 swig_module.next = &swig_module;
39616 SWIG_SetModule(clientdata, &swig_module);
39617 }
39618
39619 /* Now work on filling in swig_module.types */
39620 #ifdef SWIGRUNTIME_DEBUG
39621 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
39622 #endif
39623 for (i = 0; i < swig_module.size; ++i) {
39624 swig_type_info *type = 0;
39625 swig_type_info *ret;
39626 swig_cast_info *cast;
39627
39628 #ifdef SWIGRUNTIME_DEBUG
39629 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39630 #endif
39631
39632 /* if there is another module already loaded */
39633 if (swig_module.next != &swig_module) {
39634 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
39635 }
39636 if (type) {
39637 /* Overwrite clientdata field */
39638 #ifdef SWIGRUNTIME_DEBUG
39639 printf("SWIG_InitializeModule: found type %s\n", type->name);
39640 #endif
39641 if (swig_module.type_initial[i]->clientdata) {
39642 type->clientdata = swig_module.type_initial[i]->clientdata;
39643 #ifdef SWIGRUNTIME_DEBUG
39644 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
39645 #endif
39646 }
39647 } else {
39648 type = swig_module.type_initial[i];
39649 }
39650
39651 /* Insert casting types */
39652 cast = swig_module.cast_initial[i];
39653 while (cast->type) {
39654 /* Don't need to add information already in the list */
39655 ret = 0;
39656 #ifdef SWIGRUNTIME_DEBUG
39657 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
39658 #endif
39659 if (swig_module.next != &swig_module) {
39660 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
39661 #ifdef SWIGRUNTIME_DEBUG
39662 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
39663 #endif
39664 }
39665 if (ret) {
39666 if (type == swig_module.type_initial[i]) {
39667 #ifdef SWIGRUNTIME_DEBUG
39668 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
39669 #endif
39670 cast->type = ret;
39671 ret = 0;
39672 } else {
39673 /* Check for casting already in the list */
39674 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
39675 #ifdef SWIGRUNTIME_DEBUG
39676 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
39677 #endif
39678 if (!ocast) ret = 0;
39679 }
39680 }
39681
39682 if (!ret) {
39683 #ifdef SWIGRUNTIME_DEBUG
39684 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
39685 #endif
39686 if (type->cast) {
39687 type->cast->prev = cast;
39688 cast->next = type->cast;
39689 }
39690 type->cast = cast;
39691 }
39692 cast++;
39693 }
39694 /* Set entry in modules->types array equal to the type */
39695 swig_module.types[i] = type;
39696 }
39697 swig_module.types[i] = 0;
39698
39699 #ifdef SWIGRUNTIME_DEBUG
39700 printf("**** SWIG_InitializeModule: Cast List ******\n");
39701 for (i = 0; i < swig_module.size; ++i) {
39702 int j = 0;
39703 swig_cast_info *cast = swig_module.cast_initial[i];
39704 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39705 while (cast->type) {
39706 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
39707 cast++;
39708 ++j;
39709 }
39710 printf("---- Total casts: %d\n",j);
39711 }
39712 printf("**** SWIG_InitializeModule: Cast List ******\n");
39713 #endif
39714 }
39715
39716 /* This function will propagate the clientdata field of type to
39717 * any new swig_type_info structures that have been added into the list
39718 * of equivalent types. It is like calling
39719 * SWIG_TypeClientData(type, clientdata) a second time.
39720 */
39721 SWIGRUNTIME void
39722 SWIG_PropagateClientData(void) {
39723 size_t i;
39724 swig_cast_info *equiv;
39725 static int init_run = 0;
39726
39727 if (init_run) return;
39728 init_run = 1;
39729
39730 for (i = 0; i < swig_module.size; i++) {
39731 if (swig_module.types[i]->clientdata) {
39732 equiv = swig_module.types[i]->cast;
39733 while (equiv) {
39734 if (!equiv->converter) {
39735 if (equiv->type && !equiv->type->clientdata)
39736 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
39737 }
39738 equiv = equiv->next;
39739 }
39740 }
39741 }
39742 }
39743
39744 #ifdef __cplusplus
39745 #if 0
39746 {
39747 /* c-mode */
39748 #endif
39749 }
39750 #endif
39751
39752
39753
39754 #ifdef __cplusplus
39755 extern "C" {
39756 #endif
39757
39758 /* Python-specific SWIG API */
39759 #define SWIG_newvarlink() SWIG_Python_newvarlink()
39760 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
39761 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
39762
39763 /* -----------------------------------------------------------------------------
39764 * global variable support code.
39765 * ----------------------------------------------------------------------------- */
39766
39767 typedef struct swig_globalvar {
39768 char *name; /* Name of global variable */
39769 PyObject *(*get_attr)(void); /* Return the current value */
39770 int (*set_attr)(PyObject *); /* Set the value */
39771 struct swig_globalvar *next;
39772 } swig_globalvar;
39773
39774 typedef struct swig_varlinkobject {
39775 PyObject_HEAD
39776 swig_globalvar *vars;
39777 } swig_varlinkobject;
39778
39779 SWIGINTERN PyObject *
39780 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
39781 return PyString_FromString("<Swig global variables>");
39782 }
39783
39784 SWIGINTERN PyObject *
39785 swig_varlink_str(swig_varlinkobject *v) {
39786 PyObject *str = PyString_FromString("(");
39787 swig_globalvar *var;
39788 for (var = v->vars; var; var=var->next) {
39789 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
39790 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
39791 }
39792 PyString_ConcatAndDel(&str,PyString_FromString(")"));
39793 return str;
39794 }
39795
39796 SWIGINTERN int
39797 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
39798 PyObject *str = swig_varlink_str(v);
39799 fprintf(fp,"Swig global variables ");
39800 fprintf(fp,"%s\n", PyString_AsString(str));
39801 Py_DECREF(str);
39802 return 0;
39803 }
39804
39805 SWIGINTERN void
39806 swig_varlink_dealloc(swig_varlinkobject *v) {
39807 swig_globalvar *var = v->vars;
39808 while (var) {
39809 swig_globalvar *n = var->next;
39810 free(var->name);
39811 free(var);
39812 var = n;
39813 }
39814 }
39815
39816 SWIGINTERN PyObject *
39817 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
39818 PyObject *res = NULL;
39819 swig_globalvar *var = v->vars;
39820 while (var) {
39821 if (strcmp(var->name,n) == 0) {
39822 res = (*var->get_attr)();
39823 break;
39824 }
39825 var = var->next;
39826 }
39827 if (res == NULL && !PyErr_Occurred()) {
39828 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39829 }
39830 return res;
39831 }
39832
39833 SWIGINTERN int
39834 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
39835 int res = 1;
39836 swig_globalvar *var = v->vars;
39837 while (var) {
39838 if (strcmp(var->name,n) == 0) {
39839 res = (*var->set_attr)(p);
39840 break;
39841 }
39842 var = var->next;
39843 }
39844 if (res == 1 && !PyErr_Occurred()) {
39845 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39846 }
39847 return res;
39848 }
39849
39850 SWIGINTERN PyTypeObject*
39851 swig_varlink_type(void) {
39852 static char varlink__doc__[] = "Swig var link object";
39853 static PyTypeObject varlink_type;
39854 static int type_init = 0;
39855 if (!type_init) {
39856 const PyTypeObject tmp
39857 = {
39858 PyObject_HEAD_INIT(NULL)
39859 0, /* Number of items in variable part (ob_size) */
39860 (char *)"swigvarlink", /* Type name (tp_name) */
39861 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
39862 0, /* Itemsize (tp_itemsize) */
39863 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
39864 (printfunc) swig_varlink_print, /* Print (tp_print) */
39865 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
39866 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
39867 0, /* tp_compare */
39868 (reprfunc) swig_varlink_repr, /* tp_repr */
39869 0, /* tp_as_number */
39870 0, /* tp_as_sequence */
39871 0, /* tp_as_mapping */
39872 0, /* tp_hash */
39873 0, /* tp_call */
39874 (reprfunc)swig_varlink_str, /* tp_str */
39875 0, /* tp_getattro */
39876 0, /* tp_setattro */
39877 0, /* tp_as_buffer */
39878 0, /* tp_flags */
39879 varlink__doc__, /* tp_doc */
39880 0, /* tp_traverse */
39881 0, /* tp_clear */
39882 0, /* tp_richcompare */
39883 0, /* tp_weaklistoffset */
39884 #if PY_VERSION_HEX >= 0x02020000
39885 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
39886 #endif
39887 #if PY_VERSION_HEX >= 0x02030000
39888 0, /* tp_del */
39889 #endif
39890 #ifdef COUNT_ALLOCS
39891 0,0,0,0 /* tp_alloc -> tp_next */
39892 #endif
39893 };
39894 varlink_type = tmp;
39895 varlink_type.ob_type = &PyType_Type;
39896 type_init = 1;
39897 }
39898 return &varlink_type;
39899 }
39900
39901 /* Create a variable linking object for use later */
39902 SWIGINTERN PyObject *
39903 SWIG_Python_newvarlink(void) {
39904 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
39905 if (result) {
39906 result->vars = 0;
39907 }
39908 return ((PyObject*) result);
39909 }
39910
39911 SWIGINTERN void
39912 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
39913 swig_varlinkobject *v = (swig_varlinkobject *) p;
39914 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
39915 if (gv) {
39916 size_t size = strlen(name)+1;
39917 gv->name = (char *)malloc(size);
39918 if (gv->name) {
39919 strncpy(gv->name,name,size);
39920 gv->get_attr = get_attr;
39921 gv->set_attr = set_attr;
39922 gv->next = v->vars;
39923 }
39924 }
39925 v->vars = gv;
39926 }
39927
39928 SWIGINTERN PyObject *
39929 SWIG_globals() {
39930 static PyObject *_SWIG_globals = 0;
39931 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
39932 return _SWIG_globals;
39933 }
39934
39935 /* -----------------------------------------------------------------------------
39936 * constants/methods manipulation
39937 * ----------------------------------------------------------------------------- */
39938
39939 /* Install Constants */
39940 SWIGINTERN void
39941 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
39942 PyObject *obj = 0;
39943 size_t i;
39944 for (i = 0; constants[i].type; ++i) {
39945 switch(constants[i].type) {
39946 case SWIG_PY_POINTER:
39947 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
39948 break;
39949 case SWIG_PY_BINARY:
39950 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
39951 break;
39952 default:
39953 obj = 0;
39954 break;
39955 }
39956 if (obj) {
39957 PyDict_SetItemString(d, constants[i].name, obj);
39958 Py_DECREF(obj);
39959 }
39960 }
39961 }
39962
39963 /* -----------------------------------------------------------------------------*/
39964 /* Fix SwigMethods to carry the callback ptrs when needed */
39965 /* -----------------------------------------------------------------------------*/
39966
39967 SWIGINTERN void
39968 SWIG_Python_FixMethods(PyMethodDef *methods,
39969 swig_const_info *const_table,
39970 swig_type_info **types,
39971 swig_type_info **types_initial) {
39972 size_t i;
39973 for (i = 0; methods[i].ml_name; ++i) {
39974 const char *c = methods[i].ml_doc;
39975 if (c && (c = strstr(c, "swig_ptr: "))) {
39976 int j;
39977 swig_const_info *ci = 0;
39978 const char *name = c + 10;
39979 for (j = 0; const_table[j].type; ++j) {
39980 if (strncmp(const_table[j].name, name,
39981 strlen(const_table[j].name)) == 0) {
39982 ci = &(const_table[j]);
39983 break;
39984 }
39985 }
39986 if (ci) {
39987 size_t shift = (ci->ptype) - types;
39988 swig_type_info *ty = types_initial[shift];
39989 size_t ldoc = (c - methods[i].ml_doc);
39990 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
39991 char *ndoc = (char*)malloc(ldoc + lptr + 10);
39992 if (ndoc) {
39993 char *buff = ndoc;
39994 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
39995 if (ptr) {
39996 strncpy(buff, methods[i].ml_doc, ldoc);
39997 buff += ldoc;
39998 strncpy(buff, "swig_ptr: ", 10);
39999 buff += 10;
40000 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
40001 methods[i].ml_doc = ndoc;
40002 }
40003 }
40004 }
40005 }
40006 }
40007 }
40008
40009 #ifdef __cplusplus
40010 }
40011 #endif
40012
40013 /* -----------------------------------------------------------------------------*
40014 * Partial Init method
40015 * -----------------------------------------------------------------------------*/
40016
40017 #ifdef __cplusplus
40018 extern "C"
40019 #endif
40020 SWIGEXPORT void SWIG_init(void) {
40021 PyObject *m, *d;
40022
40023 /* Fix SwigMethods to carry the callback ptrs when needed */
40024 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
40025
40026 m = Py_InitModule((char *) SWIG_name, SwigMethods);
40027 d = PyModule_GetDict(m);
40028
40029 SWIG_InitializeModule(0);
40030 SWIG_InstallConstants(d,swig_const_table);
40031
40032
40033 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
40034 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
40035 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
40036 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
40037 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
40038 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
40039 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
40040 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
40041 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
40042 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
40043 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
40044 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
40045 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
40046 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
40047 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
40048 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
40049 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
40050 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
40051 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
40052 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
40053 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
40054 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
40055 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
40056 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
40057 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
40058 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
40059 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
40060 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
40061 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
40062 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
40063 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
40064 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
40065 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
40066 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
40067 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
40068 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
40069 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
40070 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
40071 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
40072 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
40073 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
40074 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
40075 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
40076 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
40077 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
40078 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
40079 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
40080 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
40081 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
40082 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
40083 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
40084 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
40085 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
40086 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
40087 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
40088 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
40089 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
40090 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
40091 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
40092 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
40093 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
40094 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
40095 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
40096 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
40097 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
40098 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
40099 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
40100 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
40101 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
40102 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
40103 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
40104 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
40105 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
40106 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
40107 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
40108 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
40109 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
40110 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
40111 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
40112 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
40113 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
40114 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
40115 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
40116 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
40117 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
40118 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
40119 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
40120 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
40121 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
40122 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
40123 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
40124 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
40125 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
40126 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
40127 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
40128 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
40129 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
40130 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
40131 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
40132 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
40133 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
40134 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
40135 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
40136 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
40137 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
40138 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
40139 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
40140 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
40141 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
40142 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
40143 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
40144 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
40145 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
40146 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
40147 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
40148 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
40149 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
40150 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
40151 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
40152 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
40153 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
40154 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
40155 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
40156 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
40157 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
40158 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
40159 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
40160 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
40161 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
40162 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
40163 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
40164 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
40165 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
40166 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
40167 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
40168 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
40169 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
40170 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
40171 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
40172 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
40173 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
40174 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
40175 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
40176 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
40177 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
40178 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
40179 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
40180 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
40181
40182 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
40183
40184 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
40185 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
40186 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
40187 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
40188 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
40189 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
40190 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
40191 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
40192 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
40193 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
40194 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
40195 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
40196 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
40197 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
40198 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
40199 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
40200 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
40201 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
40202 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
40203 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
40204 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
40205 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
40206 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
40207 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
40208 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
40209 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
40210 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
40211 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
40212 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
40213 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
40214 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
40215 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
40216 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
40217 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
40218 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
40219 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
40220 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
40221 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
40222 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
40223 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
40224 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
40225 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
40226 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
40227 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
40228 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
40229 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
40230 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
40231 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
40232 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
40233 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
40234 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
40235 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
40236 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
40237
40238 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
40239
40240 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
40241 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
40242 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
40243 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
40244 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
40245 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
40246 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
40247 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
40248 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
40249 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
40250 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
40251 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
40252 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
40253 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
40254 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
40255 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
40256 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
40257 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
40258 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
40259 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
40260 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
40261 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
40262 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
40263 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
40264 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
40265 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
40266 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
40267 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
40268 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
40269 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
40270 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
40271 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
40272 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
40273 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
40274 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
40275 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
40276 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
40277 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
40278 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
40279 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
40280 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
40281 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
40282 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
40283 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
40284 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
40285 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
40286 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
40287 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
40288 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
40289 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
40290 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
40291 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
40292 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
40293 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
40294 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
40295 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
40296 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
40297 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
40298 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
40299 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
40300 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
40301 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
40302 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
40303 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
40304 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
40305 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
40306 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
40307 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
40308 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
40309 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
40310 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
40311 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
40312 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
40313 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
40314 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
40315 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
40316
40317 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
40318
40319 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
40320 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
40321 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
40322 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
40323 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
40324 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
40325 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
40326 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
40327 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
40328 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
40329 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
40330 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
40331 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
40332 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
40333 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
40334 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
40335 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
40336 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
40337 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
40338 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
40339 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
40340 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
40341 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
40342 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
40343 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
40344 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
40345 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
40346 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
40347 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
40348 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
40349 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
40350 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
40351 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
40352 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
40353 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
40354 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
40355 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
40356 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
40357 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
40358 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
40359 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
40360 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
40361 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
40362 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
40363 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
40364 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
40365 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
40366 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
40367 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
40368 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
40369 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
40370 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
40371 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
40372 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
40373 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
40374 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
40375 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
40376 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
40377 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
40378 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
40379 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
40380 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
40381 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
40382 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
40383 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
40384 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
40385 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
40386 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
40387 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
40388 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
40389 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
40390 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
40391 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
40392 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
40393 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
40394 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
40395 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
40396 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
40397 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
40398 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
40399 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
40400 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
40401 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
40402 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
40403 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
40404 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
40405 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
40406 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
40407 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
40408 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
40409 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
40410 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
40411 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
40412 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
40413 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
40414 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
40415 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
40416 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
40417 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
40418 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
40419 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
40420 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
40421 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
40422 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
40423 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
40424 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
40425 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
40426 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
40427 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
40428 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
40429 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
40430 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
40431 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
40432 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
40433 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
40434 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
40435 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
40436 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
40437 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
40438 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
40439 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
40440 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
40441 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
40442 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
40443 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
40444 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
40445 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
40446 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
40447 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
40448 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
40449 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
40450 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
40451 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
40452 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
40453 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
40454 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
40455 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
40456 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
40457 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
40458 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
40459 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
40460 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
40461 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
40462 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
40463 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
40464 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
40465 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
40466 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
40467 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
40468 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
40469 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
40470 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
40471 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
40472 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
40473 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
40474 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
40475 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
40476 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
40477 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
40478 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
40479 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
40480 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
40481 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
40482 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
40483 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
40484 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
40485 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
40486 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
40487 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
40488 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
40489 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
40490 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
40491 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
40492 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
40493 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
40494 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
40495 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
40496 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
40497 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
40498 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
40499 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
40500 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
40501 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
40502 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
40503 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
40504 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
40505 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
40506 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
40507 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
40508 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
40509 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
40510 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
40511 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
40512 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
40513 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
40514 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
40515 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
40516 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
40517 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
40518 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
40519
40520 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
40521 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
40522 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
40523 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
40524
40525 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
40526 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
40527 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
40528 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
40529 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
40530 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
40531 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
40532 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
40533 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
40534 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
40535 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
40536 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
40537 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
40538 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
40539 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
40540 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
40541 }
40542
wxWidgets (Impactor)