]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Added test bitmap.
[wxWidgets.git] / wxPython / src / msw / _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_wxMetafile swig_types[93]
2560 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2561 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseState swig_types[99]
2566 #define SWIGTYPE_p_wxMoveEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[101]
2568 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNcPaintEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNotifyEvent swig_types[104]
2571 #define SWIGTYPE_p_wxObject swig_types[105]
2572 #define SWIGTYPE_p_wxOutputStream swig_types[106]
2573 #define SWIGTYPE_p_wxPCXHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNGHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNMHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPaintEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaperSize swig_types[112]
2579 #define SWIGTYPE_p_wxPlatformInfo swig_types[113]
2580 #define SWIGTYPE_p_wxPoint swig_types[114]
2581 #define SWIGTYPE_p_wxPowerEvent swig_types[115]
2582 #define SWIGTYPE_p_wxProcessEvent swig_types[116]
2583 #define SWIGTYPE_p_wxPyApp swig_types[117]
2584 #define SWIGTYPE_p_wxPyArtProvider swig_types[118]
2585 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[119]
2586 #define SWIGTYPE_p_wxPyCommandEvent swig_types[120]
2587 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[121]
2588 #define SWIGTYPE_p_wxPyDropSource swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropTarget swig_types[123]
2590 #define SWIGTYPE_p_wxPyEvent swig_types[124]
2591 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[125]
2592 #define SWIGTYPE_p_wxPyImageHandler swig_types[126]
2593 #define SWIGTYPE_p_wxPyLog swig_types[127]
2594 #define SWIGTYPE_p_wxPyProcess swig_types[128]
2595 #define SWIGTYPE_p_wxPySizer swig_types[129]
2596 #define SWIGTYPE_p_wxPyTextDataObject swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[131]
2598 #define SWIGTYPE_p_wxPyTimer swig_types[132]
2599 #define SWIGTYPE_p_wxPyTipProvider swig_types[133]
2600 #define SWIGTYPE_p_wxPyValidator swig_types[134]
2601 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[135]
2602 #define SWIGTYPE_p_wxRect swig_types[136]
2603 #define SWIGTYPE_p_wxScrollEvent swig_types[137]
2604 #define SWIGTYPE_p_wxScrollWinEvent swig_types[138]
2605 #define SWIGTYPE_p_wxSetCursorEvent swig_types[139]
2606 #define SWIGTYPE_p_wxShowEvent swig_types[140]
2607 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[141]
2608 #define SWIGTYPE_p_wxSize swig_types[142]
2609 #define SWIGTYPE_p_wxSizeEvent swig_types[143]
2610 #define SWIGTYPE_p_wxSizer swig_types[144]
2611 #define SWIGTYPE_p_wxSizerItem swig_types[145]
2612 #define SWIGTYPE_p_wxSound swig_types[146]
2613 #define SWIGTYPE_p_wxStandardPaths swig_types[147]
2614 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[148]
2615 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStopWatch swig_types[150]
2617 #define SWIGTYPE_p_wxString swig_types[151]
2618 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[152]
2619 #define SWIGTYPE_p_wxSystemOptions swig_types[153]
2620 #define SWIGTYPE_p_wxSystemSettings swig_types[154]
2621 #define SWIGTYPE_p_wxTIFFHandler swig_types[155]
2622 #define SWIGTYPE_p_wxTextCtrl swig_types[156]
2623 #define SWIGTYPE_p_wxTextDataObject swig_types[157]
2624 #define SWIGTYPE_p_wxTimeSpan swig_types[158]
2625 #define SWIGTYPE_p_wxTimer swig_types[159]
2626 #define SWIGTYPE_p_wxTimerEvent swig_types[160]
2627 #define SWIGTYPE_p_wxTimerRunner swig_types[161]
2628 #define SWIGTYPE_p_wxTipProvider swig_types[162]
2629 #define SWIGTYPE_p_wxToolTip swig_types[163]
2630 #define SWIGTYPE_p_wxURLDataObject swig_types[164]
2631 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[165]
2632 #define SWIGTYPE_p_wxValidator swig_types[166]
2633 #define SWIGTYPE_p_wxVideoMode swig_types[167]
2634 #define SWIGTYPE_p_wxWindow swig_types[168]
2635 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[169]
2636 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[170]
2637 #define SWIGTYPE_p_wxWindowDisabler swig_types[171]
2638 #define SWIGTYPE_p_wxXPMHandler swig_types[172]
2639 static swig_type_info *swig_types[174];
2640 static swig_module_info swig_module = {swig_types, 173, 0, 0, 0, 0};
2641 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2642 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2643
2644 /* -------- TYPES TABLE (END) -------- */
2645
2646 #if (PY_VERSION_HEX <= 0x02000000)
2647 # if !defined(SWIG_PYTHON_CLASSIC)
2648 # error "This python version requires to use swig with the '-classic' option"
2649 # endif
2650 #endif
2651 #if (PY_VERSION_HEX <= 0x02020000)
2652 # error "This python version requires to use swig with the '-nomodern' option"
2653 #endif
2654 #if (PY_VERSION_HEX <= 0x02020000)
2655 # error "This python version requires to use swig with the '-nomodernargs' option"
2656 #endif
2657 #ifndef METH_O
2658 # error "This python version requires to use swig with the '-nofastunpack' option"
2659 #endif
2660
2661 /*-----------------------------------------------
2662 @(target):= _misc_.so
2663 ------------------------------------------------*/
2664 #define SWIG_init init_misc_
2665
2666 #define SWIG_name "_misc_"
2667
2668 #define SWIGVERSION 0x010329
2669
2670
2671 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2672 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2673
2674
2675 #include <stdexcept>
2676
2677
2678 namespace swig {
2679 class PyObject_ptr {
2680 protected:
2681 PyObject *_obj;
2682
2683 public:
2684 PyObject_ptr() :_obj(0)
2685 {
2686 }
2687
2688 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2689 {
2690 Py_XINCREF(_obj);
2691 }
2692
2693 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2694 {
2695 if (initial_ref) Py_XINCREF(_obj);
2696 }
2697
2698 PyObject_ptr & operator=(const PyObject_ptr& item)
2699 {
2700 Py_XINCREF(item._obj);
2701 Py_XDECREF(_obj);
2702 _obj = item._obj;
2703 return *this;
2704 }
2705
2706 ~PyObject_ptr()
2707 {
2708 Py_XDECREF(_obj);
2709 }
2710
2711 operator PyObject *() const
2712 {
2713 return _obj;
2714 }
2715
2716 PyObject *operator->() const
2717 {
2718 return _obj;
2719 }
2720 };
2721 }
2722
2723
2724 namespace swig {
2725 struct PyObject_var : PyObject_ptr {
2726 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2727
2728 PyObject_var & operator = (PyObject* obj)
2729 {
2730 Py_XDECREF(_obj);
2731 _obj = obj;
2732 return *this;
2733 }
2734 };
2735 }
2736
2737
2738 #include "wx/wxPython/wxPython.h"
2739 #include "wx/wxPython/pyclasses.h"
2740 #include "wx/wxPython/pyistream.h"
2741
2742 static const wxString wxPyEmptyString(wxEmptyString);
2743
2744
2745
2746 #define SWIG_From_long PyInt_FromLong
2747
2748
2749 SWIGINTERNINLINE PyObject *
2750 SWIG_From_int (int value)
2751 {
2752 return SWIG_From_long (value);
2753 }
2754
2755
2756 #include <limits.h>
2757 #ifndef LLONG_MIN
2758 # define LLONG_MIN LONG_LONG_MIN
2759 #endif
2760 #ifndef LLONG_MAX
2761 # define LLONG_MAX LONG_LONG_MAX
2762 #endif
2763 #ifndef ULLONG_MAX
2764 # define ULLONG_MAX ULONG_LONG_MAX
2765 #endif
2766
2767
2768 SWIGINTERN int
2769 SWIG_AsVal_long (PyObject* obj, long* val)
2770 {
2771 if (PyNumber_Check(obj)) {
2772 if (val) *val = PyInt_AsLong(obj);
2773 return SWIG_OK;
2774 }
2775 return SWIG_TypeError;
2776 }
2777
2778
2779 SWIGINTERN int
2780 SWIG_AsVal_int (PyObject * obj, int *val)
2781 {
2782 long v;
2783 int res = SWIG_AsVal_long (obj, &v);
2784 if (SWIG_IsOK(res)) {
2785 if ((v < INT_MIN || v > INT_MAX)) {
2786 return SWIG_OverflowError;
2787 } else {
2788 if (val) *val = static_cast< int >(v);
2789 }
2790 }
2791 return res;
2792 }
2793
2794 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2795
2796 #include <wx/stockitem.h>
2797
2798 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2799 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2800 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2801
2802 SWIGINTERN int
2803 SWIG_AsVal_bool (PyObject *obj, bool *val)
2804 {
2805 if (obj == Py_True) {
2806 if (val) *val = true;
2807 return SWIG_OK;
2808 } else if (obj == Py_False) {
2809 if (val) *val = false;
2810 return SWIG_OK;
2811 } else {
2812 long v = 0;
2813 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2814 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2815 return res;
2816 }
2817 }
2818
2819
2820 SWIGINTERN int
2821 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2822 {
2823 long v = 0;
2824 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2825 return SWIG_TypeError;
2826 }
2827 else if (val)
2828 *val = (unsigned long)v;
2829 return SWIG_OK;
2830 }
2831
2832
2833 SWIGINTERNINLINE PyObject*
2834 SWIG_From_unsigned_SS_long (unsigned long value)
2835 {
2836 return (value > LONG_MAX) ?
2837 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2838 }
2839
2840
2841 void* wxGetXDisplay()
2842 {
2843 #ifdef __WXGTK__
2844 return wxGetDisplay();
2845 #else
2846 return NULL;
2847 #endif
2848 }
2849
2850
2851 wxWindow* FindWindowAtPointer() {
2852 wxPoint unused;
2853 return wxFindWindowAtPointer(unused);
2854 }
2855
2856
2857 bool wxThread_IsMain() {
2858 #ifdef WXP_WITH_THREAD
2859 return wxThread::IsMain();
2860 #else
2861 return true;
2862 #endif
2863 }
2864
2865 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2866 delete self;
2867 }
2868
2869 #include <wx/snglinst.h>
2870
2871
2872 #ifdef __WXMSW__
2873 #include <wx/msw/private.h>
2874 #include <wx/dynload.h>
2875 #endif
2876
2877
2878
2879 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2880 #if 0
2881 , int method
2882 #endif
2883 )
2884 {
2885 #ifdef __WXMSW__
2886 #if 0
2887 switch (method)
2888 {
2889 case 1:
2890 // This one only partially works. Appears to be an undocumented
2891 // "standard" convention that not all widgets adhear to. For
2892 // example, for some widgets backgrounds or non-client areas may
2893 // not be painted.
2894 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2895 break;
2896
2897 case 2:
2898 #endif
2899 // This one works much better, nearly all widgets and their
2900 // children are captured correctly[**]. Prior to the big
2901 // background erase changes that Vadim did in 2004-2005 this
2902 // method failed badly on XP with Themes activated, most native
2903 // widgets draw only partially, if at all. Without themes it
2904 // worked just like on Win2k. After those changes this method
2905 // works very well.
2906 //
2907 // ** For example the radio buttons in a wxRadioBox are not its
2908 // children by default, but you can capture it via the panel
2909 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2910 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2911 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2912 PRF_ERASEBKGND | PRF_OWNED );
2913 return true;
2914 #if 0
2915 break;
2916
2917 case 3:
2918 // This one is only defined in the latest SDK and is only
2919 // available on XP. MSDN says it is similar to sending WM_PRINT
2920 // so I expect that it will work similar to the above. Since it
2921 // is avaialble only on XP, it can't be compiled like this and
2922 // will have to be loaded dynamically.
2923 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2924
2925 // fall through
2926
2927 case 4:
2928 // Use PrintWindow if available, or fallback to WM_PRINT
2929 // otherwise. Unfortunately using PrintWindow is even worse than
2930 // WM_PRINT. For most native widgets nothing is drawn to the dc
2931 // at all, with or without Themes.
2932 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2933 static bool s_triedToLoad = false;
2934 static PrintWindow_t pfnPrintWindow = NULL;
2935 if ( !s_triedToLoad )
2936 {
2937
2938 s_triedToLoad = true;
2939 wxDynamicLibrary dllUser32(_T("user32.dll"));
2940 if ( dllUser32.IsLoaded() )
2941 {
2942 wxLogNull nolog; // Don't report errors here
2943 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2944 }
2945 }
2946 if (pfnPrintWindow)
2947 {
2948 //printf("Using PrintWindow\n");
2949 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2950 }
2951 else
2952 {
2953 //printf("Using WM_PRINT\n");
2954 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2955 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2956 PRF_ERASEBKGND | PRF_OWNED );
2957 }
2958 }
2959 #endif // 0
2960 #else
2961 return false;
2962 #endif // __WXMSW__
2963 }
2964
2965
2966
2967 #include <wx/tipdlg.h>
2968
2969
2970 SWIGINTERNINLINE PyObject *
2971 SWIG_From_size_t (size_t value)
2972 {
2973 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2974 }
2975
2976
2977 class wxPyTipProvider : public wxTipProvider {
2978 public:
2979 wxPyTipProvider(size_t currentTip)
2980 : wxTipProvider(currentTip) {}
2981
2982 DEC_PYCALLBACK_STRING__pure(GetTip);
2983 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2984 PYPRIVATE;
2985 };
2986
2987 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2988 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2989
2990
2991 SWIGINTERNINLINE int
2992 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2993 {
2994 unsigned long v;
2995 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2996 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2997 return res;
2998 }
2999
3000
3001 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3002
3003 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3004
3005 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3006 : wxTimer(owner, id)
3007 {
3008 if (owner == NULL)
3009 SetOwner(this);
3010 }
3011
3012
3013 SWIGINTERN swig_type_info*
3014 SWIG_pchar_descriptor()
3015 {
3016 static int init = 0;
3017 static swig_type_info* info = 0;
3018 if (!init) {
3019 info = SWIG_TypeQuery("_p_char");
3020 init = 1;
3021 }
3022 return info;
3023 }
3024
3025
3026 SWIGINTERNINLINE PyObject *
3027 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3028 {
3029 if (carray) {
3030 if (size > INT_MAX) {
3031 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3032 return pchar_descriptor ?
3033 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3034 } else {
3035 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3036 }
3037 } else {
3038 return SWIG_Py_Void();
3039 }
3040 }
3041
3042
3043 SWIGINTERNINLINE PyObject *
3044 SWIG_FromCharPtr(const char *cptr)
3045 {
3046 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3047 }
3048
3049
3050 SWIGINTERN int
3051 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3052 {
3053 unsigned long v;
3054 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3055 if (SWIG_IsOK(res)) {
3056 if ((v > UINT_MAX)) {
3057 return SWIG_OverflowError;
3058 } else {
3059 if (val) *val = static_cast< unsigned int >(v);
3060 }
3061 }
3062 return res;
3063 }
3064
3065 SWIGINTERN wxString wxLog_TimeStamp(){
3066 wxString msg;
3067 wxLog::TimeStamp(&msg);
3068 return msg;
3069 }
3070 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3071 // Make some wrappers that double any % signs so they are 'escaped'
3072 void wxPyLogFatalError(const wxString& msg)
3073 {
3074 wxString m(msg);
3075 m.Replace(wxT("%"), wxT("%%"));
3076 wxLogFatalError(m);
3077 }
3078
3079 void wxPyLogError(const wxString& msg)
3080 {
3081 wxString m(msg);
3082 m.Replace(wxT("%"), wxT("%%"));
3083 wxLogError(m);
3084 }
3085
3086 void wxPyLogWarning(const wxString& msg)
3087 {
3088 wxString m(msg);
3089 m.Replace(wxT("%"), wxT("%%"));
3090 wxLogWarning(m);
3091 }
3092
3093 void wxPyLogMessage(const wxString& msg)
3094 {
3095 wxString m(msg);
3096 m.Replace(wxT("%"), wxT("%%"));
3097 wxLogMessage(m);
3098 }
3099
3100 void wxPyLogInfo(const wxString& msg)
3101 {
3102 wxString m(msg);
3103 m.Replace(wxT("%"), wxT("%%"));
3104 wxLogInfo(m);
3105 }
3106
3107 void wxPyLogDebug(const wxString& msg)
3108 {
3109 wxString m(msg);
3110 m.Replace(wxT("%"), wxT("%%"));
3111 wxLogDebug(m);
3112 }
3113
3114 void wxPyLogVerbose(const wxString& msg)
3115 {
3116 wxString m(msg);
3117 m.Replace(wxT("%"), wxT("%%"));
3118 wxLogVerbose(m);
3119 }
3120
3121 void wxPyLogStatus(const wxString& msg)
3122 {
3123 wxString m(msg);
3124 m.Replace(wxT("%"), wxT("%%"));
3125 wxLogStatus(m);
3126 }
3127
3128 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3129 {
3130 wxString m(msg);
3131 m.Replace(wxT("%"), wxT("%%"));
3132 wxLogStatus(pFrame, m);
3133 }
3134
3135 void wxPyLogSysError(const wxString& msg)
3136 {
3137 wxString m(msg);
3138 m.Replace(wxT("%"), wxT("%%"));
3139 wxLogSysError(m);
3140 }
3141
3142 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3143 {
3144 wxString m(msg);
3145 m.Replace(wxT("%"), wxT("%%"));
3146 wxLogGeneric(level, m);
3147 }
3148
3149 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3150 {
3151 wxString m(msg);
3152 m.Replace(wxT("%"), wxT("%%"));
3153 wxLogTrace(mask, m);
3154 }
3155
3156 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3157 {
3158 wxString m(msg);
3159 m.Replace(wxT("%"), wxT("%%"));
3160 wxLogTrace(mask, m);
3161 }
3162
3163
3164
3165 // A wxLog class that can be derived from in wxPython
3166 class wxPyLog : public wxLog {
3167 public:
3168 wxPyLog() : wxLog() {}
3169
3170 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3171 bool found;
3172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3173 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3174 PyObject* s = wx2PyString(szString);
3175 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3176 Py_DECREF(s);
3177 }
3178 wxPyEndBlockThreads(blocked);
3179 if (! found)
3180 wxLog::DoLog(level, szString, t);
3181 }
3182
3183 virtual void DoLogString(const wxChar *szString, time_t t) {
3184 bool found;
3185 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3186 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3187 PyObject* s = wx2PyString(szString);
3188 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3189 Py_DECREF(s);
3190 }
3191 wxPyEndBlockThreads(blocked);
3192 if (! found)
3193 wxLog::DoLogString(szString, t);
3194 }
3195
3196 DEC_PYCALLBACK_VOID_(Flush);
3197 PYPRIVATE;
3198 };
3199 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3200
3201
3202
3203
3204 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3205
3206
3207 #include <wx/joystick.h>
3208
3209
3210 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3211 // A C++ stub class for wxJoystick for platforms that don't have it.
3212 class wxJoystick : public wxObject {
3213 public:
3214 wxJoystick(int joystick = wxJOYSTICK1) {
3215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3216 PyErr_SetString(PyExc_NotImplementedError,
3217 "wxJoystick is not available on this platform.");
3218 wxPyEndBlockThreads(blocked);
3219 }
3220 wxPoint GetPosition() { return wxPoint(-1,-1); }
3221 int GetZPosition() { return -1; }
3222 int GetButtonState() { return -1; }
3223 int GetPOVPosition() { return -1; }
3224 int GetPOVCTSPosition() { return -1; }
3225 int GetRudderPosition() { return -1; }
3226 int GetUPosition() { return -1; }
3227 int GetVPosition() { return -1; }
3228 int GetMovementThreshold() { return -1; }
3229 void SetMovementThreshold(int threshold) {}
3230
3231 bool IsOk(void) { return false; }
3232 int GetNumberJoysticks() { return -1; }
3233 int GetManufacturerId() { return -1; }
3234 int GetProductId() { return -1; }
3235 wxString GetProductName() { return wxEmptyString; }
3236 int GetXMin() { return -1; }
3237 int GetYMin() { return -1; }
3238 int GetZMin() { return -1; }
3239 int GetXMax() { return -1; }
3240 int GetYMax() { return -1; }
3241 int GetZMax() { return -1; }
3242 int GetNumberButtons() { return -1; }
3243 int GetNumberAxes() { return -1; }
3244 int GetMaxButtons() { return -1; }
3245 int GetMaxAxes() { return -1; }
3246 int GetPollingMin() { return -1; }
3247 int GetPollingMax() { return -1; }
3248 int GetRudderMin() { return -1; }
3249 int GetRudderMax() { return -1; }
3250 int GetUMin() { return -1; }
3251 int GetUMax() { return -1; }
3252 int GetVMin() { return -1; }
3253 int GetVMax() { return -1; }
3254
3255 bool HasRudder() { return false; }
3256 bool HasZ() { return false; }
3257 bool HasU() { return false; }
3258 bool HasV() { return false; }
3259 bool HasPOV() { return false; }
3260 bool HasPOV4Dir() { return false; }
3261 bool HasPOVCTS() { return false; }
3262
3263 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3264 bool ReleaseCapture() { return false; }
3265 };
3266 #endif
3267
3268
3269 #include <wx/sound.h>
3270
3271
3272 #if !wxUSE_SOUND
3273 // A C++ stub class for wxWave for platforms that don't have it.
3274 class wxSound : public wxObject
3275 {
3276 public:
3277 wxSound() {
3278 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3279 PyErr_SetString(PyExc_NotImplementedError,
3280 "wxSound is not available on this platform.");
3281 wxPyEndBlockThreads(blocked);
3282 }
3283 wxSound(const wxString&/*, bool*/) {
3284 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3285 PyErr_SetString(PyExc_NotImplementedError,
3286 "wxSound is not available on this platform.");
3287 wxPyEndBlockThreads(blocked);
3288 }
3289 wxSound(int, const wxByte*) {
3290 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3291 PyErr_SetString(PyExc_NotImplementedError,
3292 "wxSound is not available on this platform.");
3293 wxPyEndBlockThreads(blocked);
3294 }
3295
3296 ~wxSound() {};
3297
3298 bool Create(const wxString&/*, bool*/) { return false; }
3299 bool Create(int, const wxByte*) { return false; };
3300 bool IsOk() { return false; };
3301 bool Play(unsigned) const { return false; }
3302 static bool Play(const wxString&, unsigned) { return false; }
3303 static void Stop() {}
3304 };
3305
3306 #endif
3307
3308 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3309 if (fileName.Length() == 0)
3310 return new wxSound;
3311 else
3312 return new wxSound(fileName);
3313 }
3314 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3315 unsigned char* buffer; int size;
3316 wxSound *sound = NULL;
3317
3318 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3319 if (!PyArg_Parse(data, "t#", &buffer, &size))
3320 goto done;
3321 sound = new wxSound(size, buffer);
3322 done:
3323 wxPyEndBlockThreads(blocked);
3324 return sound;
3325 }
3326 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3327 #ifndef __WXMAC__
3328 unsigned char* buffer;
3329 int size;
3330 bool rv = false;
3331
3332 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3333 if (!PyArg_Parse(data, "t#", &buffer, &size))
3334 goto done;
3335 rv = self->Create(size, buffer);
3336 done:
3337 wxPyEndBlockThreads(blocked);
3338 return rv;
3339 #else
3340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3341 PyErr_SetString(PyExc_NotImplementedError,
3342 "Create from data is not available on this platform.");
3343 wxPyEndBlockThreads(blocked);
3344 return false;
3345 #endif
3346 }
3347
3348 #include <wx/mimetype.h>
3349
3350 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3351 wxString str;
3352 if (self->GetMimeType(&str))
3353 return wx2PyString(str);
3354 else
3355 RETURN_NONE();
3356 }
3357 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3358 wxArrayString arr;
3359 if (self->GetMimeTypes(arr))
3360 return wxArrayString2PyList_helper(arr);
3361 else
3362 RETURN_NONE();
3363 }
3364 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3365 wxArrayString arr;
3366 if (self->GetExtensions(arr))
3367 return wxArrayString2PyList_helper(arr);
3368 else
3369 RETURN_NONE();
3370 }
3371 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3372 wxIconLocation loc;
3373 if (self->GetIcon(&loc))
3374 return new wxIcon(loc);
3375 else
3376 return NULL;
3377 }
3378 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3379 wxIconLocation loc;
3380 if (self->GetIcon(&loc)) {
3381 wxString iconFile = loc.GetFileName();
3382 int iconIndex = -1;
3383
3384 iconIndex = loc.GetIndex();
3385
3386 // Make a tuple and put the values in it
3387 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3388 PyObject* tuple = PyTuple_New(3);
3389 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3390 wxT("wxIcon"), true));
3391 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3392 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3393 wxPyEndBlockThreads(blocked);
3394 return tuple;
3395 }
3396 else
3397 RETURN_NONE();
3398 }
3399 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3400 wxString str;
3401 if (self->GetDescription(&str))
3402 return wx2PyString(str);
3403 else
3404 RETURN_NONE();
3405 }
3406 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3407 wxString str;
3408 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3409 return wx2PyString(str);
3410 else
3411 RETURN_NONE();
3412 }
3413 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3414 wxString str;
3415 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3416 return wx2PyString(str);
3417 else
3418 RETURN_NONE();
3419 }
3420 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3421 wxArrayString verbs;
3422 wxArrayString commands;
3423 if (self->GetAllCommands(&verbs, &commands,
3424 wxFileType::MessageParameters(filename, mimetype))) {
3425 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3426 PyObject* tuple = PyTuple_New(2);
3427 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3428 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3429 wxPyEndBlockThreads(blocked);
3430 return tuple;
3431 }
3432 else
3433 RETURN_NONE();
3434 }
3435 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3436 return wxFileType::ExpandCommand(command,
3437 wxFileType::MessageParameters(filename, mimetype));
3438 }
3439 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3440 wxArrayString arr;
3441 self->EnumAllFileTypes(arr);
3442 return wxArrayString2PyList_helper(arr);
3443 }
3444
3445 #include <wx/artprov.h>
3446
3447 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3448 static const wxString wxPyART_MENU(wxART_MENU);
3449 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3450 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3451 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3452 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3453 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3454 static const wxString wxPyART_OTHER(wxART_OTHER);
3455 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3456 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3457 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3458 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3459 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3460 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3461 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3462 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3463 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3464 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3465 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3466 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3467 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3468 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3469 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3470 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3471 static const wxString wxPyART_PRINT(wxART_PRINT);
3472 static const wxString wxPyART_HELP(wxART_HELP);
3473 static const wxString wxPyART_TIP(wxART_TIP);
3474 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3475 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3476 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3477 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3478 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3479 static const wxString wxPyART_CDROM(wxART_CDROM);
3480 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3481 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3482 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3483 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3484 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3485 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3486 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3487 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3488 static const wxString wxPyART_ERROR(wxART_ERROR);
3489 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3490 static const wxString wxPyART_WARNING(wxART_WARNING);
3491 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3492 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3493 static const wxString wxPyART_COPY(wxART_COPY);
3494 static const wxString wxPyART_CUT(wxART_CUT);
3495 static const wxString wxPyART_PASTE(wxART_PASTE);
3496 static const wxString wxPyART_DELETE(wxART_DELETE);
3497 static const wxString wxPyART_NEW(wxART_NEW);
3498 static const wxString wxPyART_UNDO(wxART_UNDO);
3499 static const wxString wxPyART_REDO(wxART_REDO);
3500 static const wxString wxPyART_QUIT(wxART_QUIT);
3501 static const wxString wxPyART_FIND(wxART_FIND);
3502 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3503 // Python aware wxArtProvider
3504 class wxPyArtProvider : public wxArtProvider {
3505 public:
3506
3507 virtual wxBitmap CreateBitmap(const wxArtID& id,
3508 const wxArtClient& client,
3509 const wxSize& size) {
3510 wxBitmap rval = wxNullBitmap;
3511 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3512 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3513 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3514 PyObject* ro;
3515 wxBitmap* ptr;
3516 PyObject* s1, *s2;
3517 s1 = wx2PyString(id);
3518 s2 = wx2PyString(client);
3519 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3520 Py_DECREF(so);
3521 Py_DECREF(s1);
3522 Py_DECREF(s2);
3523 if (ro) {
3524 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3525 rval = *ptr;
3526 Py_DECREF(ro);
3527 }
3528 }
3529 wxPyEndBlockThreads(blocked);
3530 return rval;
3531 }
3532
3533 PYPRIVATE;
3534 };
3535
3536 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3537
3538
3539
3540 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3541 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3542 PyObject* ret = PyTuple_New(3);
3543 if (ret) {
3544 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3545 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3546 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3547 }
3548 wxPyEndBlockThreads(blocked);
3549 return ret;
3550 }
3551
3552 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3553 bool cont;
3554 long index = 0;
3555 wxString value;
3556
3557 cont = self->GetFirstGroup(value, index);
3558 return __EnumerationHelper(cont, value, index);
3559 }
3560 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3561 bool cont;
3562 wxString value;
3563
3564 cont = self->GetNextGroup(value, index);
3565 return __EnumerationHelper(cont, value, index);
3566 }
3567 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3568 bool cont;
3569 long index = 0;
3570 wxString value;
3571
3572 cont = self->GetFirstEntry(value, index);
3573 return __EnumerationHelper(cont, value, index);
3574 }
3575 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3576 bool cont;
3577 wxString value;
3578
3579 cont = self->GetNextEntry(value, index);
3580 return __EnumerationHelper(cont, value, index);
3581 }
3582 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3583 long rv;
3584 self->Read(key, &rv, defaultVal);
3585 return rv;
3586 }
3587
3588 SWIGINTERN int
3589 SWIG_AsVal_double (PyObject *obj, double* val)
3590 {
3591 if (PyNumber_Check(obj)) {
3592 if (val) *val = PyFloat_AsDouble(obj);
3593 return SWIG_OK;
3594 }
3595 return SWIG_TypeError;
3596 }
3597
3598 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3599 double rv;
3600 self->Read(key, &rv, defaultVal);
3601 return rv;
3602 }
3603
3604 #define SWIG_From_double PyFloat_FromDouble
3605
3606 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3607 bool rv;
3608 self->Read(key, &rv, defaultVal);
3609 return rv;
3610 }
3611
3612 #include <wx/datetime.h>
3613
3614 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3615 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3616
3617 #define LOCAL_TZ wxDateTime::Local
3618
3619 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3620 wxString am;
3621 wxString pm;
3622 wxDateTime::GetAmPmStrings(&am, &pm);
3623 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3624 PyObject* tup = PyTuple_New(2);
3625 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3626 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3627 wxPyEndBlockThreads(blocked);
3628 return tup;
3629 }
3630
3631 SWIGINTERNINLINE PyObject *
3632 SWIG_From_unsigned_SS_int (unsigned int value)
3633 {
3634 return SWIG_From_unsigned_SS_long (value);
3635 }
3636
3637 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3638 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3639 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3640 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3641 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3642 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3643 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3644 return (*self < *other);
3645 }
3646 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3647 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3648 return (*self <= *other);
3649 }
3650 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3651 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3652 return (*self > *other);
3653 }
3654 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3655 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3656 return (*self >= *other);
3657 }
3658 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3659 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3660 return (*self == *other);
3661 }
3662 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3663 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3664 return (*self != *other);
3665 }
3666 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3667 const wxChar* rv;
3668 const wxChar* _date = date;
3669 rv = self->ParseRfc822Date(_date);
3670 if (rv == NULL) return -1;
3671 return rv - _date;
3672 }
3673 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3674 const wxChar* rv;
3675 const wxChar* _date = date;
3676 rv = self->ParseFormat(_date, format, dateDef);
3677 if (rv == NULL) return -1;
3678 return rv - _date;
3679 }
3680 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3681 const wxChar* rv;
3682 const wxChar* _datetime = datetime;
3683 rv = self->ParseDateTime(_datetime);
3684 if (rv == NULL) return -1;
3685 return rv - _datetime;
3686 }
3687 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3688 const wxChar* rv;
3689 const wxChar* _date = date;
3690 rv = self->ParseDate(_date);
3691 if (rv == NULL) return -1;
3692 return rv - _date;
3693 }
3694 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3695 const wxChar* rv;
3696 const wxChar* _time = time;
3697 rv = self->ParseTime(_time);
3698 if (rv == NULL) return -1;
3699 return rv - _time;
3700 }
3701 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3702 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3703 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3704 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3705 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3706 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3707 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3708 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3709 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3710 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3711 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3712 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3713 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3714 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3715 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3716 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3717
3718 #include <wx/dataobj.h>
3719
3720 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3721 size_t count = self->GetFormatCount(dir);
3722 wxDataFormat* formats = new wxDataFormat[count];
3723 self->GetAllFormats(formats, dir);
3724
3725 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3726 PyObject* list = PyList_New(count);
3727 for (size_t i=0; i<count; i++) {
3728 wxDataFormat* format = new wxDataFormat(formats[i]);
3729 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3730 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3731 }
3732 wxPyEndBlockThreads(blocked);
3733 delete [] formats;
3734 return list;
3735 }
3736 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3737 PyObject* rval = NULL;
3738 size_t size = self->GetDataSize(format);
3739 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3740 if (size) {
3741 char* buf = new char[size];
3742 if (self->GetDataHere(format, buf))
3743 rval = PyString_FromStringAndSize(buf, size);
3744 delete [] buf;
3745 }
3746 if (! rval) {
3747 rval = Py_None;
3748 Py_INCREF(rval);
3749 }
3750 wxPyEndBlockThreads(blocked);
3751 return rval;
3752 }
3753 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3754 bool rval;
3755 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3756 if (PyString_Check(data)) {
3757 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3758 }
3759 else {
3760 // raise a TypeError if not a string
3761 PyErr_SetString(PyExc_TypeError, "String expected.");
3762 rval = false;
3763 }
3764 wxPyEndBlockThreads(blocked);
3765 return rval;
3766 }
3767 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3768 PyObject* rval = NULL;
3769 size_t size = self->GetDataSize();
3770 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3771 if (size) {
3772 char* buf = new char[size];
3773 if (self->GetDataHere(buf))
3774 rval = PyString_FromStringAndSize(buf, size);
3775 delete [] buf;
3776 }
3777 if (! rval) {
3778 rval = Py_None;
3779 Py_INCREF(rval);
3780 }
3781 wxPyEndBlockThreads(blocked);
3782 return rval;
3783 }
3784 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3785 bool rval;
3786 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3787 if (PyString_Check(data)) {
3788 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3789 }
3790 else {
3791 // raise a TypeError if not a string
3792 PyErr_SetString(PyExc_TypeError, "String expected.");
3793 rval = false;
3794 }
3795 wxPyEndBlockThreads(blocked);
3796 return rval;
3797 }
3798 // Create a new class for wxPython to use
3799 class wxPyDataObjectSimple : public wxDataObjectSimple {
3800 public:
3801 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3802 : wxDataObjectSimple(format) {}
3803
3804 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3805 bool GetDataHere(void *buf) const;
3806 bool SetData(size_t len, const void *buf);
3807 PYPRIVATE;
3808 };
3809
3810 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3811
3812 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3813 // We need to get the data for this object and write it to buf. I think
3814 // the best way to do this for wxPython is to have the Python method
3815 // return either a string or None and then act appropriately with the
3816 // C++ version.
3817
3818 bool rval = false;
3819 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3820 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3821 PyObject* ro;
3822 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3823 if (ro) {
3824 rval = (ro != Py_None && PyString_Check(ro));
3825 if (rval)
3826 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3827 Py_DECREF(ro);
3828 }
3829 }
3830 wxPyEndBlockThreads(blocked);
3831 return rval;
3832 }
3833
3834 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3835 // For this one we simply need to make a string from buf and len
3836 // and send it to the Python method.
3837 bool rval = false;
3838 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3839 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3840 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3841 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3842 Py_DECREF(data);
3843 }
3844 wxPyEndBlockThreads(blocked);
3845 return rval;
3846 }
3847
3848 // Create a new class for wxPython to use
3849 class wxPyTextDataObject : public wxTextDataObject {
3850 public:
3851 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3852 : wxTextDataObject(text) {}
3853
3854 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3855 DEC_PYCALLBACK_STRING__const(GetText);
3856 DEC_PYCALLBACK__STRING(SetText);
3857 PYPRIVATE;
3858 };
3859
3860 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3861 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3862 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3863
3864
3865 // Create a new class for wxPython to use
3866 class wxPyBitmapDataObject : public wxBitmapDataObject {
3867 public:
3868 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3869 : wxBitmapDataObject(bitmap) {}
3870
3871 wxBitmap GetBitmap() const;
3872 void SetBitmap(const wxBitmap& bitmap);
3873 PYPRIVATE;
3874 };
3875
3876 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3877 wxBitmap* rval = &wxNullBitmap;
3878 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3879 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3880 PyObject* ro;
3881 wxBitmap* ptr;
3882 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3883 if (ro) {
3884 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3885 rval = ptr;
3886 Py_DECREF(ro);
3887 }
3888 }
3889 wxPyEndBlockThreads(blocked);
3890 return *rval;
3891 }
3892
3893 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3894 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3895 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3896 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3897 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3898 Py_DECREF(bo);
3899 }
3900 wxPyEndBlockThreads(blocked);
3901 }
3902
3903 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3904 return new wxCustomDataObject(wxDataFormat(formatName));
3905 }
3906 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3907 bool rval;
3908 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3909 if (PyString_Check(data)) {
3910 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3911 }
3912 else {
3913 // raise a TypeError if not a string
3914 PyErr_SetString(PyExc_TypeError, "String expected.");
3915 rval = false;
3916 }
3917 wxPyEndBlockThreads(blocked);
3918 return rval;
3919 }
3920 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3921 PyObject* obj;
3922 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3923 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3924 wxPyEndBlockThreads(blocked);
3925 return obj;
3926 }
3927
3928 #include <wx/metafile.h>
3929
3930
3931 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3932
3933
3934 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3935 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3936 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3937 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3938 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3939
3940
3941 class wxPyTextDropTarget : public wxTextDropTarget {
3942 public:
3943 wxPyTextDropTarget() {}
3944
3945 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3946
3947 DEC_PYCALLBACK__(OnLeave);
3948 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3949 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3950 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3951 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3952
3953 PYPRIVATE;
3954 };
3955
3956 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3957 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3958 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3959 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3960 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3961 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3962
3963
3964
3965 class wxPyFileDropTarget : public wxFileDropTarget {
3966 public:
3967 wxPyFileDropTarget() {}
3968
3969 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3970
3971 DEC_PYCALLBACK__(OnLeave);
3972 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3973 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3974 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3975 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3976
3977 PYPRIVATE;
3978 };
3979
3980 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3981 const wxArrayString& filenames) {
3982 bool rval = false;
3983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3984 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3985 PyObject* list = wxArrayString2PyList_helper(filenames);
3986 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3987 Py_DECREF(list);
3988 }
3989 wxPyEndBlockThreads(blocked);
3990 return rval;
3991 }
3992
3993
3994
3995 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3996 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3997 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3998 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
3999 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4000
4001
4002
4003
4004 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4005
4006 #include <wx/display.h>
4007
4008 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4009 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4010
4011 #if !wxUSE_DISPLAY
4012 const wxVideoMode wxDefaultVideoMode;
4013 #endif
4014
4015 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4016 #if wxUSE_DISPLAY
4017 PyObject* pyList = NULL;
4018 wxArrayVideoModes arr = self->GetModes(mode);
4019 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4020 pyList = PyList_New(0);
4021 for (size_t i=0; i < arr.GetCount(); i++)
4022 {
4023 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4024 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4025 PyList_Append(pyList, pyObj);
4026 Py_DECREF(pyObj);
4027 }
4028 wxPyEndBlockThreads(blocked);
4029 return pyList;
4030 #else
4031 wxPyRaiseNotImplemented();
4032 return NULL;
4033 #endif
4034 }
4035 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4036 #if wxUSE_DISPLAY
4037 return self->GetCurrentMode();
4038 #else
4039 wxPyRaiseNotImplemented();
4040 return wxDefaultVideoMode;
4041 #endif
4042 }
4043 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4044 #if wxUSE_DISPLAY
4045 return self->ChangeMode(mode);
4046 #else
4047 wxPyRaiseNotImplemented();
4048 return false;
4049 #endif
4050 }
4051 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4052 #if wxUSE_DISPLAY
4053 self->ResetMode();
4054 #else
4055 wxPyRaiseNotImplemented();
4056 #endif
4057 }
4058
4059 #include <wx/stdpaths.h>
4060
4061 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4062 return (wxStandardPaths*) &wxStandardPaths::Get();
4063 }
4064 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4065 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4066
4067 #ifndef wxHAS_POWER_EVENTS
4068 // Dummy class and other definitions for platforms that don't have them
4069
4070 // See wxPython_int.h for wxPowerEvent
4071
4072 enum {
4073 wxEVT_POWER_SUSPENDING,
4074 wxEVT_POWER_SUSPENDED,
4075 wxEVT_POWER_SUSPEND_CANCEL,
4076 wxEVT_POWER_RESUME,
4077 };
4078
4079 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4080 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4081
4082 #endif
4083
4084 #ifdef __cplusplus
4085 extern "C" {
4086 #endif
4087 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4088 PyObject *resultobj = 0;
4089 wxSystemColour arg1 ;
4090 wxColour result;
4091 int val1 ;
4092 int ecode1 = 0 ;
4093 PyObject * obj0 = 0 ;
4094 char * kwnames[] = {
4095 (char *) "index", NULL
4096 };
4097
4098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4099 ecode1 = SWIG_AsVal_int(obj0, &val1);
4100 if (!SWIG_IsOK(ecode1)) {
4101 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4102 }
4103 arg1 = static_cast< wxSystemColour >(val1);
4104 {
4105 if (!wxPyCheckForApp()) SWIG_fail;
4106 PyThreadState* __tstate = wxPyBeginAllowThreads();
4107 result = wxSystemSettings::GetColour(arg1);
4108 wxPyEndAllowThreads(__tstate);
4109 if (PyErr_Occurred()) SWIG_fail;
4110 }
4111 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4112 return resultobj;
4113 fail:
4114 return NULL;
4115 }
4116
4117
4118 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4119 PyObject *resultobj = 0;
4120 wxSystemFont arg1 ;
4121 wxFont result;
4122 int val1 ;
4123 int ecode1 = 0 ;
4124 PyObject * obj0 = 0 ;
4125 char * kwnames[] = {
4126 (char *) "index", NULL
4127 };
4128
4129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4130 ecode1 = SWIG_AsVal_int(obj0, &val1);
4131 if (!SWIG_IsOK(ecode1)) {
4132 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4133 }
4134 arg1 = static_cast< wxSystemFont >(val1);
4135 {
4136 if (!wxPyCheckForApp()) SWIG_fail;
4137 PyThreadState* __tstate = wxPyBeginAllowThreads();
4138 result = wxSystemSettings::GetFont(arg1);
4139 wxPyEndAllowThreads(__tstate);
4140 if (PyErr_Occurred()) SWIG_fail;
4141 }
4142 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4143 return resultobj;
4144 fail:
4145 return NULL;
4146 }
4147
4148
4149 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4150 PyObject *resultobj = 0;
4151 wxSystemMetric arg1 ;
4152 wxWindow *arg2 = (wxWindow *) NULL ;
4153 int result;
4154 int val1 ;
4155 int ecode1 = 0 ;
4156 void *argp2 = 0 ;
4157 int res2 = 0 ;
4158 PyObject * obj0 = 0 ;
4159 PyObject * obj1 = 0 ;
4160 char * kwnames[] = {
4161 (char *) "index",(char *) "win", NULL
4162 };
4163
4164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4165 ecode1 = SWIG_AsVal_int(obj0, &val1);
4166 if (!SWIG_IsOK(ecode1)) {
4167 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4168 }
4169 arg1 = static_cast< wxSystemMetric >(val1);
4170 if (obj1) {
4171 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4172 if (!SWIG_IsOK(res2)) {
4173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4174 }
4175 arg2 = reinterpret_cast< wxWindow * >(argp2);
4176 }
4177 {
4178 if (!wxPyCheckForApp()) SWIG_fail;
4179 PyThreadState* __tstate = wxPyBeginAllowThreads();
4180 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4181 wxPyEndAllowThreads(__tstate);
4182 if (PyErr_Occurred()) SWIG_fail;
4183 }
4184 resultobj = SWIG_From_int(static_cast< int >(result));
4185 return resultobj;
4186 fail:
4187 return NULL;
4188 }
4189
4190
4191 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4192 PyObject *resultobj = 0;
4193 wxSystemFeature arg1 ;
4194 bool result;
4195 int val1 ;
4196 int ecode1 = 0 ;
4197 PyObject * obj0 = 0 ;
4198 char * kwnames[] = {
4199 (char *) "index", NULL
4200 };
4201
4202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4203 ecode1 = SWIG_AsVal_int(obj0, &val1);
4204 if (!SWIG_IsOK(ecode1)) {
4205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4206 }
4207 arg1 = static_cast< wxSystemFeature >(val1);
4208 {
4209 if (!wxPyCheckForApp()) SWIG_fail;
4210 PyThreadState* __tstate = wxPyBeginAllowThreads();
4211 result = (bool)wxSystemSettings::HasFeature(arg1);
4212 wxPyEndAllowThreads(__tstate);
4213 if (PyErr_Occurred()) SWIG_fail;
4214 }
4215 {
4216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4217 }
4218 return resultobj;
4219 fail:
4220 return NULL;
4221 }
4222
4223
4224 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4225 PyObject *resultobj = 0;
4226 wxSystemScreenType result;
4227
4228 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4229 {
4230 if (!wxPyCheckForApp()) SWIG_fail;
4231 PyThreadState* __tstate = wxPyBeginAllowThreads();
4232 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4233 wxPyEndAllowThreads(__tstate);
4234 if (PyErr_Occurred()) SWIG_fail;
4235 }
4236 resultobj = SWIG_From_int(static_cast< int >(result));
4237 return resultobj;
4238 fail:
4239 return NULL;
4240 }
4241
4242
4243 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4244 PyObject *resultobj = 0;
4245 wxSystemScreenType arg1 ;
4246 int val1 ;
4247 int ecode1 = 0 ;
4248 PyObject * obj0 = 0 ;
4249 char * kwnames[] = {
4250 (char *) "screen", NULL
4251 };
4252
4253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4254 ecode1 = SWIG_AsVal_int(obj0, &val1);
4255 if (!SWIG_IsOK(ecode1)) {
4256 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4257 }
4258 arg1 = static_cast< wxSystemScreenType >(val1);
4259 {
4260 if (!wxPyCheckForApp()) SWIG_fail;
4261 PyThreadState* __tstate = wxPyBeginAllowThreads();
4262 wxSystemSettings::SetScreenType(arg1);
4263 wxPyEndAllowThreads(__tstate);
4264 if (PyErr_Occurred()) SWIG_fail;
4265 }
4266 resultobj = SWIG_Py_Void();
4267 return resultobj;
4268 fail:
4269 return NULL;
4270 }
4271
4272
4273 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4274 PyObject *obj;
4275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4276 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4277 return SWIG_Py_Void();
4278 }
4279
4280 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4281 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4282 return 1;
4283 }
4284
4285
4286 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4287 PyObject *pyobj = 0;
4288
4289 {
4290 #if wxUSE_UNICODE
4291 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4292 #else
4293 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4294 #endif
4295 }
4296 return pyobj;
4297 }
4298
4299
4300 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4301 PyObject *resultobj = 0;
4302 wxSystemOptions *result = 0 ;
4303
4304 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4305 {
4306 PyThreadState* __tstate = wxPyBeginAllowThreads();
4307 result = (wxSystemOptions *)new wxSystemOptions();
4308 wxPyEndAllowThreads(__tstate);
4309 if (PyErr_Occurred()) SWIG_fail;
4310 }
4311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4312 return resultobj;
4313 fail:
4314 return NULL;
4315 }
4316
4317
4318 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4319 PyObject *resultobj = 0;
4320 wxString *arg1 = 0 ;
4321 wxString *arg2 = 0 ;
4322 bool temp1 = false ;
4323 bool temp2 = false ;
4324 PyObject * obj0 = 0 ;
4325 PyObject * obj1 = 0 ;
4326 char * kwnames[] = {
4327 (char *) "name",(char *) "value", NULL
4328 };
4329
4330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4331 {
4332 arg1 = wxString_in_helper(obj0);
4333 if (arg1 == NULL) SWIG_fail;
4334 temp1 = true;
4335 }
4336 {
4337 arg2 = wxString_in_helper(obj1);
4338 if (arg2 == NULL) SWIG_fail;
4339 temp2 = true;
4340 }
4341 {
4342 PyThreadState* __tstate = wxPyBeginAllowThreads();
4343 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4344 wxPyEndAllowThreads(__tstate);
4345 if (PyErr_Occurred()) SWIG_fail;
4346 }
4347 resultobj = SWIG_Py_Void();
4348 {
4349 if (temp1)
4350 delete arg1;
4351 }
4352 {
4353 if (temp2)
4354 delete arg2;
4355 }
4356 return resultobj;
4357 fail:
4358 {
4359 if (temp1)
4360 delete arg1;
4361 }
4362 {
4363 if (temp2)
4364 delete arg2;
4365 }
4366 return NULL;
4367 }
4368
4369
4370 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4371 PyObject *resultobj = 0;
4372 wxString *arg1 = 0 ;
4373 int arg2 ;
4374 bool temp1 = false ;
4375 int val2 ;
4376 int ecode2 = 0 ;
4377 PyObject * obj0 = 0 ;
4378 PyObject * obj1 = 0 ;
4379 char * kwnames[] = {
4380 (char *) "name",(char *) "value", NULL
4381 };
4382
4383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4384 {
4385 arg1 = wxString_in_helper(obj0);
4386 if (arg1 == NULL) SWIG_fail;
4387 temp1 = true;
4388 }
4389 ecode2 = SWIG_AsVal_int(obj1, &val2);
4390 if (!SWIG_IsOK(ecode2)) {
4391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4392 }
4393 arg2 = static_cast< int >(val2);
4394 {
4395 PyThreadState* __tstate = wxPyBeginAllowThreads();
4396 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4397 wxPyEndAllowThreads(__tstate);
4398 if (PyErr_Occurred()) SWIG_fail;
4399 }
4400 resultobj = SWIG_Py_Void();
4401 {
4402 if (temp1)
4403 delete arg1;
4404 }
4405 return resultobj;
4406 fail:
4407 {
4408 if (temp1)
4409 delete arg1;
4410 }
4411 return NULL;
4412 }
4413
4414
4415 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4416 PyObject *resultobj = 0;
4417 wxString *arg1 = 0 ;
4418 wxString result;
4419 bool temp1 = false ;
4420 PyObject * obj0 = 0 ;
4421 char * kwnames[] = {
4422 (char *) "name", NULL
4423 };
4424
4425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4426 {
4427 arg1 = wxString_in_helper(obj0);
4428 if (arg1 == NULL) SWIG_fail;
4429 temp1 = true;
4430 }
4431 {
4432 PyThreadState* __tstate = wxPyBeginAllowThreads();
4433 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4434 wxPyEndAllowThreads(__tstate);
4435 if (PyErr_Occurred()) SWIG_fail;
4436 }
4437 {
4438 #if wxUSE_UNICODE
4439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4440 #else
4441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4442 #endif
4443 }
4444 {
4445 if (temp1)
4446 delete arg1;
4447 }
4448 return resultobj;
4449 fail:
4450 {
4451 if (temp1)
4452 delete arg1;
4453 }
4454 return NULL;
4455 }
4456
4457
4458 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4459 PyObject *resultobj = 0;
4460 wxString *arg1 = 0 ;
4461 int result;
4462 bool temp1 = false ;
4463 PyObject * obj0 = 0 ;
4464 char * kwnames[] = {
4465 (char *) "name", NULL
4466 };
4467
4468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4469 {
4470 arg1 = wxString_in_helper(obj0);
4471 if (arg1 == NULL) SWIG_fail;
4472 temp1 = true;
4473 }
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4477 wxPyEndAllowThreads(__tstate);
4478 if (PyErr_Occurred()) SWIG_fail;
4479 }
4480 resultobj = SWIG_From_int(static_cast< int >(result));
4481 {
4482 if (temp1)
4483 delete arg1;
4484 }
4485 return resultobj;
4486 fail:
4487 {
4488 if (temp1)
4489 delete arg1;
4490 }
4491 return NULL;
4492 }
4493
4494
4495 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4496 PyObject *resultobj = 0;
4497 wxString *arg1 = 0 ;
4498 bool result;
4499 bool temp1 = false ;
4500 PyObject * obj0 = 0 ;
4501 char * kwnames[] = {
4502 (char *) "name", NULL
4503 };
4504
4505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4506 {
4507 arg1 = wxString_in_helper(obj0);
4508 if (arg1 == NULL) SWIG_fail;
4509 temp1 = true;
4510 }
4511 {
4512 PyThreadState* __tstate = wxPyBeginAllowThreads();
4513 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4514 wxPyEndAllowThreads(__tstate);
4515 if (PyErr_Occurred()) SWIG_fail;
4516 }
4517 {
4518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4519 }
4520 {
4521 if (temp1)
4522 delete arg1;
4523 }
4524 return resultobj;
4525 fail:
4526 {
4527 if (temp1)
4528 delete arg1;
4529 }
4530 return NULL;
4531 }
4532
4533
4534 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4535 PyObject *resultobj = 0;
4536 wxString *arg1 = 0 ;
4537 bool result;
4538 bool temp1 = false ;
4539 PyObject * obj0 = 0 ;
4540 char * kwnames[] = {
4541 (char *) "name", NULL
4542 };
4543
4544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4545 {
4546 arg1 = wxString_in_helper(obj0);
4547 if (arg1 == NULL) SWIG_fail;
4548 temp1 = true;
4549 }
4550 {
4551 PyThreadState* __tstate = wxPyBeginAllowThreads();
4552 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4553 wxPyEndAllowThreads(__tstate);
4554 if (PyErr_Occurred()) SWIG_fail;
4555 }
4556 {
4557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4558 }
4559 {
4560 if (temp1)
4561 delete arg1;
4562 }
4563 return resultobj;
4564 fail:
4565 {
4566 if (temp1)
4567 delete arg1;
4568 }
4569 return NULL;
4570 }
4571
4572
4573 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4574 PyObject *obj;
4575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4576 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4577 return SWIG_Py_Void();
4578 }
4579
4580 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4581 return SWIG_Python_InitShadowInstance(args);
4582 }
4583
4584 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4585 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4586 return 1;
4587 }
4588
4589
4590 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4591 PyObject *pyobj = 0;
4592
4593 {
4594 #if wxUSE_UNICODE
4595 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4596 #else
4597 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4598 #endif
4599 }
4600 return pyobj;
4601 }
4602
4603
4604 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4605 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4606 return 1;
4607 }
4608
4609
4610 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4611 PyObject *pyobj = 0;
4612
4613 {
4614 #if wxUSE_UNICODE
4615 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4616 #else
4617 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4618 #endif
4619 }
4620 return pyobj;
4621 }
4622
4623
4624 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4625 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4626 return 1;
4627 }
4628
4629
4630 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4631 PyObject *pyobj = 0;
4632
4633 {
4634 #if wxUSE_UNICODE
4635 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4636 #else
4637 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4638 #endif
4639 }
4640 return pyobj;
4641 }
4642
4643
4644 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4645 PyObject *resultobj = 0;
4646 long result;
4647
4648 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4649 {
4650 PyThreadState* __tstate = wxPyBeginAllowThreads();
4651 result = (long)wxNewId();
4652 wxPyEndAllowThreads(__tstate);
4653 if (PyErr_Occurred()) SWIG_fail;
4654 }
4655 resultobj = SWIG_From_long(static_cast< long >(result));
4656 return resultobj;
4657 fail:
4658 return NULL;
4659 }
4660
4661
4662 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4663 PyObject *resultobj = 0;
4664 long arg1 ;
4665 long val1 ;
4666 int ecode1 = 0 ;
4667 PyObject * obj0 = 0 ;
4668 char * kwnames[] = {
4669 (char *) "id", NULL
4670 };
4671
4672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4673 ecode1 = SWIG_AsVal_long(obj0, &val1);
4674 if (!SWIG_IsOK(ecode1)) {
4675 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4676 }
4677 arg1 = static_cast< long >(val1);
4678 {
4679 PyThreadState* __tstate = wxPyBeginAllowThreads();
4680 wxRegisterId(arg1);
4681 wxPyEndAllowThreads(__tstate);
4682 if (PyErr_Occurred()) SWIG_fail;
4683 }
4684 resultobj = SWIG_Py_Void();
4685 return resultobj;
4686 fail:
4687 return NULL;
4688 }
4689
4690
4691 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4692 PyObject *resultobj = 0;
4693 long result;
4694
4695 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4696 {
4697 PyThreadState* __tstate = wxPyBeginAllowThreads();
4698 result = (long)wxGetCurrentId();
4699 wxPyEndAllowThreads(__tstate);
4700 if (PyErr_Occurred()) SWIG_fail;
4701 }
4702 resultobj = SWIG_From_long(static_cast< long >(result));
4703 return resultobj;
4704 fail:
4705 return NULL;
4706 }
4707
4708
4709 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4710 PyObject *resultobj = 0;
4711 int arg1 ;
4712 bool result;
4713 int val1 ;
4714 int ecode1 = 0 ;
4715 PyObject * obj0 = 0 ;
4716 char * kwnames[] = {
4717 (char *) "id", NULL
4718 };
4719
4720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4721 ecode1 = SWIG_AsVal_int(obj0, &val1);
4722 if (!SWIG_IsOK(ecode1)) {
4723 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4724 }
4725 arg1 = static_cast< int >(val1);
4726 {
4727 PyThreadState* __tstate = wxPyBeginAllowThreads();
4728 result = (bool)wxIsStockID(arg1);
4729 wxPyEndAllowThreads(__tstate);
4730 if (PyErr_Occurred()) SWIG_fail;
4731 }
4732 {
4733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4734 }
4735 return resultobj;
4736 fail:
4737 return NULL;
4738 }
4739
4740
4741 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4742 PyObject *resultobj = 0;
4743 int arg1 ;
4744 wxString *arg2 = 0 ;
4745 bool result;
4746 int val1 ;
4747 int ecode1 = 0 ;
4748 bool temp2 = false ;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 char * kwnames[] = {
4752 (char *) "id",(char *) "label", NULL
4753 };
4754
4755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4756 ecode1 = SWIG_AsVal_int(obj0, &val1);
4757 if (!SWIG_IsOK(ecode1)) {
4758 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4759 }
4760 arg1 = static_cast< int >(val1);
4761 {
4762 arg2 = wxString_in_helper(obj1);
4763 if (arg2 == NULL) SWIG_fail;
4764 temp2 = true;
4765 }
4766 {
4767 PyThreadState* __tstate = wxPyBeginAllowThreads();
4768 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4769 wxPyEndAllowThreads(__tstate);
4770 if (PyErr_Occurred()) SWIG_fail;
4771 }
4772 {
4773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4774 }
4775 {
4776 if (temp2)
4777 delete arg2;
4778 }
4779 return resultobj;
4780 fail:
4781 {
4782 if (temp2)
4783 delete arg2;
4784 }
4785 return NULL;
4786 }
4787
4788
4789 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4790 PyObject *resultobj = 0;
4791 int arg1 ;
4792 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4793 wxString result;
4794 int val1 ;
4795 int ecode1 = 0 ;
4796 long val2 ;
4797 int ecode2 = 0 ;
4798 PyObject * obj0 = 0 ;
4799 PyObject * obj1 = 0 ;
4800 char * kwnames[] = {
4801 (char *) "id",(char *) "flags", NULL
4802 };
4803
4804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4805 ecode1 = SWIG_AsVal_int(obj0, &val1);
4806 if (!SWIG_IsOK(ecode1)) {
4807 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4808 }
4809 arg1 = static_cast< int >(val1);
4810 if (obj1) {
4811 ecode2 = SWIG_AsVal_long(obj1, &val2);
4812 if (!SWIG_IsOK(ecode2)) {
4813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4814 }
4815 arg2 = static_cast< long >(val2);
4816 }
4817 {
4818 PyThreadState* __tstate = wxPyBeginAllowThreads();
4819 result = wxGetStockLabel(arg1,arg2);
4820 wxPyEndAllowThreads(__tstate);
4821 if (PyErr_Occurred()) SWIG_fail;
4822 }
4823 {
4824 #if wxUSE_UNICODE
4825 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4826 #else
4827 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4828 #endif
4829 }
4830 return resultobj;
4831 fail:
4832 return NULL;
4833 }
4834
4835
4836 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4837 PyObject *resultobj = 0;
4838 int arg1 ;
4839 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4840 wxString result;
4841 int val1 ;
4842 int ecode1 = 0 ;
4843 int val2 ;
4844 int ecode2 = 0 ;
4845 PyObject * obj0 = 0 ;
4846 PyObject * obj1 = 0 ;
4847 char * kwnames[] = {
4848 (char *) "id",(char *) "client", NULL
4849 };
4850
4851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4852 ecode1 = SWIG_AsVal_int(obj0, &val1);
4853 if (!SWIG_IsOK(ecode1)) {
4854 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4855 }
4856 arg1 = static_cast< int >(val1);
4857 if (obj1) {
4858 ecode2 = SWIG_AsVal_int(obj1, &val2);
4859 if (!SWIG_IsOK(ecode2)) {
4860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4861 }
4862 arg2 = static_cast< wxStockHelpStringClient >(val2);
4863 }
4864 {
4865 PyThreadState* __tstate = wxPyBeginAllowThreads();
4866 result = wxGetStockHelpString(arg1,arg2);
4867 wxPyEndAllowThreads(__tstate);
4868 if (PyErr_Occurred()) SWIG_fail;
4869 }
4870 {
4871 #if wxUSE_UNICODE
4872 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4873 #else
4874 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4875 #endif
4876 }
4877 return resultobj;
4878 fail:
4879 return NULL;
4880 }
4881
4882
4883 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4884 PyObject *resultobj = 0;
4885
4886 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4887 {
4888 if (!wxPyCheckForApp()) SWIG_fail;
4889 PyThreadState* __tstate = wxPyBeginAllowThreads();
4890 wxBell();
4891 wxPyEndAllowThreads(__tstate);
4892 if (PyErr_Occurred()) SWIG_fail;
4893 }
4894 resultobj = SWIG_Py_Void();
4895 return resultobj;
4896 fail:
4897 return NULL;
4898 }
4899
4900
4901 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4902 PyObject *resultobj = 0;
4903
4904 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4905 {
4906 if (!wxPyCheckForApp()) SWIG_fail;
4907 PyThreadState* __tstate = wxPyBeginAllowThreads();
4908 wxEndBusyCursor();
4909 wxPyEndAllowThreads(__tstate);
4910 if (PyErr_Occurred()) SWIG_fail;
4911 }
4912 resultobj = SWIG_Py_Void();
4913 return resultobj;
4914 fail:
4915 return NULL;
4916 }
4917
4918
4919 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4920 PyObject *resultobj = 0;
4921 bool arg1 = (bool) true ;
4922 long result;
4923 bool val1 ;
4924 int ecode1 = 0 ;
4925 PyObject * obj0 = 0 ;
4926 char * kwnames[] = {
4927 (char *) "resetTimer", NULL
4928 };
4929
4930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4931 if (obj0) {
4932 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4933 if (!SWIG_IsOK(ecode1)) {
4934 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4935 }
4936 arg1 = static_cast< bool >(val1);
4937 }
4938 {
4939 PyThreadState* __tstate = wxPyBeginAllowThreads();
4940 result = (long)wxGetElapsedTime(arg1);
4941 wxPyEndAllowThreads(__tstate);
4942 if (PyErr_Occurred()) SWIG_fail;
4943 }
4944 resultobj = SWIG_From_long(static_cast< long >(result));
4945 return resultobj;
4946 fail:
4947 return NULL;
4948 }
4949
4950
4951 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4952 PyObject *resultobj = 0;
4953 bool result;
4954
4955 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4956 {
4957 PyThreadState* __tstate = wxPyBeginAllowThreads();
4958 result = (bool)wxIsBusy();
4959 wxPyEndAllowThreads(__tstate);
4960 if (PyErr_Occurred()) SWIG_fail;
4961 }
4962 {
4963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4964 }
4965 return resultobj;
4966 fail:
4967 return NULL;
4968 }
4969
4970
4971 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4972 PyObject *resultobj = 0;
4973 wxString result;
4974
4975 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4976 {
4977 PyThreadState* __tstate = wxPyBeginAllowThreads();
4978 result = wxNow();
4979 wxPyEndAllowThreads(__tstate);
4980 if (PyErr_Occurred()) SWIG_fail;
4981 }
4982 {
4983 #if wxUSE_UNICODE
4984 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4985 #else
4986 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4987 #endif
4988 }
4989 return resultobj;
4990 fail:
4991 return NULL;
4992 }
4993
4994
4995 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4996 PyObject *resultobj = 0;
4997 wxString const &arg1_defvalue = wxPyEmptyString ;
4998 wxString *arg1 = (wxString *) &arg1_defvalue ;
4999 bool result;
5000 bool temp1 = false ;
5001 PyObject * obj0 = 0 ;
5002 char * kwnames[] = {
5003 (char *) "command", NULL
5004 };
5005
5006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5007 if (obj0) {
5008 {
5009 arg1 = wxString_in_helper(obj0);
5010 if (arg1 == NULL) SWIG_fail;
5011 temp1 = true;
5012 }
5013 }
5014 {
5015 PyThreadState* __tstate = wxPyBeginAllowThreads();
5016 result = (bool)wxShell((wxString const &)*arg1);
5017 wxPyEndAllowThreads(__tstate);
5018 if (PyErr_Occurred()) SWIG_fail;
5019 }
5020 {
5021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5022 }
5023 {
5024 if (temp1)
5025 delete arg1;
5026 }
5027 return resultobj;
5028 fail:
5029 {
5030 if (temp1)
5031 delete arg1;
5032 }
5033 return NULL;
5034 }
5035
5036
5037 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5038 PyObject *resultobj = 0;
5039
5040 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5041 {
5042 PyThreadState* __tstate = wxPyBeginAllowThreads();
5043 wxStartTimer();
5044 wxPyEndAllowThreads(__tstate);
5045 if (PyErr_Occurred()) SWIG_fail;
5046 }
5047 resultobj = SWIG_Py_Void();
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5055 PyObject *resultobj = 0;
5056 int *arg1 = (int *) 0 ;
5057 int *arg2 = (int *) 0 ;
5058 int result;
5059 int temp1 ;
5060 int res1 = SWIG_TMPOBJ ;
5061 int temp2 ;
5062 int res2 = SWIG_TMPOBJ ;
5063
5064 arg1 = &temp1;
5065 arg2 = &temp2;
5066 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5067 {
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 result = (int)wxGetOsVersion(arg1,arg2);
5070 wxPyEndAllowThreads(__tstate);
5071 if (PyErr_Occurred()) SWIG_fail;
5072 }
5073 resultobj = SWIG_From_int(static_cast< int >(result));
5074 if (SWIG_IsTmpObj(res1)) {
5075 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5076 } else {
5077 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5078 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5079 }
5080 if (SWIG_IsTmpObj(res2)) {
5081 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5082 } else {
5083 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5084 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5085 }
5086 return resultobj;
5087 fail:
5088 return NULL;
5089 }
5090
5091
5092 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5093 PyObject *resultobj = 0;
5094 wxString result;
5095
5096 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5097 {
5098 PyThreadState* __tstate = wxPyBeginAllowThreads();
5099 result = wxGetOsDescription();
5100 wxPyEndAllowThreads(__tstate);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 {
5104 #if wxUSE_UNICODE
5105 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5106 #else
5107 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5108 #endif
5109 }
5110 return resultobj;
5111 fail:
5112 return NULL;
5113 }
5114
5115
5116 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5117 PyObject *resultobj = 0;
5118 bool result;
5119
5120 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5121 {
5122 PyThreadState* __tstate = wxPyBeginAllowThreads();
5123 result = (bool)wxIsPlatformLittleEndian();
5124 wxPyEndAllowThreads(__tstate);
5125 if (PyErr_Occurred()) SWIG_fail;
5126 }
5127 {
5128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5129 }
5130 return resultobj;
5131 fail:
5132 return NULL;
5133 }
5134
5135
5136 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5137 PyObject *resultobj = 0;
5138 bool result;
5139
5140 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5141 {
5142 PyThreadState* __tstate = wxPyBeginAllowThreads();
5143 result = (bool)wxIsPlatform64Bit();
5144 wxPyEndAllowThreads(__tstate);
5145 if (PyErr_Occurred()) SWIG_fail;
5146 }
5147 {
5148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5149 }
5150 return resultobj;
5151 fail:
5152 return NULL;
5153 }
5154
5155
5156 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5157 PyObject *resultobj = 0;
5158 wxMemorySize result;
5159
5160 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5161 {
5162 PyThreadState* __tstate = wxPyBeginAllowThreads();
5163 result = wxGetFreeMemory();
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 {
5168 #if wxUSE_LONGLONG
5169 resultobj = PyLong_FromLongLong((&result)->GetValue());
5170 #else
5171 resultobj = PyInt_FromLong(result);
5172 #endif
5173 }
5174 return resultobj;
5175 fail:
5176 return NULL;
5177 }
5178
5179
5180 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5181 PyObject *resultobj = 0;
5182 wxShutdownFlags arg1 ;
5183 bool result;
5184 int val1 ;
5185 int ecode1 = 0 ;
5186 PyObject * obj0 = 0 ;
5187 char * kwnames[] = {
5188 (char *) "wFlags", NULL
5189 };
5190
5191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5192 ecode1 = SWIG_AsVal_int(obj0, &val1);
5193 if (!SWIG_IsOK(ecode1)) {
5194 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5195 }
5196 arg1 = static_cast< wxShutdownFlags >(val1);
5197 {
5198 if (!wxPyCheckForApp()) SWIG_fail;
5199 PyThreadState* __tstate = wxPyBeginAllowThreads();
5200 result = (bool)wxShutdown(arg1);
5201 wxPyEndAllowThreads(__tstate);
5202 if (PyErr_Occurred()) SWIG_fail;
5203 }
5204 {
5205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5206 }
5207 return resultobj;
5208 fail:
5209 return NULL;
5210 }
5211
5212
5213 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5214 PyObject *resultobj = 0;
5215 int arg1 ;
5216 int val1 ;
5217 int ecode1 = 0 ;
5218 PyObject * obj0 = 0 ;
5219 char * kwnames[] = {
5220 (char *) "secs", NULL
5221 };
5222
5223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5224 ecode1 = SWIG_AsVal_int(obj0, &val1);
5225 if (!SWIG_IsOK(ecode1)) {
5226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5227 }
5228 arg1 = static_cast< int >(val1);
5229 {
5230 PyThreadState* __tstate = wxPyBeginAllowThreads();
5231 wxSleep(arg1);
5232 wxPyEndAllowThreads(__tstate);
5233 if (PyErr_Occurred()) SWIG_fail;
5234 }
5235 resultobj = SWIG_Py_Void();
5236 return resultobj;
5237 fail:
5238 return NULL;
5239 }
5240
5241
5242 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5243 PyObject *resultobj = 0;
5244 unsigned long arg1 ;
5245 unsigned long val1 ;
5246 int ecode1 = 0 ;
5247 PyObject * obj0 = 0 ;
5248 char * kwnames[] = {
5249 (char *) "milliseconds", NULL
5250 };
5251
5252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5253 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5254 if (!SWIG_IsOK(ecode1)) {
5255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5256 }
5257 arg1 = static_cast< unsigned long >(val1);
5258 {
5259 PyThreadState* __tstate = wxPyBeginAllowThreads();
5260 wxMilliSleep(arg1);
5261 wxPyEndAllowThreads(__tstate);
5262 if (PyErr_Occurred()) SWIG_fail;
5263 }
5264 resultobj = SWIG_Py_Void();
5265 return resultobj;
5266 fail:
5267 return NULL;
5268 }
5269
5270
5271 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5272 PyObject *resultobj = 0;
5273 unsigned long arg1 ;
5274 unsigned long val1 ;
5275 int ecode1 = 0 ;
5276 PyObject * obj0 = 0 ;
5277 char * kwnames[] = {
5278 (char *) "microseconds", NULL
5279 };
5280
5281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5282 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5283 if (!SWIG_IsOK(ecode1)) {
5284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5285 }
5286 arg1 = static_cast< unsigned long >(val1);
5287 {
5288 PyThreadState* __tstate = wxPyBeginAllowThreads();
5289 wxMicroSleep(arg1);
5290 wxPyEndAllowThreads(__tstate);
5291 if (PyErr_Occurred()) SWIG_fail;
5292 }
5293 resultobj = SWIG_Py_Void();
5294 return resultobj;
5295 fail:
5296 return NULL;
5297 }
5298
5299
5300 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5301 PyObject *resultobj = 0;
5302 bool arg1 ;
5303 bool val1 ;
5304 int ecode1 = 0 ;
5305 PyObject * obj0 = 0 ;
5306 char * kwnames[] = {
5307 (char *) "enable", NULL
5308 };
5309
5310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5311 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5312 if (!SWIG_IsOK(ecode1)) {
5313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5314 }
5315 arg1 = static_cast< bool >(val1);
5316 {
5317 PyThreadState* __tstate = wxPyBeginAllowThreads();
5318 wxEnableTopLevelWindows(arg1);
5319 wxPyEndAllowThreads(__tstate);
5320 if (PyErr_Occurred()) SWIG_fail;
5321 }
5322 resultobj = SWIG_Py_Void();
5323 return resultobj;
5324 fail:
5325 return NULL;
5326 }
5327
5328
5329 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5330 PyObject *resultobj = 0;
5331 wxString *arg1 = 0 ;
5332 wxString result;
5333 bool temp1 = false ;
5334 PyObject * obj0 = 0 ;
5335 char * kwnames[] = {
5336 (char *) "in", NULL
5337 };
5338
5339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5340 {
5341 arg1 = wxString_in_helper(obj0);
5342 if (arg1 == NULL) SWIG_fail;
5343 temp1 = true;
5344 }
5345 {
5346 PyThreadState* __tstate = wxPyBeginAllowThreads();
5347 result = wxStripMenuCodes((wxString const &)*arg1);
5348 wxPyEndAllowThreads(__tstate);
5349 if (PyErr_Occurred()) SWIG_fail;
5350 }
5351 {
5352 #if wxUSE_UNICODE
5353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5354 #else
5355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5356 #endif
5357 }
5358 {
5359 if (temp1)
5360 delete arg1;
5361 }
5362 return resultobj;
5363 fail:
5364 {
5365 if (temp1)
5366 delete arg1;
5367 }
5368 return NULL;
5369 }
5370
5371
5372 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5373 PyObject *resultobj = 0;
5374 wxString result;
5375
5376 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5377 {
5378 PyThreadState* __tstate = wxPyBeginAllowThreads();
5379 result = wxGetEmailAddress();
5380 wxPyEndAllowThreads(__tstate);
5381 if (PyErr_Occurred()) SWIG_fail;
5382 }
5383 {
5384 #if wxUSE_UNICODE
5385 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5386 #else
5387 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5388 #endif
5389 }
5390 return resultobj;
5391 fail:
5392 return NULL;
5393 }
5394
5395
5396 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5397 PyObject *resultobj = 0;
5398 wxString result;
5399
5400 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5401 {
5402 PyThreadState* __tstate = wxPyBeginAllowThreads();
5403 result = wxGetHostName();
5404 wxPyEndAllowThreads(__tstate);
5405 if (PyErr_Occurred()) SWIG_fail;
5406 }
5407 {
5408 #if wxUSE_UNICODE
5409 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5410 #else
5411 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5412 #endif
5413 }
5414 return resultobj;
5415 fail:
5416 return NULL;
5417 }
5418
5419
5420 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5421 PyObject *resultobj = 0;
5422 wxString result;
5423
5424 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5425 {
5426 PyThreadState* __tstate = wxPyBeginAllowThreads();
5427 result = wxGetFullHostName();
5428 wxPyEndAllowThreads(__tstate);
5429 if (PyErr_Occurred()) SWIG_fail;
5430 }
5431 {
5432 #if wxUSE_UNICODE
5433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5434 #else
5435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5436 #endif
5437 }
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5445 PyObject *resultobj = 0;
5446 wxString result;
5447
5448 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5449 {
5450 PyThreadState* __tstate = wxPyBeginAllowThreads();
5451 result = wxGetUserId();
5452 wxPyEndAllowThreads(__tstate);
5453 if (PyErr_Occurred()) SWIG_fail;
5454 }
5455 {
5456 #if wxUSE_UNICODE
5457 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5458 #else
5459 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5460 #endif
5461 }
5462 return resultobj;
5463 fail:
5464 return NULL;
5465 }
5466
5467
5468 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5469 PyObject *resultobj = 0;
5470 wxString result;
5471
5472 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5473 {
5474 PyThreadState* __tstate = wxPyBeginAllowThreads();
5475 result = wxGetUserName();
5476 wxPyEndAllowThreads(__tstate);
5477 if (PyErr_Occurred()) SWIG_fail;
5478 }
5479 {
5480 #if wxUSE_UNICODE
5481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5482 #else
5483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5484 #endif
5485 }
5486 return resultobj;
5487 fail:
5488 return NULL;
5489 }
5490
5491
5492 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5493 PyObject *resultobj = 0;
5494 wxString result;
5495
5496 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5497 {
5498 PyThreadState* __tstate = wxPyBeginAllowThreads();
5499 result = wxGetHomeDir();
5500 wxPyEndAllowThreads(__tstate);
5501 if (PyErr_Occurred()) SWIG_fail;
5502 }
5503 {
5504 #if wxUSE_UNICODE
5505 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5506 #else
5507 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5508 #endif
5509 }
5510 return resultobj;
5511 fail:
5512 return NULL;
5513 }
5514
5515
5516 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5517 PyObject *resultobj = 0;
5518 wxString const &arg1_defvalue = wxPyEmptyString ;
5519 wxString *arg1 = (wxString *) &arg1_defvalue ;
5520 wxString result;
5521 bool temp1 = false ;
5522 PyObject * obj0 = 0 ;
5523 char * kwnames[] = {
5524 (char *) "user", NULL
5525 };
5526
5527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5528 if (obj0) {
5529 {
5530 arg1 = wxString_in_helper(obj0);
5531 if (arg1 == NULL) SWIG_fail;
5532 temp1 = true;
5533 }
5534 }
5535 {
5536 PyThreadState* __tstate = wxPyBeginAllowThreads();
5537 result = wxGetUserHome((wxString const &)*arg1);
5538 wxPyEndAllowThreads(__tstate);
5539 if (PyErr_Occurred()) SWIG_fail;
5540 }
5541 {
5542 #if wxUSE_UNICODE
5543 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5544 #else
5545 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5546 #endif
5547 }
5548 {
5549 if (temp1)
5550 delete arg1;
5551 }
5552 return resultobj;
5553 fail:
5554 {
5555 if (temp1)
5556 delete arg1;
5557 }
5558 return NULL;
5559 }
5560
5561
5562 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5563 PyObject *resultobj = 0;
5564 unsigned long result;
5565
5566 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5567 {
5568 PyThreadState* __tstate = wxPyBeginAllowThreads();
5569 result = (unsigned long)wxGetProcessId();
5570 wxPyEndAllowThreads(__tstate);
5571 if (PyErr_Occurred()) SWIG_fail;
5572 }
5573 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5574 return resultobj;
5575 fail:
5576 return NULL;
5577 }
5578
5579
5580 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5581 PyObject *resultobj = 0;
5582
5583 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5584 {
5585 PyThreadState* __tstate = wxPyBeginAllowThreads();
5586 wxTrap();
5587 wxPyEndAllowThreads(__tstate);
5588 if (PyErr_Occurred()) SWIG_fail;
5589 }
5590 resultobj = SWIG_Py_Void();
5591 return resultobj;
5592 fail:
5593 return NULL;
5594 }
5595
5596
5597 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5598 PyObject *resultobj = 0;
5599 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5600 wxString *arg1 = (wxString *) &arg1_defvalue ;
5601 wxString const &arg2_defvalue = wxPyEmptyString ;
5602 wxString *arg2 = (wxString *) &arg2_defvalue ;
5603 wxString const &arg3_defvalue = wxPyEmptyString ;
5604 wxString *arg3 = (wxString *) &arg3_defvalue ;
5605 wxString const &arg4_defvalue = wxPyEmptyString ;
5606 wxString *arg4 = (wxString *) &arg4_defvalue ;
5607 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5608 wxString *arg5 = (wxString *) &arg5_defvalue ;
5609 int arg6 = (int) 0 ;
5610 wxWindow *arg7 = (wxWindow *) NULL ;
5611 int arg8 = (int) -1 ;
5612 int arg9 = (int) -1 ;
5613 wxString result;
5614 bool temp1 = false ;
5615 bool temp2 = false ;
5616 bool temp3 = false ;
5617 bool temp4 = false ;
5618 bool temp5 = false ;
5619 int val6 ;
5620 int ecode6 = 0 ;
5621 void *argp7 = 0 ;
5622 int res7 = 0 ;
5623 int val8 ;
5624 int ecode8 = 0 ;
5625 int val9 ;
5626 int ecode9 = 0 ;
5627 PyObject * obj0 = 0 ;
5628 PyObject * obj1 = 0 ;
5629 PyObject * obj2 = 0 ;
5630 PyObject * obj3 = 0 ;
5631 PyObject * obj4 = 0 ;
5632 PyObject * obj5 = 0 ;
5633 PyObject * obj6 = 0 ;
5634 PyObject * obj7 = 0 ;
5635 PyObject * obj8 = 0 ;
5636 char * kwnames[] = {
5637 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5638 };
5639
5640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5641 if (obj0) {
5642 {
5643 arg1 = wxString_in_helper(obj0);
5644 if (arg1 == NULL) SWIG_fail;
5645 temp1 = true;
5646 }
5647 }
5648 if (obj1) {
5649 {
5650 arg2 = wxString_in_helper(obj1);
5651 if (arg2 == NULL) SWIG_fail;
5652 temp2 = true;
5653 }
5654 }
5655 if (obj2) {
5656 {
5657 arg3 = wxString_in_helper(obj2);
5658 if (arg3 == NULL) SWIG_fail;
5659 temp3 = true;
5660 }
5661 }
5662 if (obj3) {
5663 {
5664 arg4 = wxString_in_helper(obj3);
5665 if (arg4 == NULL) SWIG_fail;
5666 temp4 = true;
5667 }
5668 }
5669 if (obj4) {
5670 {
5671 arg5 = wxString_in_helper(obj4);
5672 if (arg5 == NULL) SWIG_fail;
5673 temp5 = true;
5674 }
5675 }
5676 if (obj5) {
5677 ecode6 = SWIG_AsVal_int(obj5, &val6);
5678 if (!SWIG_IsOK(ecode6)) {
5679 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5680 }
5681 arg6 = static_cast< int >(val6);
5682 }
5683 if (obj6) {
5684 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5685 if (!SWIG_IsOK(res7)) {
5686 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5687 }
5688 arg7 = reinterpret_cast< wxWindow * >(argp7);
5689 }
5690 if (obj7) {
5691 ecode8 = SWIG_AsVal_int(obj7, &val8);
5692 if (!SWIG_IsOK(ecode8)) {
5693 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5694 }
5695 arg8 = static_cast< int >(val8);
5696 }
5697 if (obj8) {
5698 ecode9 = SWIG_AsVal_int(obj8, &val9);
5699 if (!SWIG_IsOK(ecode9)) {
5700 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5701 }
5702 arg9 = static_cast< int >(val9);
5703 }
5704 {
5705 if (!wxPyCheckForApp()) SWIG_fail;
5706 PyThreadState* __tstate = wxPyBeginAllowThreads();
5707 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5708 wxPyEndAllowThreads(__tstate);
5709 if (PyErr_Occurred()) SWIG_fail;
5710 }
5711 {
5712 #if wxUSE_UNICODE
5713 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5714 #else
5715 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5716 #endif
5717 }
5718 {
5719 if (temp1)
5720 delete arg1;
5721 }
5722 {
5723 if (temp2)
5724 delete arg2;
5725 }
5726 {
5727 if (temp3)
5728 delete arg3;
5729 }
5730 {
5731 if (temp4)
5732 delete arg4;
5733 }
5734 {
5735 if (temp5)
5736 delete arg5;
5737 }
5738 return resultobj;
5739 fail:
5740 {
5741 if (temp1)
5742 delete arg1;
5743 }
5744 {
5745 if (temp2)
5746 delete arg2;
5747 }
5748 {
5749 if (temp3)
5750 delete arg3;
5751 }
5752 {
5753 if (temp4)
5754 delete arg4;
5755 }
5756 {
5757 if (temp5)
5758 delete arg5;
5759 }
5760 return NULL;
5761 }
5762
5763
5764 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5765 PyObject *resultobj = 0;
5766 wxString *arg1 = 0 ;
5767 wxString *arg2 = 0 ;
5768 wxString const &arg3_defvalue = wxPyEmptyString ;
5769 wxString *arg3 = (wxString *) &arg3_defvalue ;
5770 wxWindow *arg4 = (wxWindow *) NULL ;
5771 wxString result;
5772 bool temp1 = false ;
5773 bool temp2 = false ;
5774 bool temp3 = false ;
5775 void *argp4 = 0 ;
5776 int res4 = 0 ;
5777 PyObject * obj0 = 0 ;
5778 PyObject * obj1 = 0 ;
5779 PyObject * obj2 = 0 ;
5780 PyObject * obj3 = 0 ;
5781 char * kwnames[] = {
5782 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5783 };
5784
5785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5786 {
5787 arg1 = wxString_in_helper(obj0);
5788 if (arg1 == NULL) SWIG_fail;
5789 temp1 = true;
5790 }
5791 {
5792 arg2 = wxString_in_helper(obj1);
5793 if (arg2 == NULL) SWIG_fail;
5794 temp2 = true;
5795 }
5796 if (obj2) {
5797 {
5798 arg3 = wxString_in_helper(obj2);
5799 if (arg3 == NULL) SWIG_fail;
5800 temp3 = true;
5801 }
5802 }
5803 if (obj3) {
5804 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5805 if (!SWIG_IsOK(res4)) {
5806 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5807 }
5808 arg4 = reinterpret_cast< wxWindow * >(argp4);
5809 }
5810 {
5811 if (!wxPyCheckForApp()) SWIG_fail;
5812 PyThreadState* __tstate = wxPyBeginAllowThreads();
5813 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5814 wxPyEndAllowThreads(__tstate);
5815 if (PyErr_Occurred()) SWIG_fail;
5816 }
5817 {
5818 #if wxUSE_UNICODE
5819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5820 #else
5821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5822 #endif
5823 }
5824 {
5825 if (temp1)
5826 delete arg1;
5827 }
5828 {
5829 if (temp2)
5830 delete arg2;
5831 }
5832 {
5833 if (temp3)
5834 delete arg3;
5835 }
5836 return resultobj;
5837 fail:
5838 {
5839 if (temp1)
5840 delete arg1;
5841 }
5842 {
5843 if (temp2)
5844 delete arg2;
5845 }
5846 {
5847 if (temp3)
5848 delete arg3;
5849 }
5850 return NULL;
5851 }
5852
5853
5854 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5855 PyObject *resultobj = 0;
5856 wxString *arg1 = 0 ;
5857 wxString *arg2 = 0 ;
5858 wxString const &arg3_defvalue = wxPyEmptyString ;
5859 wxString *arg3 = (wxString *) &arg3_defvalue ;
5860 wxWindow *arg4 = (wxWindow *) NULL ;
5861 wxString result;
5862 bool temp1 = false ;
5863 bool temp2 = false ;
5864 bool temp3 = false ;
5865 void *argp4 = 0 ;
5866 int res4 = 0 ;
5867 PyObject * obj0 = 0 ;
5868 PyObject * obj1 = 0 ;
5869 PyObject * obj2 = 0 ;
5870 PyObject * obj3 = 0 ;
5871 char * kwnames[] = {
5872 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5873 };
5874
5875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5876 {
5877 arg1 = wxString_in_helper(obj0);
5878 if (arg1 == NULL) SWIG_fail;
5879 temp1 = true;
5880 }
5881 {
5882 arg2 = wxString_in_helper(obj1);
5883 if (arg2 == NULL) SWIG_fail;
5884 temp2 = true;
5885 }
5886 if (obj2) {
5887 {
5888 arg3 = wxString_in_helper(obj2);
5889 if (arg3 == NULL) SWIG_fail;
5890 temp3 = true;
5891 }
5892 }
5893 if (obj3) {
5894 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5895 if (!SWIG_IsOK(res4)) {
5896 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5897 }
5898 arg4 = reinterpret_cast< wxWindow * >(argp4);
5899 }
5900 {
5901 if (!wxPyCheckForApp()) SWIG_fail;
5902 PyThreadState* __tstate = wxPyBeginAllowThreads();
5903 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5904 wxPyEndAllowThreads(__tstate);
5905 if (PyErr_Occurred()) SWIG_fail;
5906 }
5907 {
5908 #if wxUSE_UNICODE
5909 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5910 #else
5911 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5912 #endif
5913 }
5914 {
5915 if (temp1)
5916 delete arg1;
5917 }
5918 {
5919 if (temp2)
5920 delete arg2;
5921 }
5922 {
5923 if (temp3)
5924 delete arg3;
5925 }
5926 return resultobj;
5927 fail:
5928 {
5929 if (temp1)
5930 delete arg1;
5931 }
5932 {
5933 if (temp2)
5934 delete arg2;
5935 }
5936 {
5937 if (temp3)
5938 delete arg3;
5939 }
5940 return NULL;
5941 }
5942
5943
5944 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5945 PyObject *resultobj = 0;
5946 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5947 wxString *arg1 = (wxString *) &arg1_defvalue ;
5948 wxString const &arg2_defvalue = wxPyEmptyString ;
5949 wxString *arg2 = (wxString *) &arg2_defvalue ;
5950 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5951 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5952 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5953 wxWindow *arg5 = (wxWindow *) NULL ;
5954 wxString result;
5955 bool temp1 = false ;
5956 bool temp2 = false ;
5957 long val3 ;
5958 int ecode3 = 0 ;
5959 wxPoint temp4 ;
5960 void *argp5 = 0 ;
5961 int res5 = 0 ;
5962 PyObject * obj0 = 0 ;
5963 PyObject * obj1 = 0 ;
5964 PyObject * obj2 = 0 ;
5965 PyObject * obj3 = 0 ;
5966 PyObject * obj4 = 0 ;
5967 char * kwnames[] = {
5968 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5969 };
5970
5971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5972 if (obj0) {
5973 {
5974 arg1 = wxString_in_helper(obj0);
5975 if (arg1 == NULL) SWIG_fail;
5976 temp1 = true;
5977 }
5978 }
5979 if (obj1) {
5980 {
5981 arg2 = wxString_in_helper(obj1);
5982 if (arg2 == NULL) SWIG_fail;
5983 temp2 = true;
5984 }
5985 }
5986 if (obj2) {
5987 ecode3 = SWIG_AsVal_long(obj2, &val3);
5988 if (!SWIG_IsOK(ecode3)) {
5989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5990 }
5991 arg3 = static_cast< long >(val3);
5992 }
5993 if (obj3) {
5994 {
5995 arg4 = &temp4;
5996 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5997 }
5998 }
5999 if (obj4) {
6000 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6001 if (!SWIG_IsOK(res5)) {
6002 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6003 }
6004 arg5 = reinterpret_cast< wxWindow * >(argp5);
6005 }
6006 {
6007 if (!wxPyCheckForApp()) SWIG_fail;
6008 PyThreadState* __tstate = wxPyBeginAllowThreads();
6009 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6010 wxPyEndAllowThreads(__tstate);
6011 if (PyErr_Occurred()) SWIG_fail;
6012 }
6013 {
6014 #if wxUSE_UNICODE
6015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6016 #else
6017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6018 #endif
6019 }
6020 {
6021 if (temp1)
6022 delete arg1;
6023 }
6024 {
6025 if (temp2)
6026 delete arg2;
6027 }
6028 return resultobj;
6029 fail:
6030 {
6031 if (temp1)
6032 delete arg1;
6033 }
6034 {
6035 if (temp2)
6036 delete arg2;
6037 }
6038 return NULL;
6039 }
6040
6041
6042 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6043 PyObject *resultobj = 0;
6044 wxString *arg1 = 0 ;
6045 wxString const &arg2_defvalue = wxPyEmptyString ;
6046 wxString *arg2 = (wxString *) &arg2_defvalue ;
6047 wxString const &arg3_defvalue = wxPyEmptyString ;
6048 wxString *arg3 = (wxString *) &arg3_defvalue ;
6049 wxWindow *arg4 = (wxWindow *) NULL ;
6050 int arg5 = (int) -1 ;
6051 int arg6 = (int) -1 ;
6052 bool arg7 = (bool) true ;
6053 wxString result;
6054 bool temp1 = false ;
6055 bool temp2 = false ;
6056 bool temp3 = false ;
6057 void *argp4 = 0 ;
6058 int res4 = 0 ;
6059 int val5 ;
6060 int ecode5 = 0 ;
6061 int val6 ;
6062 int ecode6 = 0 ;
6063 bool val7 ;
6064 int ecode7 = 0 ;
6065 PyObject * obj0 = 0 ;
6066 PyObject * obj1 = 0 ;
6067 PyObject * obj2 = 0 ;
6068 PyObject * obj3 = 0 ;
6069 PyObject * obj4 = 0 ;
6070 PyObject * obj5 = 0 ;
6071 PyObject * obj6 = 0 ;
6072 char * kwnames[] = {
6073 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6074 };
6075
6076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6077 {
6078 arg1 = wxString_in_helper(obj0);
6079 if (arg1 == NULL) SWIG_fail;
6080 temp1 = true;
6081 }
6082 if (obj1) {
6083 {
6084 arg2 = wxString_in_helper(obj1);
6085 if (arg2 == NULL) SWIG_fail;
6086 temp2 = true;
6087 }
6088 }
6089 if (obj2) {
6090 {
6091 arg3 = wxString_in_helper(obj2);
6092 if (arg3 == NULL) SWIG_fail;
6093 temp3 = true;
6094 }
6095 }
6096 if (obj3) {
6097 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6098 if (!SWIG_IsOK(res4)) {
6099 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6100 }
6101 arg4 = reinterpret_cast< wxWindow * >(argp4);
6102 }
6103 if (obj4) {
6104 ecode5 = SWIG_AsVal_int(obj4, &val5);
6105 if (!SWIG_IsOK(ecode5)) {
6106 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6107 }
6108 arg5 = static_cast< int >(val5);
6109 }
6110 if (obj5) {
6111 ecode6 = SWIG_AsVal_int(obj5, &val6);
6112 if (!SWIG_IsOK(ecode6)) {
6113 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6114 }
6115 arg6 = static_cast< int >(val6);
6116 }
6117 if (obj6) {
6118 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6119 if (!SWIG_IsOK(ecode7)) {
6120 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6121 }
6122 arg7 = static_cast< bool >(val7);
6123 }
6124 {
6125 if (!wxPyCheckForApp()) SWIG_fail;
6126 PyThreadState* __tstate = wxPyBeginAllowThreads();
6127 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6128 wxPyEndAllowThreads(__tstate);
6129 if (PyErr_Occurred()) SWIG_fail;
6130 }
6131 {
6132 #if wxUSE_UNICODE
6133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6134 #else
6135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6136 #endif
6137 }
6138 {
6139 if (temp1)
6140 delete arg1;
6141 }
6142 {
6143 if (temp2)
6144 delete arg2;
6145 }
6146 {
6147 if (temp3)
6148 delete arg3;
6149 }
6150 return resultobj;
6151 fail:
6152 {
6153 if (temp1)
6154 delete arg1;
6155 }
6156 {
6157 if (temp2)
6158 delete arg2;
6159 }
6160 {
6161 if (temp3)
6162 delete arg3;
6163 }
6164 return NULL;
6165 }
6166
6167
6168 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6169 PyObject *resultobj = 0;
6170 wxString *arg1 = 0 ;
6171 wxString const &arg2_defvalue = wxPyEmptyString ;
6172 wxString *arg2 = (wxString *) &arg2_defvalue ;
6173 wxString const &arg3_defvalue = wxPyEmptyString ;
6174 wxString *arg3 = (wxString *) &arg3_defvalue ;
6175 wxWindow *arg4 = (wxWindow *) NULL ;
6176 wxString result;
6177 bool temp1 = false ;
6178 bool temp2 = false ;
6179 bool temp3 = false ;
6180 void *argp4 = 0 ;
6181 int res4 = 0 ;
6182 PyObject * obj0 = 0 ;
6183 PyObject * obj1 = 0 ;
6184 PyObject * obj2 = 0 ;
6185 PyObject * obj3 = 0 ;
6186 char * kwnames[] = {
6187 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6188 };
6189
6190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6191 {
6192 arg1 = wxString_in_helper(obj0);
6193 if (arg1 == NULL) SWIG_fail;
6194 temp1 = true;
6195 }
6196 if (obj1) {
6197 {
6198 arg2 = wxString_in_helper(obj1);
6199 if (arg2 == NULL) SWIG_fail;
6200 temp2 = true;
6201 }
6202 }
6203 if (obj2) {
6204 {
6205 arg3 = wxString_in_helper(obj2);
6206 if (arg3 == NULL) SWIG_fail;
6207 temp3 = true;
6208 }
6209 }
6210 if (obj3) {
6211 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6212 if (!SWIG_IsOK(res4)) {
6213 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6214 }
6215 arg4 = reinterpret_cast< wxWindow * >(argp4);
6216 }
6217 {
6218 if (!wxPyCheckForApp()) SWIG_fail;
6219 PyThreadState* __tstate = wxPyBeginAllowThreads();
6220 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6221 wxPyEndAllowThreads(__tstate);
6222 if (PyErr_Occurred()) SWIG_fail;
6223 }
6224 {
6225 #if wxUSE_UNICODE
6226 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6227 #else
6228 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6229 #endif
6230 }
6231 {
6232 if (temp1)
6233 delete arg1;
6234 }
6235 {
6236 if (temp2)
6237 delete arg2;
6238 }
6239 {
6240 if (temp3)
6241 delete arg3;
6242 }
6243 return resultobj;
6244 fail:
6245 {
6246 if (temp1)
6247 delete arg1;
6248 }
6249 {
6250 if (temp2)
6251 delete arg2;
6252 }
6253 {
6254 if (temp3)
6255 delete arg3;
6256 }
6257 return NULL;
6258 }
6259
6260
6261 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6262 PyObject *resultobj = 0;
6263 wxString *arg1 = 0 ;
6264 wxString *arg2 = 0 ;
6265 int arg3 ;
6266 wxString *arg4 = (wxString *) 0 ;
6267 wxWindow *arg5 = (wxWindow *) NULL ;
6268 int arg6 = (int) -1 ;
6269 int arg7 = (int) -1 ;
6270 bool arg8 = (bool) true ;
6271 int arg9 = (int) 150 ;
6272 int arg10 = (int) 200 ;
6273 wxString result;
6274 bool temp1 = false ;
6275 bool temp2 = false ;
6276 void *argp5 = 0 ;
6277 int res5 = 0 ;
6278 int val6 ;
6279 int ecode6 = 0 ;
6280 int val7 ;
6281 int ecode7 = 0 ;
6282 bool val8 ;
6283 int ecode8 = 0 ;
6284 int val9 ;
6285 int ecode9 = 0 ;
6286 int val10 ;
6287 int ecode10 = 0 ;
6288 PyObject * obj0 = 0 ;
6289 PyObject * obj1 = 0 ;
6290 PyObject * obj2 = 0 ;
6291 PyObject * obj3 = 0 ;
6292 PyObject * obj4 = 0 ;
6293 PyObject * obj5 = 0 ;
6294 PyObject * obj6 = 0 ;
6295 PyObject * obj7 = 0 ;
6296 PyObject * obj8 = 0 ;
6297 char * kwnames[] = {
6298 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6299 };
6300
6301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6302 {
6303 arg1 = wxString_in_helper(obj0);
6304 if (arg1 == NULL) SWIG_fail;
6305 temp1 = true;
6306 }
6307 {
6308 arg2 = wxString_in_helper(obj1);
6309 if (arg2 == NULL) SWIG_fail;
6310 temp2 = true;
6311 }
6312 {
6313 arg3 = PyList_Size(obj2);
6314 arg4 = wxString_LIST_helper(obj2);
6315 if (arg4 == NULL) SWIG_fail;
6316 }
6317 if (obj3) {
6318 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6319 if (!SWIG_IsOK(res5)) {
6320 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6321 }
6322 arg5 = reinterpret_cast< wxWindow * >(argp5);
6323 }
6324 if (obj4) {
6325 ecode6 = SWIG_AsVal_int(obj4, &val6);
6326 if (!SWIG_IsOK(ecode6)) {
6327 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6328 }
6329 arg6 = static_cast< int >(val6);
6330 }
6331 if (obj5) {
6332 ecode7 = SWIG_AsVal_int(obj5, &val7);
6333 if (!SWIG_IsOK(ecode7)) {
6334 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6335 }
6336 arg7 = static_cast< int >(val7);
6337 }
6338 if (obj6) {
6339 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6340 if (!SWIG_IsOK(ecode8)) {
6341 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6342 }
6343 arg8 = static_cast< bool >(val8);
6344 }
6345 if (obj7) {
6346 ecode9 = SWIG_AsVal_int(obj7, &val9);
6347 if (!SWIG_IsOK(ecode9)) {
6348 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6349 }
6350 arg9 = static_cast< int >(val9);
6351 }
6352 if (obj8) {
6353 ecode10 = SWIG_AsVal_int(obj8, &val10);
6354 if (!SWIG_IsOK(ecode10)) {
6355 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6356 }
6357 arg10 = static_cast< int >(val10);
6358 }
6359 {
6360 if (!wxPyCheckForApp()) SWIG_fail;
6361 PyThreadState* __tstate = wxPyBeginAllowThreads();
6362 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6363 wxPyEndAllowThreads(__tstate);
6364 if (PyErr_Occurred()) SWIG_fail;
6365 }
6366 {
6367 #if wxUSE_UNICODE
6368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6369 #else
6370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6371 #endif
6372 }
6373 {
6374 if (temp1)
6375 delete arg1;
6376 }
6377 {
6378 if (temp2)
6379 delete arg2;
6380 }
6381 {
6382 if (arg4) delete [] arg4;
6383 }
6384 return resultobj;
6385 fail:
6386 {
6387 if (temp1)
6388 delete arg1;
6389 }
6390 {
6391 if (temp2)
6392 delete arg2;
6393 }
6394 {
6395 if (arg4) delete [] arg4;
6396 }
6397 return NULL;
6398 }
6399
6400
6401 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6402 PyObject *resultobj = 0;
6403 wxString *arg1 = 0 ;
6404 wxString *arg2 = 0 ;
6405 int arg3 ;
6406 wxString *arg4 = (wxString *) 0 ;
6407 wxWindow *arg5 = (wxWindow *) NULL ;
6408 int arg6 = (int) -1 ;
6409 int arg7 = (int) -1 ;
6410 bool arg8 = (bool) true ;
6411 int arg9 = (int) 150 ;
6412 int arg10 = (int) 200 ;
6413 int result;
6414 bool temp1 = false ;
6415 bool temp2 = false ;
6416 void *argp5 = 0 ;
6417 int res5 = 0 ;
6418 int val6 ;
6419 int ecode6 = 0 ;
6420 int val7 ;
6421 int ecode7 = 0 ;
6422 bool val8 ;
6423 int ecode8 = 0 ;
6424 int val9 ;
6425 int ecode9 = 0 ;
6426 int val10 ;
6427 int ecode10 = 0 ;
6428 PyObject * obj0 = 0 ;
6429 PyObject * obj1 = 0 ;
6430 PyObject * obj2 = 0 ;
6431 PyObject * obj3 = 0 ;
6432 PyObject * obj4 = 0 ;
6433 PyObject * obj5 = 0 ;
6434 PyObject * obj6 = 0 ;
6435 PyObject * obj7 = 0 ;
6436 PyObject * obj8 = 0 ;
6437 char * kwnames[] = {
6438 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6439 };
6440
6441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6442 {
6443 arg1 = wxString_in_helper(obj0);
6444 if (arg1 == NULL) SWIG_fail;
6445 temp1 = true;
6446 }
6447 {
6448 arg2 = wxString_in_helper(obj1);
6449 if (arg2 == NULL) SWIG_fail;
6450 temp2 = true;
6451 }
6452 {
6453 arg3 = PyList_Size(obj2);
6454 arg4 = wxString_LIST_helper(obj2);
6455 if (arg4 == NULL) SWIG_fail;
6456 }
6457 if (obj3) {
6458 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6459 if (!SWIG_IsOK(res5)) {
6460 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6461 }
6462 arg5 = reinterpret_cast< wxWindow * >(argp5);
6463 }
6464 if (obj4) {
6465 ecode6 = SWIG_AsVal_int(obj4, &val6);
6466 if (!SWIG_IsOK(ecode6)) {
6467 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6468 }
6469 arg6 = static_cast< int >(val6);
6470 }
6471 if (obj5) {
6472 ecode7 = SWIG_AsVal_int(obj5, &val7);
6473 if (!SWIG_IsOK(ecode7)) {
6474 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6475 }
6476 arg7 = static_cast< int >(val7);
6477 }
6478 if (obj6) {
6479 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6480 if (!SWIG_IsOK(ecode8)) {
6481 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6482 }
6483 arg8 = static_cast< bool >(val8);
6484 }
6485 if (obj7) {
6486 ecode9 = SWIG_AsVal_int(obj7, &val9);
6487 if (!SWIG_IsOK(ecode9)) {
6488 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6489 }
6490 arg9 = static_cast< int >(val9);
6491 }
6492 if (obj8) {
6493 ecode10 = SWIG_AsVal_int(obj8, &val10);
6494 if (!SWIG_IsOK(ecode10)) {
6495 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6496 }
6497 arg10 = static_cast< int >(val10);
6498 }
6499 {
6500 if (!wxPyCheckForApp()) SWIG_fail;
6501 PyThreadState* __tstate = wxPyBeginAllowThreads();
6502 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6503 wxPyEndAllowThreads(__tstate);
6504 if (PyErr_Occurred()) SWIG_fail;
6505 }
6506 resultobj = SWIG_From_int(static_cast< int >(result));
6507 {
6508 if (temp1)
6509 delete arg1;
6510 }
6511 {
6512 if (temp2)
6513 delete arg2;
6514 }
6515 {
6516 if (arg4) delete [] arg4;
6517 }
6518 return resultobj;
6519 fail:
6520 {
6521 if (temp1)
6522 delete arg1;
6523 }
6524 {
6525 if (temp2)
6526 delete arg2;
6527 }
6528 {
6529 if (arg4) delete [] arg4;
6530 }
6531 return NULL;
6532 }
6533
6534
6535 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6536 PyObject *resultobj = 0;
6537 wxString *arg1 = 0 ;
6538 wxString const &arg2_defvalue = wxPyEmptyString ;
6539 wxString *arg2 = (wxString *) &arg2_defvalue ;
6540 int arg3 = (int) wxOK|wxCENTRE ;
6541 wxWindow *arg4 = (wxWindow *) NULL ;
6542 int arg5 = (int) -1 ;
6543 int arg6 = (int) -1 ;
6544 int result;
6545 bool temp1 = false ;
6546 bool temp2 = false ;
6547 int val3 ;
6548 int ecode3 = 0 ;
6549 void *argp4 = 0 ;
6550 int res4 = 0 ;
6551 int val5 ;
6552 int ecode5 = 0 ;
6553 int val6 ;
6554 int ecode6 = 0 ;
6555 PyObject * obj0 = 0 ;
6556 PyObject * obj1 = 0 ;
6557 PyObject * obj2 = 0 ;
6558 PyObject * obj3 = 0 ;
6559 PyObject * obj4 = 0 ;
6560 PyObject * obj5 = 0 ;
6561 char * kwnames[] = {
6562 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6563 };
6564
6565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6566 {
6567 arg1 = wxString_in_helper(obj0);
6568 if (arg1 == NULL) SWIG_fail;
6569 temp1 = true;
6570 }
6571 if (obj1) {
6572 {
6573 arg2 = wxString_in_helper(obj1);
6574 if (arg2 == NULL) SWIG_fail;
6575 temp2 = true;
6576 }
6577 }
6578 if (obj2) {
6579 ecode3 = SWIG_AsVal_int(obj2, &val3);
6580 if (!SWIG_IsOK(ecode3)) {
6581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6582 }
6583 arg3 = static_cast< int >(val3);
6584 }
6585 if (obj3) {
6586 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6587 if (!SWIG_IsOK(res4)) {
6588 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6589 }
6590 arg4 = reinterpret_cast< wxWindow * >(argp4);
6591 }
6592 if (obj4) {
6593 ecode5 = SWIG_AsVal_int(obj4, &val5);
6594 if (!SWIG_IsOK(ecode5)) {
6595 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6596 }
6597 arg5 = static_cast< int >(val5);
6598 }
6599 if (obj5) {
6600 ecode6 = SWIG_AsVal_int(obj5, &val6);
6601 if (!SWIG_IsOK(ecode6)) {
6602 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6603 }
6604 arg6 = static_cast< int >(val6);
6605 }
6606 {
6607 if (!wxPyCheckForApp()) SWIG_fail;
6608 PyThreadState* __tstate = wxPyBeginAllowThreads();
6609 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6610 wxPyEndAllowThreads(__tstate);
6611 if (PyErr_Occurred()) SWIG_fail;
6612 }
6613 resultobj = SWIG_From_int(static_cast< int >(result));
6614 {
6615 if (temp1)
6616 delete arg1;
6617 }
6618 {
6619 if (temp2)
6620 delete arg2;
6621 }
6622 return resultobj;
6623 fail:
6624 {
6625 if (temp1)
6626 delete arg1;
6627 }
6628 {
6629 if (temp2)
6630 delete arg2;
6631 }
6632 return NULL;
6633 }
6634
6635
6636 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6637 PyObject *resultobj = 0;
6638 wxString *arg1 = 0 ;
6639 wxString *arg2 = 0 ;
6640 wxString *arg3 = 0 ;
6641 long arg4 ;
6642 long arg5 = (long) 0 ;
6643 long arg6 = (long) 100 ;
6644 wxWindow *arg7 = (wxWindow *) NULL ;
6645 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6646 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6647 long result;
6648 bool temp1 = false ;
6649 bool temp2 = false ;
6650 bool temp3 = false ;
6651 long val4 ;
6652 int ecode4 = 0 ;
6653 long val5 ;
6654 int ecode5 = 0 ;
6655 long val6 ;
6656 int ecode6 = 0 ;
6657 void *argp7 = 0 ;
6658 int res7 = 0 ;
6659 wxPoint temp8 ;
6660 PyObject * obj0 = 0 ;
6661 PyObject * obj1 = 0 ;
6662 PyObject * obj2 = 0 ;
6663 PyObject * obj3 = 0 ;
6664 PyObject * obj4 = 0 ;
6665 PyObject * obj5 = 0 ;
6666 PyObject * obj6 = 0 ;
6667 PyObject * obj7 = 0 ;
6668 char * kwnames[] = {
6669 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6670 };
6671
6672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6673 {
6674 arg1 = wxString_in_helper(obj0);
6675 if (arg1 == NULL) SWIG_fail;
6676 temp1 = true;
6677 }
6678 {
6679 arg2 = wxString_in_helper(obj1);
6680 if (arg2 == NULL) SWIG_fail;
6681 temp2 = true;
6682 }
6683 {
6684 arg3 = wxString_in_helper(obj2);
6685 if (arg3 == NULL) SWIG_fail;
6686 temp3 = true;
6687 }
6688 ecode4 = SWIG_AsVal_long(obj3, &val4);
6689 if (!SWIG_IsOK(ecode4)) {
6690 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6691 }
6692 arg4 = static_cast< long >(val4);
6693 if (obj4) {
6694 ecode5 = SWIG_AsVal_long(obj4, &val5);
6695 if (!SWIG_IsOK(ecode5)) {
6696 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6697 }
6698 arg5 = static_cast< long >(val5);
6699 }
6700 if (obj5) {
6701 ecode6 = SWIG_AsVal_long(obj5, &val6);
6702 if (!SWIG_IsOK(ecode6)) {
6703 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6704 }
6705 arg6 = static_cast< long >(val6);
6706 }
6707 if (obj6) {
6708 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6709 if (!SWIG_IsOK(res7)) {
6710 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6711 }
6712 arg7 = reinterpret_cast< wxWindow * >(argp7);
6713 }
6714 if (obj7) {
6715 {
6716 arg8 = &temp8;
6717 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6718 }
6719 }
6720 {
6721 if (!wxPyCheckForApp()) SWIG_fail;
6722 PyThreadState* __tstate = wxPyBeginAllowThreads();
6723 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6724 wxPyEndAllowThreads(__tstate);
6725 if (PyErr_Occurred()) SWIG_fail;
6726 }
6727 resultobj = SWIG_From_long(static_cast< long >(result));
6728 {
6729 if (temp1)
6730 delete arg1;
6731 }
6732 {
6733 if (temp2)
6734 delete arg2;
6735 }
6736 {
6737 if (temp3)
6738 delete arg3;
6739 }
6740 return resultobj;
6741 fail:
6742 {
6743 if (temp1)
6744 delete arg1;
6745 }
6746 {
6747 if (temp2)
6748 delete arg2;
6749 }
6750 {
6751 if (temp3)
6752 delete arg3;
6753 }
6754 return NULL;
6755 }
6756
6757
6758 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6759 PyObject *resultobj = 0;
6760 bool result;
6761
6762 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6763 {
6764 if (!wxPyCheckForApp()) SWIG_fail;
6765 PyThreadState* __tstate = wxPyBeginAllowThreads();
6766 result = (bool)wxColourDisplay();
6767 wxPyEndAllowThreads(__tstate);
6768 if (PyErr_Occurred()) SWIG_fail;
6769 }
6770 {
6771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6772 }
6773 return resultobj;
6774 fail:
6775 return NULL;
6776 }
6777
6778
6779 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6780 PyObject *resultobj = 0;
6781 int result;
6782
6783 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6784 {
6785 if (!wxPyCheckForApp()) SWIG_fail;
6786 PyThreadState* __tstate = wxPyBeginAllowThreads();
6787 result = (int)wxDisplayDepth();
6788 wxPyEndAllowThreads(__tstate);
6789 if (PyErr_Occurred()) SWIG_fail;
6790 }
6791 resultobj = SWIG_From_int(static_cast< int >(result));
6792 return resultobj;
6793 fail:
6794 return NULL;
6795 }
6796
6797
6798 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6799 PyObject *resultobj = 0;
6800 int result;
6801
6802 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6803 {
6804 if (!wxPyCheckForApp()) SWIG_fail;
6805 PyThreadState* __tstate = wxPyBeginAllowThreads();
6806 result = (int)wxGetDisplayDepth();
6807 wxPyEndAllowThreads(__tstate);
6808 if (PyErr_Occurred()) SWIG_fail;
6809 }
6810 resultobj = SWIG_From_int(static_cast< int >(result));
6811 return resultobj;
6812 fail:
6813 return NULL;
6814 }
6815
6816
6817 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6818 PyObject *resultobj = 0;
6819 int *arg1 = (int *) 0 ;
6820 int *arg2 = (int *) 0 ;
6821 int temp1 ;
6822 int res1 = SWIG_TMPOBJ ;
6823 int temp2 ;
6824 int res2 = SWIG_TMPOBJ ;
6825
6826 arg1 = &temp1;
6827 arg2 = &temp2;
6828 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6829 {
6830 if (!wxPyCheckForApp()) SWIG_fail;
6831 PyThreadState* __tstate = wxPyBeginAllowThreads();
6832 wxDisplaySize(arg1,arg2);
6833 wxPyEndAllowThreads(__tstate);
6834 if (PyErr_Occurred()) SWIG_fail;
6835 }
6836 resultobj = SWIG_Py_Void();
6837 if (SWIG_IsTmpObj(res1)) {
6838 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6839 } else {
6840 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6841 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6842 }
6843 if (SWIG_IsTmpObj(res2)) {
6844 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6845 } else {
6846 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6847 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6848 }
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6856 PyObject *resultobj = 0;
6857 wxSize result;
6858
6859 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6860 {
6861 if (!wxPyCheckForApp()) SWIG_fail;
6862 PyThreadState* __tstate = wxPyBeginAllowThreads();
6863 result = wxGetDisplaySize();
6864 wxPyEndAllowThreads(__tstate);
6865 if (PyErr_Occurred()) SWIG_fail;
6866 }
6867 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6868 return resultobj;
6869 fail:
6870 return NULL;
6871 }
6872
6873
6874 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6875 PyObject *resultobj = 0;
6876 int *arg1 = (int *) 0 ;
6877 int *arg2 = (int *) 0 ;
6878 int temp1 ;
6879 int res1 = SWIG_TMPOBJ ;
6880 int temp2 ;
6881 int res2 = SWIG_TMPOBJ ;
6882
6883 arg1 = &temp1;
6884 arg2 = &temp2;
6885 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6886 {
6887 if (!wxPyCheckForApp()) SWIG_fail;
6888 PyThreadState* __tstate = wxPyBeginAllowThreads();
6889 wxDisplaySizeMM(arg1,arg2);
6890 wxPyEndAllowThreads(__tstate);
6891 if (PyErr_Occurred()) SWIG_fail;
6892 }
6893 resultobj = SWIG_Py_Void();
6894 if (SWIG_IsTmpObj(res1)) {
6895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6896 } else {
6897 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6898 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6899 }
6900 if (SWIG_IsTmpObj(res2)) {
6901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6902 } else {
6903 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6904 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6905 }
6906 return resultobj;
6907 fail:
6908 return NULL;
6909 }
6910
6911
6912 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6913 PyObject *resultobj = 0;
6914 wxSize result;
6915
6916 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6917 {
6918 if (!wxPyCheckForApp()) SWIG_fail;
6919 PyThreadState* __tstate = wxPyBeginAllowThreads();
6920 result = wxGetDisplaySizeMM();
6921 wxPyEndAllowThreads(__tstate);
6922 if (PyErr_Occurred()) SWIG_fail;
6923 }
6924 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6925 return resultobj;
6926 fail:
6927 return NULL;
6928 }
6929
6930
6931 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6932 PyObject *resultobj = 0;
6933 int *arg1 = (int *) 0 ;
6934 int *arg2 = (int *) 0 ;
6935 int *arg3 = (int *) 0 ;
6936 int *arg4 = (int *) 0 ;
6937 int temp1 ;
6938 int res1 = SWIG_TMPOBJ ;
6939 int temp2 ;
6940 int res2 = SWIG_TMPOBJ ;
6941 int temp3 ;
6942 int res3 = SWIG_TMPOBJ ;
6943 int temp4 ;
6944 int res4 = SWIG_TMPOBJ ;
6945
6946 arg1 = &temp1;
6947 arg2 = &temp2;
6948 arg3 = &temp3;
6949 arg4 = &temp4;
6950 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6951 {
6952 if (!wxPyCheckForApp()) SWIG_fail;
6953 PyThreadState* __tstate = wxPyBeginAllowThreads();
6954 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6955 wxPyEndAllowThreads(__tstate);
6956 if (PyErr_Occurred()) SWIG_fail;
6957 }
6958 resultobj = SWIG_Py_Void();
6959 if (SWIG_IsTmpObj(res1)) {
6960 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6961 } else {
6962 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6963 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6964 }
6965 if (SWIG_IsTmpObj(res2)) {
6966 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6967 } else {
6968 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6970 }
6971 if (SWIG_IsTmpObj(res3)) {
6972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6973 } else {
6974 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6975 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6976 }
6977 if (SWIG_IsTmpObj(res4)) {
6978 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6979 } else {
6980 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6981 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6982 }
6983 return resultobj;
6984 fail:
6985 return NULL;
6986 }
6987
6988
6989 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6990 PyObject *resultobj = 0;
6991 wxRect result;
6992
6993 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6994 {
6995 if (!wxPyCheckForApp()) SWIG_fail;
6996 PyThreadState* __tstate = wxPyBeginAllowThreads();
6997 result = wxGetClientDisplayRect();
6998 wxPyEndAllowThreads(__tstate);
6999 if (PyErr_Occurred()) SWIG_fail;
7000 }
7001 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7002 return resultobj;
7003 fail:
7004 return NULL;
7005 }
7006
7007
7008 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7009 PyObject *resultobj = 0;
7010 wxCursor *arg1 = 0 ;
7011 void *argp1 = 0 ;
7012 int res1 = 0 ;
7013 PyObject * obj0 = 0 ;
7014 char * kwnames[] = {
7015 (char *) "cursor", NULL
7016 };
7017
7018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7019 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7020 if (!SWIG_IsOK(res1)) {
7021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7022 }
7023 if (!argp1) {
7024 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7025 }
7026 arg1 = reinterpret_cast< wxCursor * >(argp1);
7027 {
7028 if (!wxPyCheckForApp()) SWIG_fail;
7029 PyThreadState* __tstate = wxPyBeginAllowThreads();
7030 wxSetCursor(*arg1);
7031 wxPyEndAllowThreads(__tstate);
7032 if (PyErr_Occurred()) SWIG_fail;
7033 }
7034 resultobj = SWIG_Py_Void();
7035 return resultobj;
7036 fail:
7037 return NULL;
7038 }
7039
7040
7041 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7042 PyObject *resultobj = 0;
7043 void *result = 0 ;
7044
7045 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7046 {
7047 if (!wxPyCheckForApp()) SWIG_fail;
7048 PyThreadState* __tstate = wxPyBeginAllowThreads();
7049 result = (void *)wxGetXDisplay();
7050 wxPyEndAllowThreads(__tstate);
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7061 PyObject *resultobj = 0;
7062 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7063 void *argp1 = 0 ;
7064 int res1 = 0 ;
7065 PyObject * obj0 = 0 ;
7066 char * kwnames[] = {
7067 (char *) "cursor", NULL
7068 };
7069
7070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7071 if (obj0) {
7072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7073 if (!SWIG_IsOK(res1)) {
7074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7075 }
7076 arg1 = reinterpret_cast< wxCursor * >(argp1);
7077 }
7078 {
7079 if (!wxPyCheckForApp()) SWIG_fail;
7080 PyThreadState* __tstate = wxPyBeginAllowThreads();
7081 wxBeginBusyCursor(arg1);
7082 wxPyEndAllowThreads(__tstate);
7083 if (PyErr_Occurred()) SWIG_fail;
7084 }
7085 resultobj = SWIG_Py_Void();
7086 return resultobj;
7087 fail:
7088 return NULL;
7089 }
7090
7091
7092 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7093 PyObject *resultobj = 0;
7094 wxPoint result;
7095
7096 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7097 {
7098 if (!wxPyCheckForApp()) SWIG_fail;
7099 PyThreadState* __tstate = wxPyBeginAllowThreads();
7100 result = wxGetMousePosition();
7101 wxPyEndAllowThreads(__tstate);
7102 if (PyErr_Occurred()) SWIG_fail;
7103 }
7104 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7105 return resultobj;
7106 fail:
7107 return NULL;
7108 }
7109
7110
7111 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7112 PyObject *resultobj = 0;
7113 wxWindow *result = 0 ;
7114
7115 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7116 {
7117 if (!wxPyCheckForApp()) SWIG_fail;
7118 PyThreadState* __tstate = wxPyBeginAllowThreads();
7119 result = (wxWindow *)FindWindowAtPointer();
7120 wxPyEndAllowThreads(__tstate);
7121 if (PyErr_Occurred()) SWIG_fail;
7122 }
7123 {
7124 resultobj = wxPyMake_wxObject(result, 0);
7125 }
7126 return resultobj;
7127 fail:
7128 return NULL;
7129 }
7130
7131
7132 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7133 PyObject *resultobj = 0;
7134 wxWindow *result = 0 ;
7135
7136 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7137 {
7138 if (!wxPyCheckForApp()) SWIG_fail;
7139 PyThreadState* __tstate = wxPyBeginAllowThreads();
7140 result = (wxWindow *)wxGetActiveWindow();
7141 wxPyEndAllowThreads(__tstate);
7142 if (PyErr_Occurred()) SWIG_fail;
7143 }
7144 {
7145 resultobj = wxPyMake_wxObject(result, 0);
7146 }
7147 return resultobj;
7148 fail:
7149 return NULL;
7150 }
7151
7152
7153 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7154 PyObject *resultobj = 0;
7155 wxPoint *arg1 = 0 ;
7156 wxWindow *result = 0 ;
7157 wxPoint temp1 ;
7158 PyObject * obj0 = 0 ;
7159 char * kwnames[] = {
7160 (char *) "pt", NULL
7161 };
7162
7163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7164 {
7165 arg1 = &temp1;
7166 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7167 }
7168 {
7169 if (!wxPyCheckForApp()) SWIG_fail;
7170 PyThreadState* __tstate = wxPyBeginAllowThreads();
7171 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7172 wxPyEndAllowThreads(__tstate);
7173 if (PyErr_Occurred()) SWIG_fail;
7174 }
7175 {
7176 resultobj = wxPyMake_wxObject(result, 0);
7177 }
7178 return resultobj;
7179 fail:
7180 return NULL;
7181 }
7182
7183
7184 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7185 PyObject *resultobj = 0;
7186 wxPoint *arg1 = 0 ;
7187 wxWindow *result = 0 ;
7188 wxPoint temp1 ;
7189 PyObject * obj0 = 0 ;
7190 char * kwnames[] = {
7191 (char *) "pt", NULL
7192 };
7193
7194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7195 {
7196 arg1 = &temp1;
7197 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7198 }
7199 {
7200 if (!wxPyCheckForApp()) SWIG_fail;
7201 PyThreadState* __tstate = wxPyBeginAllowThreads();
7202 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7203 wxPyEndAllowThreads(__tstate);
7204 if (PyErr_Occurred()) SWIG_fail;
7205 }
7206 {
7207 resultobj = wxPyMake_wxObject(result, 0);
7208 }
7209 return resultobj;
7210 fail:
7211 return NULL;
7212 }
7213
7214
7215 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7216 PyObject *resultobj = 0;
7217 wxWindow *arg1 = (wxWindow *) 0 ;
7218 wxWindow *result = 0 ;
7219 void *argp1 = 0 ;
7220 int res1 = 0 ;
7221 PyObject * obj0 = 0 ;
7222 char * kwnames[] = {
7223 (char *) "win", NULL
7224 };
7225
7226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7228 if (!SWIG_IsOK(res1)) {
7229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7230 }
7231 arg1 = reinterpret_cast< wxWindow * >(argp1);
7232 {
7233 if (!wxPyCheckForApp()) SWIG_fail;
7234 PyThreadState* __tstate = wxPyBeginAllowThreads();
7235 result = (wxWindow *)wxGetTopLevelParent(arg1);
7236 wxPyEndAllowThreads(__tstate);
7237 if (PyErr_Occurred()) SWIG_fail;
7238 }
7239 {
7240 resultobj = wxPyMake_wxObject(result, 0);
7241 }
7242 return resultobj;
7243 fail:
7244 return NULL;
7245 }
7246
7247
7248 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7249 PyObject *resultobj = 0;
7250 wxString *arg1 = 0 ;
7251 bool result;
7252 bool temp1 = false ;
7253 PyObject * obj0 = 0 ;
7254 char * kwnames[] = {
7255 (char *) "url", NULL
7256 };
7257
7258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7259 {
7260 arg1 = wxString_in_helper(obj0);
7261 if (arg1 == NULL) SWIG_fail;
7262 temp1 = true;
7263 }
7264 {
7265 PyThreadState* __tstate = wxPyBeginAllowThreads();
7266 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 {
7271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7272 }
7273 {
7274 if (temp1)
7275 delete arg1;
7276 }
7277 return resultobj;
7278 fail:
7279 {
7280 if (temp1)
7281 delete arg1;
7282 }
7283 return NULL;
7284 }
7285
7286
7287 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7288 PyObject *resultobj = 0;
7289 wxKeyCode arg1 ;
7290 bool result;
7291 int val1 ;
7292 int ecode1 = 0 ;
7293 PyObject * obj0 = 0 ;
7294 char * kwnames[] = {
7295 (char *) "key", NULL
7296 };
7297
7298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7299 ecode1 = SWIG_AsVal_int(obj0, &val1);
7300 if (!SWIG_IsOK(ecode1)) {
7301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7302 }
7303 arg1 = static_cast< wxKeyCode >(val1);
7304 {
7305 if (!wxPyCheckForApp()) SWIG_fail;
7306 PyThreadState* __tstate = wxPyBeginAllowThreads();
7307 result = (bool)wxGetKeyState(arg1);
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 {
7312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7313 }
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7321 PyObject *resultobj = 0;
7322 wxMouseState *result = 0 ;
7323
7324 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7325 {
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 result = (wxMouseState *)new wxMouseState();
7328 wxPyEndAllowThreads(__tstate);
7329 if (PyErr_Occurred()) SWIG_fail;
7330 }
7331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7332 return resultobj;
7333 fail:
7334 return NULL;
7335 }
7336
7337
7338 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7339 PyObject *resultobj = 0;
7340 wxMouseState *arg1 = (wxMouseState *) 0 ;
7341 void *argp1 = 0 ;
7342 int res1 = 0 ;
7343 PyObject *swig_obj[1] ;
7344
7345 if (!args) SWIG_fail;
7346 swig_obj[0] = args;
7347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7348 if (!SWIG_IsOK(res1)) {
7349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7350 }
7351 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7352 {
7353 PyThreadState* __tstate = wxPyBeginAllowThreads();
7354 delete arg1;
7355
7356 wxPyEndAllowThreads(__tstate);
7357 if (PyErr_Occurred()) SWIG_fail;
7358 }
7359 resultobj = SWIG_Py_Void();
7360 return resultobj;
7361 fail:
7362 return NULL;
7363 }
7364
7365
7366 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7367 PyObject *resultobj = 0;
7368 wxMouseState *arg1 = (wxMouseState *) 0 ;
7369 int result;
7370 void *argp1 = 0 ;
7371 int res1 = 0 ;
7372 PyObject *swig_obj[1] ;
7373
7374 if (!args) SWIG_fail;
7375 swig_obj[0] = args;
7376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7377 if (!SWIG_IsOK(res1)) {
7378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7379 }
7380 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7381 {
7382 PyThreadState* __tstate = wxPyBeginAllowThreads();
7383 result = (int)(arg1)->GetX();
7384 wxPyEndAllowThreads(__tstate);
7385 if (PyErr_Occurred()) SWIG_fail;
7386 }
7387 resultobj = SWIG_From_int(static_cast< int >(result));
7388 return resultobj;
7389 fail:
7390 return NULL;
7391 }
7392
7393
7394 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7395 PyObject *resultobj = 0;
7396 wxMouseState *arg1 = (wxMouseState *) 0 ;
7397 int result;
7398 void *argp1 = 0 ;
7399 int res1 = 0 ;
7400 PyObject *swig_obj[1] ;
7401
7402 if (!args) SWIG_fail;
7403 swig_obj[0] = args;
7404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7405 if (!SWIG_IsOK(res1)) {
7406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7407 }
7408 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7409 {
7410 PyThreadState* __tstate = wxPyBeginAllowThreads();
7411 result = (int)(arg1)->GetY();
7412 wxPyEndAllowThreads(__tstate);
7413 if (PyErr_Occurred()) SWIG_fail;
7414 }
7415 resultobj = SWIG_From_int(static_cast< int >(result));
7416 return resultobj;
7417 fail:
7418 return NULL;
7419 }
7420
7421
7422 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7423 PyObject *resultobj = 0;
7424 wxMouseState *arg1 = (wxMouseState *) 0 ;
7425 bool result;
7426 void *argp1 = 0 ;
7427 int res1 = 0 ;
7428 PyObject *swig_obj[1] ;
7429
7430 if (!args) SWIG_fail;
7431 swig_obj[0] = args;
7432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7433 if (!SWIG_IsOK(res1)) {
7434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7435 }
7436 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7437 {
7438 PyThreadState* __tstate = wxPyBeginAllowThreads();
7439 result = (bool)(arg1)->LeftDown();
7440 wxPyEndAllowThreads(__tstate);
7441 if (PyErr_Occurred()) SWIG_fail;
7442 }
7443 {
7444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7445 }
7446 return resultobj;
7447 fail:
7448 return NULL;
7449 }
7450
7451
7452 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7453 PyObject *resultobj = 0;
7454 wxMouseState *arg1 = (wxMouseState *) 0 ;
7455 bool result;
7456 void *argp1 = 0 ;
7457 int res1 = 0 ;
7458 PyObject *swig_obj[1] ;
7459
7460 if (!args) SWIG_fail;
7461 swig_obj[0] = args;
7462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7463 if (!SWIG_IsOK(res1)) {
7464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7465 }
7466 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7467 {
7468 PyThreadState* __tstate = wxPyBeginAllowThreads();
7469 result = (bool)(arg1)->MiddleDown();
7470 wxPyEndAllowThreads(__tstate);
7471 if (PyErr_Occurred()) SWIG_fail;
7472 }
7473 {
7474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7475 }
7476 return resultobj;
7477 fail:
7478 return NULL;
7479 }
7480
7481
7482 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7483 PyObject *resultobj = 0;
7484 wxMouseState *arg1 = (wxMouseState *) 0 ;
7485 bool result;
7486 void *argp1 = 0 ;
7487 int res1 = 0 ;
7488 PyObject *swig_obj[1] ;
7489
7490 if (!args) SWIG_fail;
7491 swig_obj[0] = args;
7492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7493 if (!SWIG_IsOK(res1)) {
7494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7495 }
7496 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7497 {
7498 PyThreadState* __tstate = wxPyBeginAllowThreads();
7499 result = (bool)(arg1)->RightDown();
7500 wxPyEndAllowThreads(__tstate);
7501 if (PyErr_Occurred()) SWIG_fail;
7502 }
7503 {
7504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7505 }
7506 return resultobj;
7507 fail:
7508 return NULL;
7509 }
7510
7511
7512 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7513 PyObject *resultobj = 0;
7514 wxMouseState *arg1 = (wxMouseState *) 0 ;
7515 bool result;
7516 void *argp1 = 0 ;
7517 int res1 = 0 ;
7518 PyObject *swig_obj[1] ;
7519
7520 if (!args) SWIG_fail;
7521 swig_obj[0] = args;
7522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7523 if (!SWIG_IsOK(res1)) {
7524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7525 }
7526 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7527 {
7528 PyThreadState* __tstate = wxPyBeginAllowThreads();
7529 result = (bool)(arg1)->ControlDown();
7530 wxPyEndAllowThreads(__tstate);
7531 if (PyErr_Occurred()) SWIG_fail;
7532 }
7533 {
7534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7535 }
7536 return resultobj;
7537 fail:
7538 return NULL;
7539 }
7540
7541
7542 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7543 PyObject *resultobj = 0;
7544 wxMouseState *arg1 = (wxMouseState *) 0 ;
7545 bool result;
7546 void *argp1 = 0 ;
7547 int res1 = 0 ;
7548 PyObject *swig_obj[1] ;
7549
7550 if (!args) SWIG_fail;
7551 swig_obj[0] = args;
7552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7553 if (!SWIG_IsOK(res1)) {
7554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7555 }
7556 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7557 {
7558 PyThreadState* __tstate = wxPyBeginAllowThreads();
7559 result = (bool)(arg1)->ShiftDown();
7560 wxPyEndAllowThreads(__tstate);
7561 if (PyErr_Occurred()) SWIG_fail;
7562 }
7563 {
7564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7565 }
7566 return resultobj;
7567 fail:
7568 return NULL;
7569 }
7570
7571
7572 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7573 PyObject *resultobj = 0;
7574 wxMouseState *arg1 = (wxMouseState *) 0 ;
7575 bool result;
7576 void *argp1 = 0 ;
7577 int res1 = 0 ;
7578 PyObject *swig_obj[1] ;
7579
7580 if (!args) SWIG_fail;
7581 swig_obj[0] = args;
7582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7583 if (!SWIG_IsOK(res1)) {
7584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7585 }
7586 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7587 {
7588 PyThreadState* __tstate = wxPyBeginAllowThreads();
7589 result = (bool)(arg1)->AltDown();
7590 wxPyEndAllowThreads(__tstate);
7591 if (PyErr_Occurred()) SWIG_fail;
7592 }
7593 {
7594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7595 }
7596 return resultobj;
7597 fail:
7598 return NULL;
7599 }
7600
7601
7602 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7603 PyObject *resultobj = 0;
7604 wxMouseState *arg1 = (wxMouseState *) 0 ;
7605 bool result;
7606 void *argp1 = 0 ;
7607 int res1 = 0 ;
7608 PyObject *swig_obj[1] ;
7609
7610 if (!args) SWIG_fail;
7611 swig_obj[0] = args;
7612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7613 if (!SWIG_IsOK(res1)) {
7614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7615 }
7616 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7617 {
7618 PyThreadState* __tstate = wxPyBeginAllowThreads();
7619 result = (bool)(arg1)->MetaDown();
7620 wxPyEndAllowThreads(__tstate);
7621 if (PyErr_Occurred()) SWIG_fail;
7622 }
7623 {
7624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7625 }
7626 return resultobj;
7627 fail:
7628 return NULL;
7629 }
7630
7631
7632 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7633 PyObject *resultobj = 0;
7634 wxMouseState *arg1 = (wxMouseState *) 0 ;
7635 bool result;
7636 void *argp1 = 0 ;
7637 int res1 = 0 ;
7638 PyObject *swig_obj[1] ;
7639
7640 if (!args) SWIG_fail;
7641 swig_obj[0] = args;
7642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7643 if (!SWIG_IsOK(res1)) {
7644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7645 }
7646 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7647 {
7648 PyThreadState* __tstate = wxPyBeginAllowThreads();
7649 result = (bool)(arg1)->CmdDown();
7650 wxPyEndAllowThreads(__tstate);
7651 if (PyErr_Occurred()) SWIG_fail;
7652 }
7653 {
7654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7655 }
7656 return resultobj;
7657 fail:
7658 return NULL;
7659 }
7660
7661
7662 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7663 PyObject *resultobj = 0;
7664 wxMouseState *arg1 = (wxMouseState *) 0 ;
7665 int arg2 ;
7666 void *argp1 = 0 ;
7667 int res1 = 0 ;
7668 int val2 ;
7669 int ecode2 = 0 ;
7670 PyObject * obj0 = 0 ;
7671 PyObject * obj1 = 0 ;
7672 char * kwnames[] = {
7673 (char *) "self",(char *) "x", NULL
7674 };
7675
7676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7678 if (!SWIG_IsOK(res1)) {
7679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7680 }
7681 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7682 ecode2 = SWIG_AsVal_int(obj1, &val2);
7683 if (!SWIG_IsOK(ecode2)) {
7684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7685 }
7686 arg2 = static_cast< int >(val2);
7687 {
7688 PyThreadState* __tstate = wxPyBeginAllowThreads();
7689 (arg1)->SetX(arg2);
7690 wxPyEndAllowThreads(__tstate);
7691 if (PyErr_Occurred()) SWIG_fail;
7692 }
7693 resultobj = SWIG_Py_Void();
7694 return resultobj;
7695 fail:
7696 return NULL;
7697 }
7698
7699
7700 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7701 PyObject *resultobj = 0;
7702 wxMouseState *arg1 = (wxMouseState *) 0 ;
7703 int arg2 ;
7704 void *argp1 = 0 ;
7705 int res1 = 0 ;
7706 int val2 ;
7707 int ecode2 = 0 ;
7708 PyObject * obj0 = 0 ;
7709 PyObject * obj1 = 0 ;
7710 char * kwnames[] = {
7711 (char *) "self",(char *) "y", NULL
7712 };
7713
7714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7716 if (!SWIG_IsOK(res1)) {
7717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7718 }
7719 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7720 ecode2 = SWIG_AsVal_int(obj1, &val2);
7721 if (!SWIG_IsOK(ecode2)) {
7722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7723 }
7724 arg2 = static_cast< int >(val2);
7725 {
7726 PyThreadState* __tstate = wxPyBeginAllowThreads();
7727 (arg1)->SetY(arg2);
7728 wxPyEndAllowThreads(__tstate);
7729 if (PyErr_Occurred()) SWIG_fail;
7730 }
7731 resultobj = SWIG_Py_Void();
7732 return resultobj;
7733 fail:
7734 return NULL;
7735 }
7736
7737
7738 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7739 PyObject *resultobj = 0;
7740 wxMouseState *arg1 = (wxMouseState *) 0 ;
7741 bool arg2 ;
7742 void *argp1 = 0 ;
7743 int res1 = 0 ;
7744 bool val2 ;
7745 int ecode2 = 0 ;
7746 PyObject * obj0 = 0 ;
7747 PyObject * obj1 = 0 ;
7748 char * kwnames[] = {
7749 (char *) "self",(char *) "down", NULL
7750 };
7751
7752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7754 if (!SWIG_IsOK(res1)) {
7755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7756 }
7757 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7758 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7759 if (!SWIG_IsOK(ecode2)) {
7760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7761 }
7762 arg2 = static_cast< bool >(val2);
7763 {
7764 PyThreadState* __tstate = wxPyBeginAllowThreads();
7765 (arg1)->SetLeftDown(arg2);
7766 wxPyEndAllowThreads(__tstate);
7767 if (PyErr_Occurred()) SWIG_fail;
7768 }
7769 resultobj = SWIG_Py_Void();
7770 return resultobj;
7771 fail:
7772 return NULL;
7773 }
7774
7775
7776 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7777 PyObject *resultobj = 0;
7778 wxMouseState *arg1 = (wxMouseState *) 0 ;
7779 bool arg2 ;
7780 void *argp1 = 0 ;
7781 int res1 = 0 ;
7782 bool val2 ;
7783 int ecode2 = 0 ;
7784 PyObject * obj0 = 0 ;
7785 PyObject * obj1 = 0 ;
7786 char * kwnames[] = {
7787 (char *) "self",(char *) "down", NULL
7788 };
7789
7790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7792 if (!SWIG_IsOK(res1)) {
7793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7794 }
7795 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7796 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7797 if (!SWIG_IsOK(ecode2)) {
7798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7799 }
7800 arg2 = static_cast< bool >(val2);
7801 {
7802 PyThreadState* __tstate = wxPyBeginAllowThreads();
7803 (arg1)->SetMiddleDown(arg2);
7804 wxPyEndAllowThreads(__tstate);
7805 if (PyErr_Occurred()) SWIG_fail;
7806 }
7807 resultobj = SWIG_Py_Void();
7808 return resultobj;
7809 fail:
7810 return NULL;
7811 }
7812
7813
7814 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7815 PyObject *resultobj = 0;
7816 wxMouseState *arg1 = (wxMouseState *) 0 ;
7817 bool arg2 ;
7818 void *argp1 = 0 ;
7819 int res1 = 0 ;
7820 bool val2 ;
7821 int ecode2 = 0 ;
7822 PyObject * obj0 = 0 ;
7823 PyObject * obj1 = 0 ;
7824 char * kwnames[] = {
7825 (char *) "self",(char *) "down", NULL
7826 };
7827
7828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7830 if (!SWIG_IsOK(res1)) {
7831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7832 }
7833 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7834 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7835 if (!SWIG_IsOK(ecode2)) {
7836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7837 }
7838 arg2 = static_cast< bool >(val2);
7839 {
7840 PyThreadState* __tstate = wxPyBeginAllowThreads();
7841 (arg1)->SetRightDown(arg2);
7842 wxPyEndAllowThreads(__tstate);
7843 if (PyErr_Occurred()) SWIG_fail;
7844 }
7845 resultobj = SWIG_Py_Void();
7846 return resultobj;
7847 fail:
7848 return NULL;
7849 }
7850
7851
7852 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7853 PyObject *resultobj = 0;
7854 wxMouseState *arg1 = (wxMouseState *) 0 ;
7855 bool arg2 ;
7856 void *argp1 = 0 ;
7857 int res1 = 0 ;
7858 bool val2 ;
7859 int ecode2 = 0 ;
7860 PyObject * obj0 = 0 ;
7861 PyObject * obj1 = 0 ;
7862 char * kwnames[] = {
7863 (char *) "self",(char *) "down", NULL
7864 };
7865
7866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7868 if (!SWIG_IsOK(res1)) {
7869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7870 }
7871 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7872 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7873 if (!SWIG_IsOK(ecode2)) {
7874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7875 }
7876 arg2 = static_cast< bool >(val2);
7877 {
7878 PyThreadState* __tstate = wxPyBeginAllowThreads();
7879 (arg1)->SetControlDown(arg2);
7880 wxPyEndAllowThreads(__tstate);
7881 if (PyErr_Occurred()) SWIG_fail;
7882 }
7883 resultobj = SWIG_Py_Void();
7884 return resultobj;
7885 fail:
7886 return NULL;
7887 }
7888
7889
7890 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7891 PyObject *resultobj = 0;
7892 wxMouseState *arg1 = (wxMouseState *) 0 ;
7893 bool arg2 ;
7894 void *argp1 = 0 ;
7895 int res1 = 0 ;
7896 bool val2 ;
7897 int ecode2 = 0 ;
7898 PyObject * obj0 = 0 ;
7899 PyObject * obj1 = 0 ;
7900 char * kwnames[] = {
7901 (char *) "self",(char *) "down", NULL
7902 };
7903
7904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7906 if (!SWIG_IsOK(res1)) {
7907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7908 }
7909 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7910 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7911 if (!SWIG_IsOK(ecode2)) {
7912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7913 }
7914 arg2 = static_cast< bool >(val2);
7915 {
7916 PyThreadState* __tstate = wxPyBeginAllowThreads();
7917 (arg1)->SetShiftDown(arg2);
7918 wxPyEndAllowThreads(__tstate);
7919 if (PyErr_Occurred()) SWIG_fail;
7920 }
7921 resultobj = SWIG_Py_Void();
7922 return resultobj;
7923 fail:
7924 return NULL;
7925 }
7926
7927
7928 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7929 PyObject *resultobj = 0;
7930 wxMouseState *arg1 = (wxMouseState *) 0 ;
7931 bool arg2 ;
7932 void *argp1 = 0 ;
7933 int res1 = 0 ;
7934 bool val2 ;
7935 int ecode2 = 0 ;
7936 PyObject * obj0 = 0 ;
7937 PyObject * obj1 = 0 ;
7938 char * kwnames[] = {
7939 (char *) "self",(char *) "down", NULL
7940 };
7941
7942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7944 if (!SWIG_IsOK(res1)) {
7945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7946 }
7947 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7948 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7949 if (!SWIG_IsOK(ecode2)) {
7950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7951 }
7952 arg2 = static_cast< bool >(val2);
7953 {
7954 PyThreadState* __tstate = wxPyBeginAllowThreads();
7955 (arg1)->SetAltDown(arg2);
7956 wxPyEndAllowThreads(__tstate);
7957 if (PyErr_Occurred()) SWIG_fail;
7958 }
7959 resultobj = SWIG_Py_Void();
7960 return resultobj;
7961 fail:
7962 return NULL;
7963 }
7964
7965
7966 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7967 PyObject *resultobj = 0;
7968 wxMouseState *arg1 = (wxMouseState *) 0 ;
7969 bool arg2 ;
7970 void *argp1 = 0 ;
7971 int res1 = 0 ;
7972 bool val2 ;
7973 int ecode2 = 0 ;
7974 PyObject * obj0 = 0 ;
7975 PyObject * obj1 = 0 ;
7976 char * kwnames[] = {
7977 (char *) "self",(char *) "down", NULL
7978 };
7979
7980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7982 if (!SWIG_IsOK(res1)) {
7983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7984 }
7985 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7986 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7987 if (!SWIG_IsOK(ecode2)) {
7988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7989 }
7990 arg2 = static_cast< bool >(val2);
7991 {
7992 PyThreadState* __tstate = wxPyBeginAllowThreads();
7993 (arg1)->SetMetaDown(arg2);
7994 wxPyEndAllowThreads(__tstate);
7995 if (PyErr_Occurred()) SWIG_fail;
7996 }
7997 resultobj = SWIG_Py_Void();
7998 return resultobj;
7999 fail:
8000 return NULL;
8001 }
8002
8003
8004 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8005 PyObject *obj;
8006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8007 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8008 return SWIG_Py_Void();
8009 }
8010
8011 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8012 return SWIG_Python_InitShadowInstance(args);
8013 }
8014
8015 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8016 PyObject *resultobj = 0;
8017 wxMouseState result;
8018
8019 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8020 {
8021 PyThreadState* __tstate = wxPyBeginAllowThreads();
8022 result = wxGetMouseState();
8023 wxPyEndAllowThreads(__tstate);
8024 if (PyErr_Occurred()) SWIG_fail;
8025 }
8026 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8027 return resultobj;
8028 fail:
8029 return NULL;
8030 }
8031
8032
8033 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8034 PyObject *resultobj = 0;
8035
8036 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8037 {
8038 if (!wxPyCheckForApp()) SWIG_fail;
8039 PyThreadState* __tstate = wxPyBeginAllowThreads();
8040 wxWakeUpMainThread();
8041 wxPyEndAllowThreads(__tstate);
8042 if (PyErr_Occurred()) SWIG_fail;
8043 }
8044 resultobj = SWIG_Py_Void();
8045 return resultobj;
8046 fail:
8047 return NULL;
8048 }
8049
8050
8051 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8052 PyObject *resultobj = 0;
8053
8054 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8055 {
8056 if (!wxPyCheckForApp()) SWIG_fail;
8057 PyThreadState* __tstate = wxPyBeginAllowThreads();
8058 wxMutexGuiEnter();
8059 wxPyEndAllowThreads(__tstate);
8060 if (PyErr_Occurred()) SWIG_fail;
8061 }
8062 resultobj = SWIG_Py_Void();
8063 return resultobj;
8064 fail:
8065 return NULL;
8066 }
8067
8068
8069 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8070 PyObject *resultobj = 0;
8071
8072 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8073 {
8074 if (!wxPyCheckForApp()) SWIG_fail;
8075 PyThreadState* __tstate = wxPyBeginAllowThreads();
8076 wxMutexGuiLeave();
8077 wxPyEndAllowThreads(__tstate);
8078 if (PyErr_Occurred()) SWIG_fail;
8079 }
8080 resultobj = SWIG_Py_Void();
8081 return resultobj;
8082 fail:
8083 return NULL;
8084 }
8085
8086
8087 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8088 PyObject *resultobj = 0;
8089 wxMutexGuiLocker *result = 0 ;
8090
8091 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8092 {
8093 if (!wxPyCheckForApp()) SWIG_fail;
8094 PyThreadState* __tstate = wxPyBeginAllowThreads();
8095 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8096 wxPyEndAllowThreads(__tstate);
8097 if (PyErr_Occurred()) SWIG_fail;
8098 }
8099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8100 return resultobj;
8101 fail:
8102 return NULL;
8103 }
8104
8105
8106 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8107 PyObject *resultobj = 0;
8108 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8109 void *argp1 = 0 ;
8110 int res1 = 0 ;
8111 PyObject *swig_obj[1] ;
8112
8113 if (!args) SWIG_fail;
8114 swig_obj[0] = args;
8115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8116 if (!SWIG_IsOK(res1)) {
8117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8118 }
8119 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8120 {
8121 PyThreadState* __tstate = wxPyBeginAllowThreads();
8122 delete arg1;
8123
8124 wxPyEndAllowThreads(__tstate);
8125 if (PyErr_Occurred()) SWIG_fail;
8126 }
8127 resultobj = SWIG_Py_Void();
8128 return resultobj;
8129 fail:
8130 return NULL;
8131 }
8132
8133
8134 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8135 PyObject *obj;
8136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8137 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8138 return SWIG_Py_Void();
8139 }
8140
8141 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8142 return SWIG_Python_InitShadowInstance(args);
8143 }
8144
8145 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8146 PyObject *resultobj = 0;
8147 bool result;
8148
8149 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8150 {
8151 PyThreadState* __tstate = wxPyBeginAllowThreads();
8152 result = (bool)wxThread_IsMain();
8153 wxPyEndAllowThreads(__tstate);
8154 if (PyErr_Occurred()) SWIG_fail;
8155 }
8156 {
8157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8158 }
8159 return resultobj;
8160 fail:
8161 return NULL;
8162 }
8163
8164
8165 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8166 PyObject *resultobj = 0;
8167 wxString *arg1 = 0 ;
8168 wxToolTip *result = 0 ;
8169 bool temp1 = false ;
8170 PyObject * obj0 = 0 ;
8171 char * kwnames[] = {
8172 (char *) "tip", NULL
8173 };
8174
8175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8176 {
8177 arg1 = wxString_in_helper(obj0);
8178 if (arg1 == NULL) SWIG_fail;
8179 temp1 = true;
8180 }
8181 {
8182 if (!wxPyCheckForApp()) SWIG_fail;
8183 PyThreadState* __tstate = wxPyBeginAllowThreads();
8184 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8185 wxPyEndAllowThreads(__tstate);
8186 if (PyErr_Occurred()) SWIG_fail;
8187 }
8188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8189 {
8190 if (temp1)
8191 delete arg1;
8192 }
8193 return resultobj;
8194 fail:
8195 {
8196 if (temp1)
8197 delete arg1;
8198 }
8199 return NULL;
8200 }
8201
8202
8203 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8204 PyObject *resultobj = 0;
8205 wxToolTip *arg1 = (wxToolTip *) 0 ;
8206 void *argp1 = 0 ;
8207 int res1 = 0 ;
8208 PyObject *swig_obj[1] ;
8209
8210 if (!args) SWIG_fail;
8211 swig_obj[0] = args;
8212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8213 if (!SWIG_IsOK(res1)) {
8214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8215 }
8216 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8217 {
8218 PyThreadState* __tstate = wxPyBeginAllowThreads();
8219 delete arg1;
8220
8221 wxPyEndAllowThreads(__tstate);
8222 if (PyErr_Occurred()) SWIG_fail;
8223 }
8224 resultobj = SWIG_Py_Void();
8225 return resultobj;
8226 fail:
8227 return NULL;
8228 }
8229
8230
8231 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8232 PyObject *resultobj = 0;
8233 wxToolTip *arg1 = (wxToolTip *) 0 ;
8234 wxString *arg2 = 0 ;
8235 void *argp1 = 0 ;
8236 int res1 = 0 ;
8237 bool temp2 = false ;
8238 PyObject * obj0 = 0 ;
8239 PyObject * obj1 = 0 ;
8240 char * kwnames[] = {
8241 (char *) "self",(char *) "tip", NULL
8242 };
8243
8244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8246 if (!SWIG_IsOK(res1)) {
8247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8248 }
8249 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8250 {
8251 arg2 = wxString_in_helper(obj1);
8252 if (arg2 == NULL) SWIG_fail;
8253 temp2 = true;
8254 }
8255 {
8256 PyThreadState* __tstate = wxPyBeginAllowThreads();
8257 (arg1)->SetTip((wxString const &)*arg2);
8258 wxPyEndAllowThreads(__tstate);
8259 if (PyErr_Occurred()) SWIG_fail;
8260 }
8261 resultobj = SWIG_Py_Void();
8262 {
8263 if (temp2)
8264 delete arg2;
8265 }
8266 return resultobj;
8267 fail:
8268 {
8269 if (temp2)
8270 delete arg2;
8271 }
8272 return NULL;
8273 }
8274
8275
8276 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8277 PyObject *resultobj = 0;
8278 wxToolTip *arg1 = (wxToolTip *) 0 ;
8279 wxString result;
8280 void *argp1 = 0 ;
8281 int res1 = 0 ;
8282 PyObject *swig_obj[1] ;
8283
8284 if (!args) SWIG_fail;
8285 swig_obj[0] = args;
8286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8287 if (!SWIG_IsOK(res1)) {
8288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8289 }
8290 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8291 {
8292 PyThreadState* __tstate = wxPyBeginAllowThreads();
8293 result = (arg1)->GetTip();
8294 wxPyEndAllowThreads(__tstate);
8295 if (PyErr_Occurred()) SWIG_fail;
8296 }
8297 {
8298 #if wxUSE_UNICODE
8299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8300 #else
8301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8302 #endif
8303 }
8304 return resultobj;
8305 fail:
8306 return NULL;
8307 }
8308
8309
8310 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8311 PyObject *resultobj = 0;
8312 wxToolTip *arg1 = (wxToolTip *) 0 ;
8313 wxWindow *result = 0 ;
8314 void *argp1 = 0 ;
8315 int res1 = 0 ;
8316 PyObject *swig_obj[1] ;
8317
8318 if (!args) SWIG_fail;
8319 swig_obj[0] = args;
8320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8321 if (!SWIG_IsOK(res1)) {
8322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8323 }
8324 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8325 {
8326 PyThreadState* __tstate = wxPyBeginAllowThreads();
8327 result = (wxWindow *)(arg1)->GetWindow();
8328 wxPyEndAllowThreads(__tstate);
8329 if (PyErr_Occurred()) SWIG_fail;
8330 }
8331 {
8332 resultobj = wxPyMake_wxObject(result, 0);
8333 }
8334 return resultobj;
8335 fail:
8336 return NULL;
8337 }
8338
8339
8340 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8341 PyObject *resultobj = 0;
8342 bool arg1 ;
8343 bool val1 ;
8344 int ecode1 = 0 ;
8345 PyObject * obj0 = 0 ;
8346 char * kwnames[] = {
8347 (char *) "flag", NULL
8348 };
8349
8350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8351 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8352 if (!SWIG_IsOK(ecode1)) {
8353 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8354 }
8355 arg1 = static_cast< bool >(val1);
8356 {
8357 PyThreadState* __tstate = wxPyBeginAllowThreads();
8358 wxToolTip::Enable(arg1);
8359 wxPyEndAllowThreads(__tstate);
8360 if (PyErr_Occurred()) SWIG_fail;
8361 }
8362 resultobj = SWIG_Py_Void();
8363 return resultobj;
8364 fail:
8365 return NULL;
8366 }
8367
8368
8369 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8370 PyObject *resultobj = 0;
8371 long arg1 ;
8372 long val1 ;
8373 int ecode1 = 0 ;
8374 PyObject * obj0 = 0 ;
8375 char * kwnames[] = {
8376 (char *) "milliseconds", NULL
8377 };
8378
8379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8380 ecode1 = SWIG_AsVal_long(obj0, &val1);
8381 if (!SWIG_IsOK(ecode1)) {
8382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8383 }
8384 arg1 = static_cast< long >(val1);
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 wxToolTip::SetDelay(arg1);
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 resultobj = SWIG_Py_Void();
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8399 PyObject *obj;
8400 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8401 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8402 return SWIG_Py_Void();
8403 }
8404
8405 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8406 return SWIG_Python_InitShadowInstance(args);
8407 }
8408
8409 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8410 PyObject *resultobj = 0;
8411 wxWindow *arg1 = (wxWindow *) 0 ;
8412 wxSize *arg2 = 0 ;
8413 wxCaret *result = 0 ;
8414 void *argp1 = 0 ;
8415 int res1 = 0 ;
8416 wxSize temp2 ;
8417 PyObject * obj0 = 0 ;
8418 PyObject * obj1 = 0 ;
8419 char * kwnames[] = {
8420 (char *) "window",(char *) "size", NULL
8421 };
8422
8423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8425 if (!SWIG_IsOK(res1)) {
8426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8427 }
8428 arg1 = reinterpret_cast< wxWindow * >(argp1);
8429 {
8430 arg2 = &temp2;
8431 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8432 }
8433 {
8434 if (!wxPyCheckForApp()) SWIG_fail;
8435 PyThreadState* __tstate = wxPyBeginAllowThreads();
8436 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8437 wxPyEndAllowThreads(__tstate);
8438 if (PyErr_Occurred()) SWIG_fail;
8439 }
8440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8441 return resultobj;
8442 fail:
8443 return NULL;
8444 }
8445
8446
8447 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8448 PyObject *resultobj = 0;
8449 wxCaret *arg1 = (wxCaret *) 0 ;
8450 void *argp1 = 0 ;
8451 int res1 = 0 ;
8452 PyObject *swig_obj[1] ;
8453
8454 if (!args) SWIG_fail;
8455 swig_obj[0] = args;
8456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8457 if (!SWIG_IsOK(res1)) {
8458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8459 }
8460 arg1 = reinterpret_cast< wxCaret * >(argp1);
8461 {
8462 PyThreadState* __tstate = wxPyBeginAllowThreads();
8463 delete arg1;
8464
8465 wxPyEndAllowThreads(__tstate);
8466 if (PyErr_Occurred()) SWIG_fail;
8467 }
8468 resultobj = SWIG_Py_Void();
8469 return resultobj;
8470 fail:
8471 return NULL;
8472 }
8473
8474
8475 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8476 PyObject *resultobj = 0;
8477 wxCaret *arg1 = (wxCaret *) 0 ;
8478 void *argp1 = 0 ;
8479 int res1 = 0 ;
8480 PyObject *swig_obj[1] ;
8481
8482 if (!args) SWIG_fail;
8483 swig_obj[0] = args;
8484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8485 if (!SWIG_IsOK(res1)) {
8486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8487 }
8488 arg1 = reinterpret_cast< wxCaret * >(argp1);
8489 {
8490 PyThreadState* __tstate = wxPyBeginAllowThreads();
8491 wxCaret_Destroy(arg1);
8492 wxPyEndAllowThreads(__tstate);
8493 if (PyErr_Occurred()) SWIG_fail;
8494 }
8495 resultobj = SWIG_Py_Void();
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8503 PyObject *resultobj = 0;
8504 wxCaret *arg1 = (wxCaret *) 0 ;
8505 bool result;
8506 void *argp1 = 0 ;
8507 int res1 = 0 ;
8508 PyObject *swig_obj[1] ;
8509
8510 if (!args) SWIG_fail;
8511 swig_obj[0] = args;
8512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8513 if (!SWIG_IsOK(res1)) {
8514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8515 }
8516 arg1 = reinterpret_cast< wxCaret * >(argp1);
8517 {
8518 PyThreadState* __tstate = wxPyBeginAllowThreads();
8519 result = (bool)(arg1)->IsOk();
8520 wxPyEndAllowThreads(__tstate);
8521 if (PyErr_Occurred()) SWIG_fail;
8522 }
8523 {
8524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8525 }
8526 return resultobj;
8527 fail:
8528 return NULL;
8529 }
8530
8531
8532 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8533 PyObject *resultobj = 0;
8534 wxCaret *arg1 = (wxCaret *) 0 ;
8535 bool result;
8536 void *argp1 = 0 ;
8537 int res1 = 0 ;
8538 PyObject *swig_obj[1] ;
8539
8540 if (!args) SWIG_fail;
8541 swig_obj[0] = args;
8542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8543 if (!SWIG_IsOK(res1)) {
8544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8545 }
8546 arg1 = reinterpret_cast< wxCaret * >(argp1);
8547 {
8548 PyThreadState* __tstate = wxPyBeginAllowThreads();
8549 result = (bool)(arg1)->IsVisible();
8550 wxPyEndAllowThreads(__tstate);
8551 if (PyErr_Occurred()) SWIG_fail;
8552 }
8553 {
8554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8555 }
8556 return resultobj;
8557 fail:
8558 return NULL;
8559 }
8560
8561
8562 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8563 PyObject *resultobj = 0;
8564 wxCaret *arg1 = (wxCaret *) 0 ;
8565 wxPoint result;
8566 void *argp1 = 0 ;
8567 int res1 = 0 ;
8568 PyObject *swig_obj[1] ;
8569
8570 if (!args) SWIG_fail;
8571 swig_obj[0] = args;
8572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8573 if (!SWIG_IsOK(res1)) {
8574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8575 }
8576 arg1 = reinterpret_cast< wxCaret * >(argp1);
8577 {
8578 PyThreadState* __tstate = wxPyBeginAllowThreads();
8579 result = (arg1)->GetPosition();
8580 wxPyEndAllowThreads(__tstate);
8581 if (PyErr_Occurred()) SWIG_fail;
8582 }
8583 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8584 return resultobj;
8585 fail:
8586 return NULL;
8587 }
8588
8589
8590 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8591 PyObject *resultobj = 0;
8592 wxCaret *arg1 = (wxCaret *) 0 ;
8593 int *arg2 = (int *) 0 ;
8594 int *arg3 = (int *) 0 ;
8595 void *argp1 = 0 ;
8596 int res1 = 0 ;
8597 int temp2 ;
8598 int res2 = SWIG_TMPOBJ ;
8599 int temp3 ;
8600 int res3 = SWIG_TMPOBJ ;
8601 PyObject *swig_obj[1] ;
8602
8603 arg2 = &temp2;
8604 arg3 = &temp3;
8605 if (!args) SWIG_fail;
8606 swig_obj[0] = args;
8607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8608 if (!SWIG_IsOK(res1)) {
8609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8610 }
8611 arg1 = reinterpret_cast< wxCaret * >(argp1);
8612 {
8613 PyThreadState* __tstate = wxPyBeginAllowThreads();
8614 (arg1)->GetPosition(arg2,arg3);
8615 wxPyEndAllowThreads(__tstate);
8616 if (PyErr_Occurred()) SWIG_fail;
8617 }
8618 resultobj = SWIG_Py_Void();
8619 if (SWIG_IsTmpObj(res2)) {
8620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8621 } else {
8622 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8624 }
8625 if (SWIG_IsTmpObj(res3)) {
8626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8627 } else {
8628 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8630 }
8631 return resultobj;
8632 fail:
8633 return NULL;
8634 }
8635
8636
8637 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8638 PyObject *resultobj = 0;
8639 wxCaret *arg1 = (wxCaret *) 0 ;
8640 wxSize result;
8641 void *argp1 = 0 ;
8642 int res1 = 0 ;
8643 PyObject *swig_obj[1] ;
8644
8645 if (!args) SWIG_fail;
8646 swig_obj[0] = args;
8647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8648 if (!SWIG_IsOK(res1)) {
8649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8650 }
8651 arg1 = reinterpret_cast< wxCaret * >(argp1);
8652 {
8653 PyThreadState* __tstate = wxPyBeginAllowThreads();
8654 result = (arg1)->GetSize();
8655 wxPyEndAllowThreads(__tstate);
8656 if (PyErr_Occurred()) SWIG_fail;
8657 }
8658 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8659 return resultobj;
8660 fail:
8661 return NULL;
8662 }
8663
8664
8665 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8666 PyObject *resultobj = 0;
8667 wxCaret *arg1 = (wxCaret *) 0 ;
8668 int *arg2 = (int *) 0 ;
8669 int *arg3 = (int *) 0 ;
8670 void *argp1 = 0 ;
8671 int res1 = 0 ;
8672 int temp2 ;
8673 int res2 = SWIG_TMPOBJ ;
8674 int temp3 ;
8675 int res3 = SWIG_TMPOBJ ;
8676 PyObject *swig_obj[1] ;
8677
8678 arg2 = &temp2;
8679 arg3 = &temp3;
8680 if (!args) SWIG_fail;
8681 swig_obj[0] = args;
8682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8683 if (!SWIG_IsOK(res1)) {
8684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8685 }
8686 arg1 = reinterpret_cast< wxCaret * >(argp1);
8687 {
8688 PyThreadState* __tstate = wxPyBeginAllowThreads();
8689 (arg1)->GetSize(arg2,arg3);
8690 wxPyEndAllowThreads(__tstate);
8691 if (PyErr_Occurred()) SWIG_fail;
8692 }
8693 resultobj = SWIG_Py_Void();
8694 if (SWIG_IsTmpObj(res2)) {
8695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8696 } else {
8697 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8699 }
8700 if (SWIG_IsTmpObj(res3)) {
8701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8702 } else {
8703 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8705 }
8706 return resultobj;
8707 fail:
8708 return NULL;
8709 }
8710
8711
8712 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8713 PyObject *resultobj = 0;
8714 wxCaret *arg1 = (wxCaret *) 0 ;
8715 wxWindow *result = 0 ;
8716 void *argp1 = 0 ;
8717 int res1 = 0 ;
8718 PyObject *swig_obj[1] ;
8719
8720 if (!args) SWIG_fail;
8721 swig_obj[0] = args;
8722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8723 if (!SWIG_IsOK(res1)) {
8724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8725 }
8726 arg1 = reinterpret_cast< wxCaret * >(argp1);
8727 {
8728 PyThreadState* __tstate = wxPyBeginAllowThreads();
8729 result = (wxWindow *)(arg1)->GetWindow();
8730 wxPyEndAllowThreads(__tstate);
8731 if (PyErr_Occurred()) SWIG_fail;
8732 }
8733 {
8734 resultobj = wxPyMake_wxObject(result, 0);
8735 }
8736 return resultobj;
8737 fail:
8738 return NULL;
8739 }
8740
8741
8742 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8743 PyObject *resultobj = 0;
8744 wxCaret *arg1 = (wxCaret *) 0 ;
8745 int arg2 ;
8746 int arg3 ;
8747 void *argp1 = 0 ;
8748 int res1 = 0 ;
8749 int val2 ;
8750 int ecode2 = 0 ;
8751 int val3 ;
8752 int ecode3 = 0 ;
8753 PyObject * obj0 = 0 ;
8754 PyObject * obj1 = 0 ;
8755 PyObject * obj2 = 0 ;
8756 char * kwnames[] = {
8757 (char *) "self",(char *) "x",(char *) "y", NULL
8758 };
8759
8760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8762 if (!SWIG_IsOK(res1)) {
8763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8764 }
8765 arg1 = reinterpret_cast< wxCaret * >(argp1);
8766 ecode2 = SWIG_AsVal_int(obj1, &val2);
8767 if (!SWIG_IsOK(ecode2)) {
8768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8769 }
8770 arg2 = static_cast< int >(val2);
8771 ecode3 = SWIG_AsVal_int(obj2, &val3);
8772 if (!SWIG_IsOK(ecode3)) {
8773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8774 }
8775 arg3 = static_cast< int >(val3);
8776 {
8777 PyThreadState* __tstate = wxPyBeginAllowThreads();
8778 (arg1)->Move(arg2,arg3);
8779 wxPyEndAllowThreads(__tstate);
8780 if (PyErr_Occurred()) SWIG_fail;
8781 }
8782 resultobj = SWIG_Py_Void();
8783 return resultobj;
8784 fail:
8785 return NULL;
8786 }
8787
8788
8789 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8790 PyObject *resultobj = 0;
8791 wxCaret *arg1 = (wxCaret *) 0 ;
8792 wxPoint *arg2 = 0 ;
8793 void *argp1 = 0 ;
8794 int res1 = 0 ;
8795 wxPoint temp2 ;
8796 PyObject * obj0 = 0 ;
8797 PyObject * obj1 = 0 ;
8798 char * kwnames[] = {
8799 (char *) "self",(char *) "pt", NULL
8800 };
8801
8802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8804 if (!SWIG_IsOK(res1)) {
8805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8806 }
8807 arg1 = reinterpret_cast< wxCaret * >(argp1);
8808 {
8809 arg2 = &temp2;
8810 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8811 }
8812 {
8813 PyThreadState* __tstate = wxPyBeginAllowThreads();
8814 (arg1)->Move((wxPoint const &)*arg2);
8815 wxPyEndAllowThreads(__tstate);
8816 if (PyErr_Occurred()) SWIG_fail;
8817 }
8818 resultobj = SWIG_Py_Void();
8819 return resultobj;
8820 fail:
8821 return NULL;
8822 }
8823
8824
8825 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8826 PyObject *resultobj = 0;
8827 wxCaret *arg1 = (wxCaret *) 0 ;
8828 int arg2 ;
8829 int arg3 ;
8830 void *argp1 = 0 ;
8831 int res1 = 0 ;
8832 int val2 ;
8833 int ecode2 = 0 ;
8834 int val3 ;
8835 int ecode3 = 0 ;
8836 PyObject * obj0 = 0 ;
8837 PyObject * obj1 = 0 ;
8838 PyObject * obj2 = 0 ;
8839 char * kwnames[] = {
8840 (char *) "self",(char *) "width",(char *) "height", NULL
8841 };
8842
8843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8845 if (!SWIG_IsOK(res1)) {
8846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8847 }
8848 arg1 = reinterpret_cast< wxCaret * >(argp1);
8849 ecode2 = SWIG_AsVal_int(obj1, &val2);
8850 if (!SWIG_IsOK(ecode2)) {
8851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8852 }
8853 arg2 = static_cast< int >(val2);
8854 ecode3 = SWIG_AsVal_int(obj2, &val3);
8855 if (!SWIG_IsOK(ecode3)) {
8856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8857 }
8858 arg3 = static_cast< int >(val3);
8859 {
8860 PyThreadState* __tstate = wxPyBeginAllowThreads();
8861 (arg1)->SetSize(arg2,arg3);
8862 wxPyEndAllowThreads(__tstate);
8863 if (PyErr_Occurred()) SWIG_fail;
8864 }
8865 resultobj = SWIG_Py_Void();
8866 return resultobj;
8867 fail:
8868 return NULL;
8869 }
8870
8871
8872 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8873 PyObject *resultobj = 0;
8874 wxCaret *arg1 = (wxCaret *) 0 ;
8875 wxSize *arg2 = 0 ;
8876 void *argp1 = 0 ;
8877 int res1 = 0 ;
8878 wxSize temp2 ;
8879 PyObject * obj0 = 0 ;
8880 PyObject * obj1 = 0 ;
8881 char * kwnames[] = {
8882 (char *) "self",(char *) "size", NULL
8883 };
8884
8885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8887 if (!SWIG_IsOK(res1)) {
8888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8889 }
8890 arg1 = reinterpret_cast< wxCaret * >(argp1);
8891 {
8892 arg2 = &temp2;
8893 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8894 }
8895 {
8896 PyThreadState* __tstate = wxPyBeginAllowThreads();
8897 (arg1)->SetSize((wxSize const &)*arg2);
8898 wxPyEndAllowThreads(__tstate);
8899 if (PyErr_Occurred()) SWIG_fail;
8900 }
8901 resultobj = SWIG_Py_Void();
8902 return resultobj;
8903 fail:
8904 return NULL;
8905 }
8906
8907
8908 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8909 PyObject *resultobj = 0;
8910 wxCaret *arg1 = (wxCaret *) 0 ;
8911 int arg2 = (int) true ;
8912 void *argp1 = 0 ;
8913 int res1 = 0 ;
8914 int val2 ;
8915 int ecode2 = 0 ;
8916 PyObject * obj0 = 0 ;
8917 PyObject * obj1 = 0 ;
8918 char * kwnames[] = {
8919 (char *) "self",(char *) "show", NULL
8920 };
8921
8922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8924 if (!SWIG_IsOK(res1)) {
8925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8926 }
8927 arg1 = reinterpret_cast< wxCaret * >(argp1);
8928 if (obj1) {
8929 ecode2 = SWIG_AsVal_int(obj1, &val2);
8930 if (!SWIG_IsOK(ecode2)) {
8931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8932 }
8933 arg2 = static_cast< int >(val2);
8934 }
8935 {
8936 PyThreadState* __tstate = wxPyBeginAllowThreads();
8937 (arg1)->Show(arg2);
8938 wxPyEndAllowThreads(__tstate);
8939 if (PyErr_Occurred()) SWIG_fail;
8940 }
8941 resultobj = SWIG_Py_Void();
8942 return resultobj;
8943 fail:
8944 return NULL;
8945 }
8946
8947
8948 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8949 PyObject *resultobj = 0;
8950 wxCaret *arg1 = (wxCaret *) 0 ;
8951 void *argp1 = 0 ;
8952 int res1 = 0 ;
8953 PyObject *swig_obj[1] ;
8954
8955 if (!args) SWIG_fail;
8956 swig_obj[0] = args;
8957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8958 if (!SWIG_IsOK(res1)) {
8959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8960 }
8961 arg1 = reinterpret_cast< wxCaret * >(argp1);
8962 {
8963 PyThreadState* __tstate = wxPyBeginAllowThreads();
8964 (arg1)->Hide();
8965 wxPyEndAllowThreads(__tstate);
8966 if (PyErr_Occurred()) SWIG_fail;
8967 }
8968 resultobj = SWIG_Py_Void();
8969 return resultobj;
8970 fail:
8971 return NULL;
8972 }
8973
8974
8975 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8976 PyObject *resultobj = 0;
8977 int result;
8978
8979 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8980 {
8981 PyThreadState* __tstate = wxPyBeginAllowThreads();
8982 result = (int)wxCaret::GetBlinkTime();
8983 wxPyEndAllowThreads(__tstate);
8984 if (PyErr_Occurred()) SWIG_fail;
8985 }
8986 resultobj = SWIG_From_int(static_cast< int >(result));
8987 return resultobj;
8988 fail:
8989 return NULL;
8990 }
8991
8992
8993 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8994 PyObject *resultobj = 0;
8995 int arg1 ;
8996 int val1 ;
8997 int ecode1 = 0 ;
8998 PyObject * obj0 = 0 ;
8999 char * kwnames[] = {
9000 (char *) "milliseconds", NULL
9001 };
9002
9003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9004 ecode1 = SWIG_AsVal_int(obj0, &val1);
9005 if (!SWIG_IsOK(ecode1)) {
9006 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9007 }
9008 arg1 = static_cast< int >(val1);
9009 {
9010 PyThreadState* __tstate = wxPyBeginAllowThreads();
9011 wxCaret::SetBlinkTime(arg1);
9012 wxPyEndAllowThreads(__tstate);
9013 if (PyErr_Occurred()) SWIG_fail;
9014 }
9015 resultobj = SWIG_Py_Void();
9016 return resultobj;
9017 fail:
9018 return NULL;
9019 }
9020
9021
9022 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9023 PyObject *obj;
9024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9025 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9026 return SWIG_Py_Void();
9027 }
9028
9029 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9030 return SWIG_Python_InitShadowInstance(args);
9031 }
9032
9033 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9034 PyObject *resultobj = 0;
9035 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9036 wxBusyCursor *result = 0 ;
9037 void *argp1 = 0 ;
9038 int res1 = 0 ;
9039 PyObject * obj0 = 0 ;
9040 char * kwnames[] = {
9041 (char *) "cursor", NULL
9042 };
9043
9044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9045 if (obj0) {
9046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9047 if (!SWIG_IsOK(res1)) {
9048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9049 }
9050 arg1 = reinterpret_cast< wxCursor * >(argp1);
9051 }
9052 {
9053 if (!wxPyCheckForApp()) SWIG_fail;
9054 PyThreadState* __tstate = wxPyBeginAllowThreads();
9055 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9056 wxPyEndAllowThreads(__tstate);
9057 if (PyErr_Occurred()) SWIG_fail;
9058 }
9059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9060 return resultobj;
9061 fail:
9062 return NULL;
9063 }
9064
9065
9066 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9067 PyObject *resultobj = 0;
9068 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9069 void *argp1 = 0 ;
9070 int res1 = 0 ;
9071 PyObject *swig_obj[1] ;
9072
9073 if (!args) SWIG_fail;
9074 swig_obj[0] = args;
9075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9076 if (!SWIG_IsOK(res1)) {
9077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9078 }
9079 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9080 {
9081 PyThreadState* __tstate = wxPyBeginAllowThreads();
9082 delete arg1;
9083
9084 wxPyEndAllowThreads(__tstate);
9085 if (PyErr_Occurred()) SWIG_fail;
9086 }
9087 resultobj = SWIG_Py_Void();
9088 return resultobj;
9089 fail:
9090 return NULL;
9091 }
9092
9093
9094 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9095 PyObject *obj;
9096 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9097 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9098 return SWIG_Py_Void();
9099 }
9100
9101 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9102 return SWIG_Python_InitShadowInstance(args);
9103 }
9104
9105 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9106 PyObject *resultobj = 0;
9107 wxWindow *arg1 = (wxWindow *) NULL ;
9108 wxWindowDisabler *result = 0 ;
9109 void *argp1 = 0 ;
9110 int res1 = 0 ;
9111 PyObject * obj0 = 0 ;
9112 char * kwnames[] = {
9113 (char *) "winToSkip", NULL
9114 };
9115
9116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9117 if (obj0) {
9118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9119 if (!SWIG_IsOK(res1)) {
9120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9121 }
9122 arg1 = reinterpret_cast< wxWindow * >(argp1);
9123 }
9124 {
9125 if (!wxPyCheckForApp()) SWIG_fail;
9126 PyThreadState* __tstate = wxPyBeginAllowThreads();
9127 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9128 wxPyEndAllowThreads(__tstate);
9129 if (PyErr_Occurred()) SWIG_fail;
9130 }
9131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9132 return resultobj;
9133 fail:
9134 return NULL;
9135 }
9136
9137
9138 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9139 PyObject *resultobj = 0;
9140 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9141 void *argp1 = 0 ;
9142 int res1 = 0 ;
9143 PyObject *swig_obj[1] ;
9144
9145 if (!args) SWIG_fail;
9146 swig_obj[0] = args;
9147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9148 if (!SWIG_IsOK(res1)) {
9149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9150 }
9151 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9152 {
9153 PyThreadState* __tstate = wxPyBeginAllowThreads();
9154 delete arg1;
9155
9156 wxPyEndAllowThreads(__tstate);
9157 if (PyErr_Occurred()) SWIG_fail;
9158 }
9159 resultobj = SWIG_Py_Void();
9160 return resultobj;
9161 fail:
9162 return NULL;
9163 }
9164
9165
9166 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9167 PyObject *obj;
9168 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9169 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9170 return SWIG_Py_Void();
9171 }
9172
9173 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9174 return SWIG_Python_InitShadowInstance(args);
9175 }
9176
9177 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9178 PyObject *resultobj = 0;
9179 wxString *arg1 = 0 ;
9180 wxBusyInfo *result = 0 ;
9181 bool temp1 = false ;
9182 PyObject * obj0 = 0 ;
9183 char * kwnames[] = {
9184 (char *) "message", NULL
9185 };
9186
9187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9188 {
9189 arg1 = wxString_in_helper(obj0);
9190 if (arg1 == NULL) SWIG_fail;
9191 temp1 = true;
9192 }
9193 {
9194 if (!wxPyCheckForApp()) SWIG_fail;
9195 PyThreadState* __tstate = wxPyBeginAllowThreads();
9196 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9197 wxPyEndAllowThreads(__tstate);
9198 if (PyErr_Occurred()) SWIG_fail;
9199 }
9200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9201 {
9202 if (temp1)
9203 delete arg1;
9204 }
9205 return resultobj;
9206 fail:
9207 {
9208 if (temp1)
9209 delete arg1;
9210 }
9211 return NULL;
9212 }
9213
9214
9215 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9216 PyObject *resultobj = 0;
9217 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9218 void *argp1 = 0 ;
9219 int res1 = 0 ;
9220 PyObject *swig_obj[1] ;
9221
9222 if (!args) SWIG_fail;
9223 swig_obj[0] = args;
9224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9225 if (!SWIG_IsOK(res1)) {
9226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9227 }
9228 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 delete arg1;
9232
9233 wxPyEndAllowThreads(__tstate);
9234 if (PyErr_Occurred()) SWIG_fail;
9235 }
9236 resultobj = SWIG_Py_Void();
9237 return resultobj;
9238 fail:
9239 return NULL;
9240 }
9241
9242
9243 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9244 PyObject *obj;
9245 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9246 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9247 return SWIG_Py_Void();
9248 }
9249
9250 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9251 return SWIG_Python_InitShadowInstance(args);
9252 }
9253
9254 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9255 PyObject *resultobj = 0;
9256 wxStopWatch *result = 0 ;
9257
9258 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9259 {
9260 PyThreadState* __tstate = wxPyBeginAllowThreads();
9261 result = (wxStopWatch *)new wxStopWatch();
9262 wxPyEndAllowThreads(__tstate);
9263 if (PyErr_Occurred()) SWIG_fail;
9264 }
9265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9266 return resultobj;
9267 fail:
9268 return NULL;
9269 }
9270
9271
9272 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9273 PyObject *resultobj = 0;
9274 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9275 long arg2 = (long) 0 ;
9276 void *argp1 = 0 ;
9277 int res1 = 0 ;
9278 long val2 ;
9279 int ecode2 = 0 ;
9280 PyObject * obj0 = 0 ;
9281 PyObject * obj1 = 0 ;
9282 char * kwnames[] = {
9283 (char *) "self",(char *) "t0", NULL
9284 };
9285
9286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9288 if (!SWIG_IsOK(res1)) {
9289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9290 }
9291 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9292 if (obj1) {
9293 ecode2 = SWIG_AsVal_long(obj1, &val2);
9294 if (!SWIG_IsOK(ecode2)) {
9295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9296 }
9297 arg2 = static_cast< long >(val2);
9298 }
9299 {
9300 PyThreadState* __tstate = wxPyBeginAllowThreads();
9301 (arg1)->Start(arg2);
9302 wxPyEndAllowThreads(__tstate);
9303 if (PyErr_Occurred()) SWIG_fail;
9304 }
9305 resultobj = SWIG_Py_Void();
9306 return resultobj;
9307 fail:
9308 return NULL;
9309 }
9310
9311
9312 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9313 PyObject *resultobj = 0;
9314 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9315 void *argp1 = 0 ;
9316 int res1 = 0 ;
9317 PyObject *swig_obj[1] ;
9318
9319 if (!args) SWIG_fail;
9320 swig_obj[0] = args;
9321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9322 if (!SWIG_IsOK(res1)) {
9323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9324 }
9325 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9326 {
9327 PyThreadState* __tstate = wxPyBeginAllowThreads();
9328 (arg1)->Pause();
9329 wxPyEndAllowThreads(__tstate);
9330 if (PyErr_Occurred()) SWIG_fail;
9331 }
9332 resultobj = SWIG_Py_Void();
9333 return resultobj;
9334 fail:
9335 return NULL;
9336 }
9337
9338
9339 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9340 PyObject *resultobj = 0;
9341 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9342 void *argp1 = 0 ;
9343 int res1 = 0 ;
9344 PyObject *swig_obj[1] ;
9345
9346 if (!args) SWIG_fail;
9347 swig_obj[0] = args;
9348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9349 if (!SWIG_IsOK(res1)) {
9350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9351 }
9352 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9353 {
9354 PyThreadState* __tstate = wxPyBeginAllowThreads();
9355 (arg1)->Resume();
9356 wxPyEndAllowThreads(__tstate);
9357 if (PyErr_Occurred()) SWIG_fail;
9358 }
9359 resultobj = SWIG_Py_Void();
9360 return resultobj;
9361 fail:
9362 return NULL;
9363 }
9364
9365
9366 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9367 PyObject *resultobj = 0;
9368 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9369 long result;
9370 void *argp1 = 0 ;
9371 int res1 = 0 ;
9372 PyObject *swig_obj[1] ;
9373
9374 if (!args) SWIG_fail;
9375 swig_obj[0] = args;
9376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9377 if (!SWIG_IsOK(res1)) {
9378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9379 }
9380 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9381 {
9382 PyThreadState* __tstate = wxPyBeginAllowThreads();
9383 result = (long)((wxStopWatch const *)arg1)->Time();
9384 wxPyEndAllowThreads(__tstate);
9385 if (PyErr_Occurred()) SWIG_fail;
9386 }
9387 resultobj = SWIG_From_long(static_cast< long >(result));
9388 return resultobj;
9389 fail:
9390 return NULL;
9391 }
9392
9393
9394 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9395 PyObject *obj;
9396 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9397 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9398 return SWIG_Py_Void();
9399 }
9400
9401 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9402 return SWIG_Python_InitShadowInstance(args);
9403 }
9404
9405 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9406 PyObject *resultobj = 0;
9407 int arg1 = (int) 9 ;
9408 int arg2 = (int) wxID_FILE1 ;
9409 wxFileHistory *result = 0 ;
9410 int val1 ;
9411 int ecode1 = 0 ;
9412 int val2 ;
9413 int ecode2 = 0 ;
9414 PyObject * obj0 = 0 ;
9415 PyObject * obj1 = 0 ;
9416 char * kwnames[] = {
9417 (char *) "maxFiles",(char *) "idBase", NULL
9418 };
9419
9420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9421 if (obj0) {
9422 ecode1 = SWIG_AsVal_int(obj0, &val1);
9423 if (!SWIG_IsOK(ecode1)) {
9424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9425 }
9426 arg1 = static_cast< int >(val1);
9427 }
9428 if (obj1) {
9429 ecode2 = SWIG_AsVal_int(obj1, &val2);
9430 if (!SWIG_IsOK(ecode2)) {
9431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9432 }
9433 arg2 = static_cast< int >(val2);
9434 }
9435 {
9436 PyThreadState* __tstate = wxPyBeginAllowThreads();
9437 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9438 wxPyEndAllowThreads(__tstate);
9439 if (PyErr_Occurred()) SWIG_fail;
9440 }
9441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9442 return resultobj;
9443 fail:
9444 return NULL;
9445 }
9446
9447
9448 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9449 PyObject *resultobj = 0;
9450 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9451 void *argp1 = 0 ;
9452 int res1 = 0 ;
9453 PyObject *swig_obj[1] ;
9454
9455 if (!args) SWIG_fail;
9456 swig_obj[0] = args;
9457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9458 if (!SWIG_IsOK(res1)) {
9459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9460 }
9461 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9462 {
9463 PyThreadState* __tstate = wxPyBeginAllowThreads();
9464 delete arg1;
9465
9466 wxPyEndAllowThreads(__tstate);
9467 if (PyErr_Occurred()) SWIG_fail;
9468 }
9469 resultobj = SWIG_Py_Void();
9470 return resultobj;
9471 fail:
9472 return NULL;
9473 }
9474
9475
9476 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9477 PyObject *resultobj = 0;
9478 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9479 wxString *arg2 = 0 ;
9480 void *argp1 = 0 ;
9481 int res1 = 0 ;
9482 bool temp2 = false ;
9483 PyObject * obj0 = 0 ;
9484 PyObject * obj1 = 0 ;
9485 char * kwnames[] = {
9486 (char *) "self",(char *) "file", NULL
9487 };
9488
9489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9491 if (!SWIG_IsOK(res1)) {
9492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9493 }
9494 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9495 {
9496 arg2 = wxString_in_helper(obj1);
9497 if (arg2 == NULL) SWIG_fail;
9498 temp2 = true;
9499 }
9500 {
9501 PyThreadState* __tstate = wxPyBeginAllowThreads();
9502 (arg1)->AddFileToHistory((wxString const &)*arg2);
9503 wxPyEndAllowThreads(__tstate);
9504 if (PyErr_Occurred()) SWIG_fail;
9505 }
9506 resultobj = SWIG_Py_Void();
9507 {
9508 if (temp2)
9509 delete arg2;
9510 }
9511 return resultobj;
9512 fail:
9513 {
9514 if (temp2)
9515 delete arg2;
9516 }
9517 return NULL;
9518 }
9519
9520
9521 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9522 PyObject *resultobj = 0;
9523 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9524 int arg2 ;
9525 void *argp1 = 0 ;
9526 int res1 = 0 ;
9527 int val2 ;
9528 int ecode2 = 0 ;
9529 PyObject * obj0 = 0 ;
9530 PyObject * obj1 = 0 ;
9531 char * kwnames[] = {
9532 (char *) "self",(char *) "i", NULL
9533 };
9534
9535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9537 if (!SWIG_IsOK(res1)) {
9538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9539 }
9540 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9541 ecode2 = SWIG_AsVal_int(obj1, &val2);
9542 if (!SWIG_IsOK(ecode2)) {
9543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9544 }
9545 arg2 = static_cast< int >(val2);
9546 {
9547 PyThreadState* __tstate = wxPyBeginAllowThreads();
9548 (arg1)->RemoveFileFromHistory(arg2);
9549 wxPyEndAllowThreads(__tstate);
9550 if (PyErr_Occurred()) SWIG_fail;
9551 }
9552 resultobj = SWIG_Py_Void();
9553 return resultobj;
9554 fail:
9555 return NULL;
9556 }
9557
9558
9559 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9560 PyObject *resultobj = 0;
9561 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9562 int result;
9563 void *argp1 = 0 ;
9564 int res1 = 0 ;
9565 PyObject *swig_obj[1] ;
9566
9567 if (!args) SWIG_fail;
9568 swig_obj[0] = args;
9569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9570 if (!SWIG_IsOK(res1)) {
9571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9572 }
9573 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9574 {
9575 PyThreadState* __tstate = wxPyBeginAllowThreads();
9576 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9577 wxPyEndAllowThreads(__tstate);
9578 if (PyErr_Occurred()) SWIG_fail;
9579 }
9580 resultobj = SWIG_From_int(static_cast< int >(result));
9581 return resultobj;
9582 fail:
9583 return NULL;
9584 }
9585
9586
9587 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9588 PyObject *resultobj = 0;
9589 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9590 wxMenu *arg2 = (wxMenu *) 0 ;
9591 void *argp1 = 0 ;
9592 int res1 = 0 ;
9593 void *argp2 = 0 ;
9594 int res2 = 0 ;
9595 PyObject * obj0 = 0 ;
9596 PyObject * obj1 = 0 ;
9597 char * kwnames[] = {
9598 (char *) "self",(char *) "menu", NULL
9599 };
9600
9601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9603 if (!SWIG_IsOK(res1)) {
9604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9605 }
9606 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9608 if (!SWIG_IsOK(res2)) {
9609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9610 }
9611 arg2 = reinterpret_cast< wxMenu * >(argp2);
9612 {
9613 PyThreadState* __tstate = wxPyBeginAllowThreads();
9614 (arg1)->UseMenu(arg2);
9615 wxPyEndAllowThreads(__tstate);
9616 if (PyErr_Occurred()) SWIG_fail;
9617 }
9618 resultobj = SWIG_Py_Void();
9619 return resultobj;
9620 fail:
9621 return NULL;
9622 }
9623
9624
9625 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9626 PyObject *resultobj = 0;
9627 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9628 wxMenu *arg2 = (wxMenu *) 0 ;
9629 void *argp1 = 0 ;
9630 int res1 = 0 ;
9631 void *argp2 = 0 ;
9632 int res2 = 0 ;
9633 PyObject * obj0 = 0 ;
9634 PyObject * obj1 = 0 ;
9635 char * kwnames[] = {
9636 (char *) "self",(char *) "menu", NULL
9637 };
9638
9639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9641 if (!SWIG_IsOK(res1)) {
9642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9643 }
9644 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9645 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9646 if (!SWIG_IsOK(res2)) {
9647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9648 }
9649 arg2 = reinterpret_cast< wxMenu * >(argp2);
9650 {
9651 PyThreadState* __tstate = wxPyBeginAllowThreads();
9652 (arg1)->RemoveMenu(arg2);
9653 wxPyEndAllowThreads(__tstate);
9654 if (PyErr_Occurred()) SWIG_fail;
9655 }
9656 resultobj = SWIG_Py_Void();
9657 return resultobj;
9658 fail:
9659 return NULL;
9660 }
9661
9662
9663 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9664 PyObject *resultobj = 0;
9665 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9666 wxConfigBase *arg2 = 0 ;
9667 void *argp1 = 0 ;
9668 int res1 = 0 ;
9669 void *argp2 = 0 ;
9670 int res2 = 0 ;
9671 PyObject * obj0 = 0 ;
9672 PyObject * obj1 = 0 ;
9673 char * kwnames[] = {
9674 (char *) "self",(char *) "config", NULL
9675 };
9676
9677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9679 if (!SWIG_IsOK(res1)) {
9680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9681 }
9682 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9683 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9684 if (!SWIG_IsOK(res2)) {
9685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9686 }
9687 if (!argp2) {
9688 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9689 }
9690 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9691 {
9692 PyThreadState* __tstate = wxPyBeginAllowThreads();
9693 (arg1)->Load(*arg2);
9694 wxPyEndAllowThreads(__tstate);
9695 if (PyErr_Occurred()) SWIG_fail;
9696 }
9697 resultobj = SWIG_Py_Void();
9698 return resultobj;
9699 fail:
9700 return NULL;
9701 }
9702
9703
9704 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9705 PyObject *resultobj = 0;
9706 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9707 wxConfigBase *arg2 = 0 ;
9708 void *argp1 = 0 ;
9709 int res1 = 0 ;
9710 void *argp2 = 0 ;
9711 int res2 = 0 ;
9712 PyObject * obj0 = 0 ;
9713 PyObject * obj1 = 0 ;
9714 char * kwnames[] = {
9715 (char *) "self",(char *) "config", NULL
9716 };
9717
9718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9720 if (!SWIG_IsOK(res1)) {
9721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9722 }
9723 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9724 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9725 if (!SWIG_IsOK(res2)) {
9726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9727 }
9728 if (!argp2) {
9729 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9730 }
9731 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9732 {
9733 PyThreadState* __tstate = wxPyBeginAllowThreads();
9734 (arg1)->Save(*arg2);
9735 wxPyEndAllowThreads(__tstate);
9736 if (PyErr_Occurred()) SWIG_fail;
9737 }
9738 resultobj = SWIG_Py_Void();
9739 return resultobj;
9740 fail:
9741 return NULL;
9742 }
9743
9744
9745 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9746 PyObject *resultobj = 0;
9747 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9748 void *argp1 = 0 ;
9749 int res1 = 0 ;
9750 PyObject *swig_obj[1] ;
9751
9752 if (!args) SWIG_fail;
9753 swig_obj[0] = args;
9754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9755 if (!SWIG_IsOK(res1)) {
9756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9757 }
9758 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9759 {
9760 PyThreadState* __tstate = wxPyBeginAllowThreads();
9761 (arg1)->AddFilesToMenu();
9762 wxPyEndAllowThreads(__tstate);
9763 if (PyErr_Occurred()) SWIG_fail;
9764 }
9765 resultobj = SWIG_Py_Void();
9766 return resultobj;
9767 fail:
9768 return NULL;
9769 }
9770
9771
9772 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9773 PyObject *resultobj = 0;
9774 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9775 wxMenu *arg2 = (wxMenu *) 0 ;
9776 void *argp1 = 0 ;
9777 int res1 = 0 ;
9778 void *argp2 = 0 ;
9779 int res2 = 0 ;
9780 PyObject * obj0 = 0 ;
9781 PyObject * obj1 = 0 ;
9782 char * kwnames[] = {
9783 (char *) "self",(char *) "menu", NULL
9784 };
9785
9786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9788 if (!SWIG_IsOK(res1)) {
9789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9790 }
9791 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9792 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9793 if (!SWIG_IsOK(res2)) {
9794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9795 }
9796 arg2 = reinterpret_cast< wxMenu * >(argp2);
9797 {
9798 PyThreadState* __tstate = wxPyBeginAllowThreads();
9799 (arg1)->AddFilesToMenu(arg2);
9800 wxPyEndAllowThreads(__tstate);
9801 if (PyErr_Occurred()) SWIG_fail;
9802 }
9803 resultobj = SWIG_Py_Void();
9804 return resultobj;
9805 fail:
9806 return NULL;
9807 }
9808
9809
9810 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9811 PyObject *resultobj = 0;
9812 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9813 int arg2 ;
9814 wxString result;
9815 void *argp1 = 0 ;
9816 int res1 = 0 ;
9817 int val2 ;
9818 int ecode2 = 0 ;
9819 PyObject * obj0 = 0 ;
9820 PyObject * obj1 = 0 ;
9821 char * kwnames[] = {
9822 (char *) "self",(char *) "i", NULL
9823 };
9824
9825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9827 if (!SWIG_IsOK(res1)) {
9828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9829 }
9830 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9831 ecode2 = SWIG_AsVal_int(obj1, &val2);
9832 if (!SWIG_IsOK(ecode2)) {
9833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9834 }
9835 arg2 = static_cast< int >(val2);
9836 {
9837 PyThreadState* __tstate = wxPyBeginAllowThreads();
9838 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9839 wxPyEndAllowThreads(__tstate);
9840 if (PyErr_Occurred()) SWIG_fail;
9841 }
9842 {
9843 #if wxUSE_UNICODE
9844 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9845 #else
9846 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9847 #endif
9848 }
9849 return resultobj;
9850 fail:
9851 return NULL;
9852 }
9853
9854
9855 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9856 PyObject *resultobj = 0;
9857 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9858 int result;
9859 void *argp1 = 0 ;
9860 int res1 = 0 ;
9861 PyObject *swig_obj[1] ;
9862
9863 if (!args) SWIG_fail;
9864 swig_obj[0] = args;
9865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9866 if (!SWIG_IsOK(res1)) {
9867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9868 }
9869 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9870 {
9871 PyThreadState* __tstate = wxPyBeginAllowThreads();
9872 result = (int)((wxFileHistory const *)arg1)->GetCount();
9873 wxPyEndAllowThreads(__tstate);
9874 if (PyErr_Occurred()) SWIG_fail;
9875 }
9876 resultobj = SWIG_From_int(static_cast< int >(result));
9877 return resultobj;
9878 fail:
9879 return NULL;
9880 }
9881
9882
9883 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9884 PyObject *obj;
9885 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9886 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9887 return SWIG_Py_Void();
9888 }
9889
9890 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9891 return SWIG_Python_InitShadowInstance(args);
9892 }
9893
9894 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9895 PyObject *resultobj = 0;
9896 wxString *arg1 = 0 ;
9897 wxString const &arg2_defvalue = wxPyEmptyString ;
9898 wxString *arg2 = (wxString *) &arg2_defvalue ;
9899 wxSingleInstanceChecker *result = 0 ;
9900 bool temp1 = false ;
9901 bool temp2 = false ;
9902 PyObject * obj0 = 0 ;
9903 PyObject * obj1 = 0 ;
9904 char * kwnames[] = {
9905 (char *) "name",(char *) "path", NULL
9906 };
9907
9908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9909 {
9910 arg1 = wxString_in_helper(obj0);
9911 if (arg1 == NULL) SWIG_fail;
9912 temp1 = true;
9913 }
9914 if (obj1) {
9915 {
9916 arg2 = wxString_in_helper(obj1);
9917 if (arg2 == NULL) SWIG_fail;
9918 temp2 = true;
9919 }
9920 }
9921 {
9922 PyThreadState* __tstate = wxPyBeginAllowThreads();
9923 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9924 wxPyEndAllowThreads(__tstate);
9925 if (PyErr_Occurred()) SWIG_fail;
9926 }
9927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9928 {
9929 if (temp1)
9930 delete arg1;
9931 }
9932 {
9933 if (temp2)
9934 delete arg2;
9935 }
9936 return resultobj;
9937 fail:
9938 {
9939 if (temp1)
9940 delete arg1;
9941 }
9942 {
9943 if (temp2)
9944 delete arg2;
9945 }
9946 return NULL;
9947 }
9948
9949
9950 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9951 PyObject *resultobj = 0;
9952 wxSingleInstanceChecker *result = 0 ;
9953
9954 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9955 {
9956 PyThreadState* __tstate = wxPyBeginAllowThreads();
9957 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9958 wxPyEndAllowThreads(__tstate);
9959 if (PyErr_Occurred()) SWIG_fail;
9960 }
9961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9962 return resultobj;
9963 fail:
9964 return NULL;
9965 }
9966
9967
9968 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9969 PyObject *resultobj = 0;
9970 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9971 void *argp1 = 0 ;
9972 int res1 = 0 ;
9973 PyObject *swig_obj[1] ;
9974
9975 if (!args) SWIG_fail;
9976 swig_obj[0] = args;
9977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9978 if (!SWIG_IsOK(res1)) {
9979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9980 }
9981 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9982 {
9983 PyThreadState* __tstate = wxPyBeginAllowThreads();
9984 delete arg1;
9985
9986 wxPyEndAllowThreads(__tstate);
9987 if (PyErr_Occurred()) SWIG_fail;
9988 }
9989 resultobj = SWIG_Py_Void();
9990 return resultobj;
9991 fail:
9992 return NULL;
9993 }
9994
9995
9996 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9997 PyObject *resultobj = 0;
9998 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9999 wxString *arg2 = 0 ;
10000 wxString const &arg3_defvalue = wxPyEmptyString ;
10001 wxString *arg3 = (wxString *) &arg3_defvalue ;
10002 bool result;
10003 void *argp1 = 0 ;
10004 int res1 = 0 ;
10005 bool temp2 = false ;
10006 bool temp3 = false ;
10007 PyObject * obj0 = 0 ;
10008 PyObject * obj1 = 0 ;
10009 PyObject * obj2 = 0 ;
10010 char * kwnames[] = {
10011 (char *) "self",(char *) "name",(char *) "path", NULL
10012 };
10013
10014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10016 if (!SWIG_IsOK(res1)) {
10017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10018 }
10019 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10020 {
10021 arg2 = wxString_in_helper(obj1);
10022 if (arg2 == NULL) SWIG_fail;
10023 temp2 = true;
10024 }
10025 if (obj2) {
10026 {
10027 arg3 = wxString_in_helper(obj2);
10028 if (arg3 == NULL) SWIG_fail;
10029 temp3 = true;
10030 }
10031 }
10032 {
10033 PyThreadState* __tstate = wxPyBeginAllowThreads();
10034 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10035 wxPyEndAllowThreads(__tstate);
10036 if (PyErr_Occurred()) SWIG_fail;
10037 }
10038 {
10039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10040 }
10041 {
10042 if (temp2)
10043 delete arg2;
10044 }
10045 {
10046 if (temp3)
10047 delete arg3;
10048 }
10049 return resultobj;
10050 fail:
10051 {
10052 if (temp2)
10053 delete arg2;
10054 }
10055 {
10056 if (temp3)
10057 delete arg3;
10058 }
10059 return NULL;
10060 }
10061
10062
10063 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10064 PyObject *resultobj = 0;
10065 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10066 bool result;
10067 void *argp1 = 0 ;
10068 int res1 = 0 ;
10069 PyObject *swig_obj[1] ;
10070
10071 if (!args) SWIG_fail;
10072 swig_obj[0] = args;
10073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10074 if (!SWIG_IsOK(res1)) {
10075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10076 }
10077 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10078 {
10079 PyThreadState* __tstate = wxPyBeginAllowThreads();
10080 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10081 wxPyEndAllowThreads(__tstate);
10082 if (PyErr_Occurred()) SWIG_fail;
10083 }
10084 {
10085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10086 }
10087 return resultobj;
10088 fail:
10089 return NULL;
10090 }
10091
10092
10093 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10094 PyObject *obj;
10095 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10096 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10097 return SWIG_Py_Void();
10098 }
10099
10100 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10101 return SWIG_Python_InitShadowInstance(args);
10102 }
10103
10104 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10105 PyObject *resultobj = 0;
10106 wxPlatformInfo *result = 0 ;
10107
10108 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10109 {
10110 PyThreadState* __tstate = wxPyBeginAllowThreads();
10111 result = (wxPlatformInfo *)new wxPlatformInfo();
10112 wxPyEndAllowThreads(__tstate);
10113 if (PyErr_Occurred()) SWIG_fail;
10114 }
10115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10116 return resultobj;
10117 fail:
10118 return NULL;
10119 }
10120
10121
10122 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10123 PyObject *resultobj = 0;
10124 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10125 wxPlatformInfo *arg2 = 0 ;
10126 bool result;
10127 void *argp1 = 0 ;
10128 int res1 = 0 ;
10129 void *argp2 = 0 ;
10130 int res2 = 0 ;
10131 PyObject * obj0 = 0 ;
10132 PyObject * obj1 = 0 ;
10133 char * kwnames[] = {
10134 (char *) "self",(char *) "t", NULL
10135 };
10136
10137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10139 if (!SWIG_IsOK(res1)) {
10140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10141 }
10142 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10143 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10144 if (!SWIG_IsOK(res2)) {
10145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10146 }
10147 if (!argp2) {
10148 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10149 }
10150 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10151 {
10152 PyThreadState* __tstate = wxPyBeginAllowThreads();
10153 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10154 wxPyEndAllowThreads(__tstate);
10155 if (PyErr_Occurred()) SWIG_fail;
10156 }
10157 {
10158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10159 }
10160 return resultobj;
10161 fail:
10162 return NULL;
10163 }
10164
10165
10166 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10167 PyObject *resultobj = 0;
10168 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10169 wxPlatformInfo *arg2 = 0 ;
10170 bool result;
10171 void *argp1 = 0 ;
10172 int res1 = 0 ;
10173 void *argp2 = 0 ;
10174 int res2 = 0 ;
10175 PyObject * obj0 = 0 ;
10176 PyObject * obj1 = 0 ;
10177 char * kwnames[] = {
10178 (char *) "self",(char *) "t", NULL
10179 };
10180
10181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10183 if (!SWIG_IsOK(res1)) {
10184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10185 }
10186 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10187 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10188 if (!SWIG_IsOK(res2)) {
10189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10190 }
10191 if (!argp2) {
10192 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10193 }
10194 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10195 {
10196 PyThreadState* __tstate = wxPyBeginAllowThreads();
10197 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10198 wxPyEndAllowThreads(__tstate);
10199 if (PyErr_Occurred()) SWIG_fail;
10200 }
10201 {
10202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10203 }
10204 return resultobj;
10205 fail:
10206 return NULL;
10207 }
10208
10209
10210 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10211 PyObject *resultobj = 0;
10212 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10213 int result;
10214 void *argp1 = 0 ;
10215 int res1 = 0 ;
10216 PyObject *swig_obj[1] ;
10217
10218 if (!args) SWIG_fail;
10219 swig_obj[0] = args;
10220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10221 if (!SWIG_IsOK(res1)) {
10222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10223 }
10224 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10225 {
10226 PyThreadState* __tstate = wxPyBeginAllowThreads();
10227 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10228 wxPyEndAllowThreads(__tstate);
10229 if (PyErr_Occurred()) SWIG_fail;
10230 }
10231 resultobj = SWIG_From_int(static_cast< int >(result));
10232 return resultobj;
10233 fail:
10234 return NULL;
10235 }
10236
10237
10238 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10239 PyObject *resultobj = 0;
10240 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10241 int result;
10242 void *argp1 = 0 ;
10243 int res1 = 0 ;
10244 PyObject *swig_obj[1] ;
10245
10246 if (!args) SWIG_fail;
10247 swig_obj[0] = args;
10248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10249 if (!SWIG_IsOK(res1)) {
10250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10251 }
10252 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10253 {
10254 PyThreadState* __tstate = wxPyBeginAllowThreads();
10255 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10256 wxPyEndAllowThreads(__tstate);
10257 if (PyErr_Occurred()) SWIG_fail;
10258 }
10259 resultobj = SWIG_From_int(static_cast< int >(result));
10260 return resultobj;
10261 fail:
10262 return NULL;
10263 }
10264
10265
10266 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10267 PyObject *resultobj = 0;
10268 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10269 int arg2 ;
10270 int arg3 ;
10271 bool result;
10272 void *argp1 = 0 ;
10273 int res1 = 0 ;
10274 int val2 ;
10275 int ecode2 = 0 ;
10276 int val3 ;
10277 int ecode3 = 0 ;
10278 PyObject * obj0 = 0 ;
10279 PyObject * obj1 = 0 ;
10280 PyObject * obj2 = 0 ;
10281 char * kwnames[] = {
10282 (char *) "self",(char *) "major",(char *) "minor", NULL
10283 };
10284
10285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10287 if (!SWIG_IsOK(res1)) {
10288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10289 }
10290 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10291 ecode2 = SWIG_AsVal_int(obj1, &val2);
10292 if (!SWIG_IsOK(ecode2)) {
10293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10294 }
10295 arg2 = static_cast< int >(val2);
10296 ecode3 = SWIG_AsVal_int(obj2, &val3);
10297 if (!SWIG_IsOK(ecode3)) {
10298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10299 }
10300 arg3 = static_cast< int >(val3);
10301 {
10302 PyThreadState* __tstate = wxPyBeginAllowThreads();
10303 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10304 wxPyEndAllowThreads(__tstate);
10305 if (PyErr_Occurred()) SWIG_fail;
10306 }
10307 {
10308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10309 }
10310 return resultobj;
10311 fail:
10312 return NULL;
10313 }
10314
10315
10316 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10317 PyObject *resultobj = 0;
10318 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10319 int result;
10320 void *argp1 = 0 ;
10321 int res1 = 0 ;
10322 PyObject *swig_obj[1] ;
10323
10324 if (!args) SWIG_fail;
10325 swig_obj[0] = args;
10326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10327 if (!SWIG_IsOK(res1)) {
10328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10329 }
10330 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10331 {
10332 PyThreadState* __tstate = wxPyBeginAllowThreads();
10333 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10334 wxPyEndAllowThreads(__tstate);
10335 if (PyErr_Occurred()) SWIG_fail;
10336 }
10337 resultobj = SWIG_From_int(static_cast< int >(result));
10338 return resultobj;
10339 fail:
10340 return NULL;
10341 }
10342
10343
10344 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10345 PyObject *resultobj = 0;
10346 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10347 int result;
10348 void *argp1 = 0 ;
10349 int res1 = 0 ;
10350 PyObject *swig_obj[1] ;
10351
10352 if (!args) SWIG_fail;
10353 swig_obj[0] = args;
10354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10355 if (!SWIG_IsOK(res1)) {
10356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10357 }
10358 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10359 {
10360 PyThreadState* __tstate = wxPyBeginAllowThreads();
10361 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10362 wxPyEndAllowThreads(__tstate);
10363 if (PyErr_Occurred()) SWIG_fail;
10364 }
10365 resultobj = SWIG_From_int(static_cast< int >(result));
10366 return resultobj;
10367 fail:
10368 return NULL;
10369 }
10370
10371
10372 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10373 PyObject *resultobj = 0;
10374 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10375 int arg2 ;
10376 int arg3 ;
10377 bool result;
10378 void *argp1 = 0 ;
10379 int res1 = 0 ;
10380 int val2 ;
10381 int ecode2 = 0 ;
10382 int val3 ;
10383 int ecode3 = 0 ;
10384 PyObject * obj0 = 0 ;
10385 PyObject * obj1 = 0 ;
10386 PyObject * obj2 = 0 ;
10387 char * kwnames[] = {
10388 (char *) "self",(char *) "major",(char *) "minor", NULL
10389 };
10390
10391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10393 if (!SWIG_IsOK(res1)) {
10394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10395 }
10396 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10397 ecode2 = SWIG_AsVal_int(obj1, &val2);
10398 if (!SWIG_IsOK(ecode2)) {
10399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10400 }
10401 arg2 = static_cast< int >(val2);
10402 ecode3 = SWIG_AsVal_int(obj2, &val3);
10403 if (!SWIG_IsOK(ecode3)) {
10404 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10405 }
10406 arg3 = static_cast< int >(val3);
10407 {
10408 PyThreadState* __tstate = wxPyBeginAllowThreads();
10409 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10410 wxPyEndAllowThreads(__tstate);
10411 if (PyErr_Occurred()) SWIG_fail;
10412 }
10413 {
10414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10415 }
10416 return resultobj;
10417 fail:
10418 return NULL;
10419 }
10420
10421
10422 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10423 PyObject *resultobj = 0;
10424 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10425 bool result;
10426 void *argp1 = 0 ;
10427 int res1 = 0 ;
10428 PyObject *swig_obj[1] ;
10429
10430 if (!args) SWIG_fail;
10431 swig_obj[0] = args;
10432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10433 if (!SWIG_IsOK(res1)) {
10434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10435 }
10436 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10437 {
10438 PyThreadState* __tstate = wxPyBeginAllowThreads();
10439 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10440 wxPyEndAllowThreads(__tstate);
10441 if (PyErr_Occurred()) SWIG_fail;
10442 }
10443 {
10444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10445 }
10446 return resultobj;
10447 fail:
10448 return NULL;
10449 }
10450
10451
10452 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10453 PyObject *resultobj = 0;
10454 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10455 wxOperatingSystemId result;
10456 void *argp1 = 0 ;
10457 int res1 = 0 ;
10458 PyObject *swig_obj[1] ;
10459
10460 if (!args) SWIG_fail;
10461 swig_obj[0] = args;
10462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10463 if (!SWIG_IsOK(res1)) {
10464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10465 }
10466 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10467 {
10468 PyThreadState* __tstate = wxPyBeginAllowThreads();
10469 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10470 wxPyEndAllowThreads(__tstate);
10471 if (PyErr_Occurred()) SWIG_fail;
10472 }
10473 resultobj = SWIG_From_int(static_cast< int >(result));
10474 return resultobj;
10475 fail:
10476 return NULL;
10477 }
10478
10479
10480 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10481 PyObject *resultobj = 0;
10482 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10483 wxPortId result;
10484 void *argp1 = 0 ;
10485 int res1 = 0 ;
10486 PyObject *swig_obj[1] ;
10487
10488 if (!args) SWIG_fail;
10489 swig_obj[0] = args;
10490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10491 if (!SWIG_IsOK(res1)) {
10492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10493 }
10494 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10495 {
10496 PyThreadState* __tstate = wxPyBeginAllowThreads();
10497 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10498 wxPyEndAllowThreads(__tstate);
10499 if (PyErr_Occurred()) SWIG_fail;
10500 }
10501 resultobj = SWIG_From_int(static_cast< int >(result));
10502 return resultobj;
10503 fail:
10504 return NULL;
10505 }
10506
10507
10508 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10509 PyObject *resultobj = 0;
10510 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10511 wxArchitecture result;
10512 void *argp1 = 0 ;
10513 int res1 = 0 ;
10514 PyObject *swig_obj[1] ;
10515
10516 if (!args) SWIG_fail;
10517 swig_obj[0] = args;
10518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10519 if (!SWIG_IsOK(res1)) {
10520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10521 }
10522 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10523 {
10524 PyThreadState* __tstate = wxPyBeginAllowThreads();
10525 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10526 wxPyEndAllowThreads(__tstate);
10527 if (PyErr_Occurred()) SWIG_fail;
10528 }
10529 resultobj = SWIG_From_int(static_cast< int >(result));
10530 return resultobj;
10531 fail:
10532 return NULL;
10533 }
10534
10535
10536 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10537 PyObject *resultobj = 0;
10538 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10539 wxEndianness result;
10540 void *argp1 = 0 ;
10541 int res1 = 0 ;
10542 PyObject *swig_obj[1] ;
10543
10544 if (!args) SWIG_fail;
10545 swig_obj[0] = args;
10546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10547 if (!SWIG_IsOK(res1)) {
10548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10549 }
10550 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10551 {
10552 PyThreadState* __tstate = wxPyBeginAllowThreads();
10553 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10554 wxPyEndAllowThreads(__tstate);
10555 if (PyErr_Occurred()) SWIG_fail;
10556 }
10557 resultobj = SWIG_From_int(static_cast< int >(result));
10558 return resultobj;
10559 fail:
10560 return NULL;
10561 }
10562
10563
10564 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10565 PyObject *resultobj = 0;
10566 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10567 wxString result;
10568 void *argp1 = 0 ;
10569 int res1 = 0 ;
10570 PyObject *swig_obj[1] ;
10571
10572 if (!args) SWIG_fail;
10573 swig_obj[0] = args;
10574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10575 if (!SWIG_IsOK(res1)) {
10576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10577 }
10578 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10579 {
10580 PyThreadState* __tstate = wxPyBeginAllowThreads();
10581 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10582 wxPyEndAllowThreads(__tstate);
10583 if (PyErr_Occurred()) SWIG_fail;
10584 }
10585 {
10586 #if wxUSE_UNICODE
10587 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10588 #else
10589 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10590 #endif
10591 }
10592 return resultobj;
10593 fail:
10594 return NULL;
10595 }
10596
10597
10598 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10599 PyObject *resultobj = 0;
10600 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10601 wxString result;
10602 void *argp1 = 0 ;
10603 int res1 = 0 ;
10604 PyObject *swig_obj[1] ;
10605
10606 if (!args) SWIG_fail;
10607 swig_obj[0] = args;
10608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10609 if (!SWIG_IsOK(res1)) {
10610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10611 }
10612 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10613 {
10614 PyThreadState* __tstate = wxPyBeginAllowThreads();
10615 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10616 wxPyEndAllowThreads(__tstate);
10617 if (PyErr_Occurred()) SWIG_fail;
10618 }
10619 {
10620 #if wxUSE_UNICODE
10621 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10622 #else
10623 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10624 #endif
10625 }
10626 return resultobj;
10627 fail:
10628 return NULL;
10629 }
10630
10631
10632 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10633 PyObject *resultobj = 0;
10634 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10635 wxString result;
10636 void *argp1 = 0 ;
10637 int res1 = 0 ;
10638 PyObject *swig_obj[1] ;
10639
10640 if (!args) SWIG_fail;
10641 swig_obj[0] = args;
10642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10643 if (!SWIG_IsOK(res1)) {
10644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10645 }
10646 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10647 {
10648 PyThreadState* __tstate = wxPyBeginAllowThreads();
10649 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10650 wxPyEndAllowThreads(__tstate);
10651 if (PyErr_Occurred()) SWIG_fail;
10652 }
10653 {
10654 #if wxUSE_UNICODE
10655 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10656 #else
10657 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10658 #endif
10659 }
10660 return resultobj;
10661 fail:
10662 return NULL;
10663 }
10664
10665
10666 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10667 PyObject *resultobj = 0;
10668 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10669 wxString result;
10670 void *argp1 = 0 ;
10671 int res1 = 0 ;
10672 PyObject *swig_obj[1] ;
10673
10674 if (!args) SWIG_fail;
10675 swig_obj[0] = args;
10676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10677 if (!SWIG_IsOK(res1)) {
10678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10679 }
10680 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10681 {
10682 PyThreadState* __tstate = wxPyBeginAllowThreads();
10683 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10684 wxPyEndAllowThreads(__tstate);
10685 if (PyErr_Occurred()) SWIG_fail;
10686 }
10687 {
10688 #if wxUSE_UNICODE
10689 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10690 #else
10691 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10692 #endif
10693 }
10694 return resultobj;
10695 fail:
10696 return NULL;
10697 }
10698
10699
10700 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10701 PyObject *resultobj = 0;
10702 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10703 wxString result;
10704 void *argp1 = 0 ;
10705 int res1 = 0 ;
10706 PyObject *swig_obj[1] ;
10707
10708 if (!args) SWIG_fail;
10709 swig_obj[0] = args;
10710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10711 if (!SWIG_IsOK(res1)) {
10712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10713 }
10714 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10715 {
10716 PyThreadState* __tstate = wxPyBeginAllowThreads();
10717 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10718 wxPyEndAllowThreads(__tstate);
10719 if (PyErr_Occurred()) SWIG_fail;
10720 }
10721 {
10722 #if wxUSE_UNICODE
10723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10724 #else
10725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10726 #endif
10727 }
10728 return resultobj;
10729 fail:
10730 return NULL;
10731 }
10732
10733
10734 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10735 PyObject *resultobj = 0;
10736 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10737 wxString result;
10738 void *argp1 = 0 ;
10739 int res1 = 0 ;
10740 PyObject *swig_obj[1] ;
10741
10742 if (!args) SWIG_fail;
10743 swig_obj[0] = args;
10744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10745 if (!SWIG_IsOK(res1)) {
10746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10747 }
10748 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10749 {
10750 PyThreadState* __tstate = wxPyBeginAllowThreads();
10751 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10752 wxPyEndAllowThreads(__tstate);
10753 if (PyErr_Occurred()) SWIG_fail;
10754 }
10755 {
10756 #if wxUSE_UNICODE
10757 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10758 #else
10759 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10760 #endif
10761 }
10762 return resultobj;
10763 fail:
10764 return NULL;
10765 }
10766
10767
10768 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10769 PyObject *resultobj = 0;
10770 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10771 int arg2 ;
10772 int arg3 ;
10773 void *argp1 = 0 ;
10774 int res1 = 0 ;
10775 int val2 ;
10776 int ecode2 = 0 ;
10777 int val3 ;
10778 int ecode3 = 0 ;
10779 PyObject * obj0 = 0 ;
10780 PyObject * obj1 = 0 ;
10781 PyObject * obj2 = 0 ;
10782 char * kwnames[] = {
10783 (char *) "self",(char *) "major",(char *) "minor", NULL
10784 };
10785
10786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10788 if (!SWIG_IsOK(res1)) {
10789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10790 }
10791 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10792 ecode2 = SWIG_AsVal_int(obj1, &val2);
10793 if (!SWIG_IsOK(ecode2)) {
10794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10795 }
10796 arg2 = static_cast< int >(val2);
10797 ecode3 = SWIG_AsVal_int(obj2, &val3);
10798 if (!SWIG_IsOK(ecode3)) {
10799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10800 }
10801 arg3 = static_cast< int >(val3);
10802 {
10803 PyThreadState* __tstate = wxPyBeginAllowThreads();
10804 (arg1)->SetOSVersion(arg2,arg3);
10805 wxPyEndAllowThreads(__tstate);
10806 if (PyErr_Occurred()) SWIG_fail;
10807 }
10808 resultobj = SWIG_Py_Void();
10809 return resultobj;
10810 fail:
10811 return NULL;
10812 }
10813
10814
10815 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10816 PyObject *resultobj = 0;
10817 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10818 int arg2 ;
10819 int arg3 ;
10820 void *argp1 = 0 ;
10821 int res1 = 0 ;
10822 int val2 ;
10823 int ecode2 = 0 ;
10824 int val3 ;
10825 int ecode3 = 0 ;
10826 PyObject * obj0 = 0 ;
10827 PyObject * obj1 = 0 ;
10828 PyObject * obj2 = 0 ;
10829 char * kwnames[] = {
10830 (char *) "self",(char *) "major",(char *) "minor", NULL
10831 };
10832
10833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10835 if (!SWIG_IsOK(res1)) {
10836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10837 }
10838 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10839 ecode2 = SWIG_AsVal_int(obj1, &val2);
10840 if (!SWIG_IsOK(ecode2)) {
10841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10842 }
10843 arg2 = static_cast< int >(val2);
10844 ecode3 = SWIG_AsVal_int(obj2, &val3);
10845 if (!SWIG_IsOK(ecode3)) {
10846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10847 }
10848 arg3 = static_cast< int >(val3);
10849 {
10850 PyThreadState* __tstate = wxPyBeginAllowThreads();
10851 (arg1)->SetToolkitVersion(arg2,arg3);
10852 wxPyEndAllowThreads(__tstate);
10853 if (PyErr_Occurred()) SWIG_fail;
10854 }
10855 resultobj = SWIG_Py_Void();
10856 return resultobj;
10857 fail:
10858 return NULL;
10859 }
10860
10861
10862 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10863 PyObject *resultobj = 0;
10864 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10865 wxOperatingSystemId arg2 ;
10866 void *argp1 = 0 ;
10867 int res1 = 0 ;
10868 int val2 ;
10869 int ecode2 = 0 ;
10870 PyObject * obj0 = 0 ;
10871 PyObject * obj1 = 0 ;
10872 char * kwnames[] = {
10873 (char *) "self",(char *) "n", NULL
10874 };
10875
10876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10878 if (!SWIG_IsOK(res1)) {
10879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10880 }
10881 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10882 ecode2 = SWIG_AsVal_int(obj1, &val2);
10883 if (!SWIG_IsOK(ecode2)) {
10884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10885 }
10886 arg2 = static_cast< wxOperatingSystemId >(val2);
10887 {
10888 PyThreadState* __tstate = wxPyBeginAllowThreads();
10889 (arg1)->SetOperatingSystemId(arg2);
10890 wxPyEndAllowThreads(__tstate);
10891 if (PyErr_Occurred()) SWIG_fail;
10892 }
10893 resultobj = SWIG_Py_Void();
10894 return resultobj;
10895 fail:
10896 return NULL;
10897 }
10898
10899
10900 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10901 PyObject *resultobj = 0;
10902 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10903 wxPortId arg2 ;
10904 void *argp1 = 0 ;
10905 int res1 = 0 ;
10906 int val2 ;
10907 int ecode2 = 0 ;
10908 PyObject * obj0 = 0 ;
10909 PyObject * obj1 = 0 ;
10910 char * kwnames[] = {
10911 (char *) "self",(char *) "n", NULL
10912 };
10913
10914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10916 if (!SWIG_IsOK(res1)) {
10917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10918 }
10919 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10920 ecode2 = SWIG_AsVal_int(obj1, &val2);
10921 if (!SWIG_IsOK(ecode2)) {
10922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10923 }
10924 arg2 = static_cast< wxPortId >(val2);
10925 {
10926 PyThreadState* __tstate = wxPyBeginAllowThreads();
10927 (arg1)->SetPortId(arg2);
10928 wxPyEndAllowThreads(__tstate);
10929 if (PyErr_Occurred()) SWIG_fail;
10930 }
10931 resultobj = SWIG_Py_Void();
10932 return resultobj;
10933 fail:
10934 return NULL;
10935 }
10936
10937
10938 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10939 PyObject *resultobj = 0;
10940 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10941 wxArchitecture arg2 ;
10942 void *argp1 = 0 ;
10943 int res1 = 0 ;
10944 int val2 ;
10945 int ecode2 = 0 ;
10946 PyObject * obj0 = 0 ;
10947 PyObject * obj1 = 0 ;
10948 char * kwnames[] = {
10949 (char *) "self",(char *) "n", NULL
10950 };
10951
10952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10954 if (!SWIG_IsOK(res1)) {
10955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10956 }
10957 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10958 ecode2 = SWIG_AsVal_int(obj1, &val2);
10959 if (!SWIG_IsOK(ecode2)) {
10960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
10961 }
10962 arg2 = static_cast< wxArchitecture >(val2);
10963 {
10964 PyThreadState* __tstate = wxPyBeginAllowThreads();
10965 (arg1)->SetArchitecture(arg2);
10966 wxPyEndAllowThreads(__tstate);
10967 if (PyErr_Occurred()) SWIG_fail;
10968 }
10969 resultobj = SWIG_Py_Void();
10970 return resultobj;
10971 fail:
10972 return NULL;
10973 }
10974
10975
10976 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10977 PyObject *resultobj = 0;
10978 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10979 wxEndianness arg2 ;
10980 void *argp1 = 0 ;
10981 int res1 = 0 ;
10982 int val2 ;
10983 int ecode2 = 0 ;
10984 PyObject * obj0 = 0 ;
10985 PyObject * obj1 = 0 ;
10986 char * kwnames[] = {
10987 (char *) "self",(char *) "n", NULL
10988 };
10989
10990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
10991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10992 if (!SWIG_IsOK(res1)) {
10993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10994 }
10995 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10996 ecode2 = SWIG_AsVal_int(obj1, &val2);
10997 if (!SWIG_IsOK(ecode2)) {
10998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
10999 }
11000 arg2 = static_cast< wxEndianness >(val2);
11001 {
11002 PyThreadState* __tstate = wxPyBeginAllowThreads();
11003 (arg1)->SetEndianness(arg2);
11004 wxPyEndAllowThreads(__tstate);
11005 if (PyErr_Occurred()) SWIG_fail;
11006 }
11007 resultobj = SWIG_Py_Void();
11008 return resultobj;
11009 fail:
11010 return NULL;
11011 }
11012
11013
11014 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11015 PyObject *resultobj = 0;
11016 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11017 bool result;
11018 void *argp1 = 0 ;
11019 int res1 = 0 ;
11020 PyObject *swig_obj[1] ;
11021
11022 if (!args) SWIG_fail;
11023 swig_obj[0] = args;
11024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11025 if (!SWIG_IsOK(res1)) {
11026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11027 }
11028 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11029 {
11030 PyThreadState* __tstate = wxPyBeginAllowThreads();
11031 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11032 wxPyEndAllowThreads(__tstate);
11033 if (PyErr_Occurred()) SWIG_fail;
11034 }
11035 {
11036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11037 }
11038 return resultobj;
11039 fail:
11040 return NULL;
11041 }
11042
11043
11044 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11045 PyObject *obj;
11046 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11047 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11048 return SWIG_Py_Void();
11049 }
11050
11051 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11052 return SWIG_Python_InitShadowInstance(args);
11053 }
11054
11055 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11056 PyObject *resultobj = 0;
11057 wxWindow *arg1 = (wxWindow *) 0 ;
11058 wxDC *arg2 = 0 ;
11059 bool result;
11060 void *argp1 = 0 ;
11061 int res1 = 0 ;
11062 void *argp2 = 0 ;
11063 int res2 = 0 ;
11064 PyObject * obj0 = 0 ;
11065 PyObject * obj1 = 0 ;
11066 char * kwnames[] = {
11067 (char *) "window",(char *) "dc", NULL
11068 };
11069
11070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11072 if (!SWIG_IsOK(res1)) {
11073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11074 }
11075 arg1 = reinterpret_cast< wxWindow * >(argp1);
11076 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11077 if (!SWIG_IsOK(res2)) {
11078 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11079 }
11080 if (!argp2) {
11081 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11082 }
11083 arg2 = reinterpret_cast< wxDC * >(argp2);
11084 {
11085 PyThreadState* __tstate = wxPyBeginAllowThreads();
11086 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11087 wxPyEndAllowThreads(__tstate);
11088 if (PyErr_Occurred()) SWIG_fail;
11089 }
11090 {
11091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11092 }
11093 return resultobj;
11094 fail:
11095 return NULL;
11096 }
11097
11098
11099 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11100 PyObject *resultobj = 0;
11101 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11102 void *argp1 = 0 ;
11103 int res1 = 0 ;
11104 PyObject *swig_obj[1] ;
11105
11106 if (!args) SWIG_fail;
11107 swig_obj[0] = args;
11108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11109 if (!SWIG_IsOK(res1)) {
11110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11111 }
11112 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11113 {
11114 PyThreadState* __tstate = wxPyBeginAllowThreads();
11115 delete arg1;
11116
11117 wxPyEndAllowThreads(__tstate);
11118 if (PyErr_Occurred()) SWIG_fail;
11119 }
11120 resultobj = SWIG_Py_Void();
11121 return resultobj;
11122 fail:
11123 return NULL;
11124 }
11125
11126
11127 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11128 PyObject *resultobj = 0;
11129 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11130 wxString result;
11131 void *argp1 = 0 ;
11132 int res1 = 0 ;
11133 PyObject *swig_obj[1] ;
11134
11135 if (!args) SWIG_fail;
11136 swig_obj[0] = args;
11137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11138 if (!SWIG_IsOK(res1)) {
11139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11140 }
11141 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11142 {
11143 PyThreadState* __tstate = wxPyBeginAllowThreads();
11144 result = (arg1)->GetTip();
11145 wxPyEndAllowThreads(__tstate);
11146 if (PyErr_Occurred()) SWIG_fail;
11147 }
11148 {
11149 #if wxUSE_UNICODE
11150 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11151 #else
11152 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11153 #endif
11154 }
11155 return resultobj;
11156 fail:
11157 return NULL;
11158 }
11159
11160
11161 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11162 PyObject *resultobj = 0;
11163 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11164 size_t result;
11165 void *argp1 = 0 ;
11166 int res1 = 0 ;
11167 PyObject *swig_obj[1] ;
11168
11169 if (!args) SWIG_fail;
11170 swig_obj[0] = args;
11171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11172 if (!SWIG_IsOK(res1)) {
11173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11174 }
11175 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11176 {
11177 PyThreadState* __tstate = wxPyBeginAllowThreads();
11178 result = (size_t)(arg1)->GetCurrentTip();
11179 wxPyEndAllowThreads(__tstate);
11180 if (PyErr_Occurred()) SWIG_fail;
11181 }
11182 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11183 return resultobj;
11184 fail:
11185 return NULL;
11186 }
11187
11188
11189 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11190 PyObject *resultobj = 0;
11191 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11192 wxString *arg2 = 0 ;
11193 wxString result;
11194 void *argp1 = 0 ;
11195 int res1 = 0 ;
11196 bool temp2 = false ;
11197 PyObject * obj0 = 0 ;
11198 PyObject * obj1 = 0 ;
11199 char * kwnames[] = {
11200 (char *) "self",(char *) "tip", NULL
11201 };
11202
11203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11205 if (!SWIG_IsOK(res1)) {
11206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11207 }
11208 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11209 {
11210 arg2 = wxString_in_helper(obj1);
11211 if (arg2 == NULL) SWIG_fail;
11212 temp2 = true;
11213 }
11214 {
11215 PyThreadState* __tstate = wxPyBeginAllowThreads();
11216 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11217 wxPyEndAllowThreads(__tstate);
11218 if (PyErr_Occurred()) SWIG_fail;
11219 }
11220 {
11221 #if wxUSE_UNICODE
11222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11223 #else
11224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11225 #endif
11226 }
11227 {
11228 if (temp2)
11229 delete arg2;
11230 }
11231 return resultobj;
11232 fail:
11233 {
11234 if (temp2)
11235 delete arg2;
11236 }
11237 return NULL;
11238 }
11239
11240
11241 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11242 PyObject *obj;
11243 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11244 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11245 return SWIG_Py_Void();
11246 }
11247
11248 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11249 PyObject *resultobj = 0;
11250 size_t arg1 ;
11251 wxPyTipProvider *result = 0 ;
11252 size_t val1 ;
11253 int ecode1 = 0 ;
11254 PyObject * obj0 = 0 ;
11255 char * kwnames[] = {
11256 (char *) "currentTip", NULL
11257 };
11258
11259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11260 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11261 if (!SWIG_IsOK(ecode1)) {
11262 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11263 }
11264 arg1 = static_cast< size_t >(val1);
11265 {
11266 PyThreadState* __tstate = wxPyBeginAllowThreads();
11267 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11268 wxPyEndAllowThreads(__tstate);
11269 if (PyErr_Occurred()) SWIG_fail;
11270 }
11271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11272 return resultobj;
11273 fail:
11274 return NULL;
11275 }
11276
11277
11278 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11279 PyObject *resultobj = 0;
11280 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11281 PyObject *arg2 = (PyObject *) 0 ;
11282 PyObject *arg3 = (PyObject *) 0 ;
11283 void *argp1 = 0 ;
11284 int res1 = 0 ;
11285 PyObject * obj0 = 0 ;
11286 PyObject * obj1 = 0 ;
11287 PyObject * obj2 = 0 ;
11288 char * kwnames[] = {
11289 (char *) "self",(char *) "self",(char *) "_class", NULL
11290 };
11291
11292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11294 if (!SWIG_IsOK(res1)) {
11295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11296 }
11297 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11298 arg2 = obj1;
11299 arg3 = obj2;
11300 {
11301 PyThreadState* __tstate = wxPyBeginAllowThreads();
11302 (arg1)->_setCallbackInfo(arg2,arg3);
11303 wxPyEndAllowThreads(__tstate);
11304 if (PyErr_Occurred()) SWIG_fail;
11305 }
11306 resultobj = SWIG_Py_Void();
11307 return resultobj;
11308 fail:
11309 return NULL;
11310 }
11311
11312
11313 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11314 PyObject *obj;
11315 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11316 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11317 return SWIG_Py_Void();
11318 }
11319
11320 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11321 return SWIG_Python_InitShadowInstance(args);
11322 }
11323
11324 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11325 PyObject *resultobj = 0;
11326 wxWindow *arg1 = (wxWindow *) 0 ;
11327 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11328 bool arg3 = (bool) true ;
11329 bool result;
11330 void *argp1 = 0 ;
11331 int res1 = 0 ;
11332 void *argp2 = 0 ;
11333 int res2 = 0 ;
11334 bool val3 ;
11335 int ecode3 = 0 ;
11336 PyObject * obj0 = 0 ;
11337 PyObject * obj1 = 0 ;
11338 PyObject * obj2 = 0 ;
11339 char * kwnames[] = {
11340 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11341 };
11342
11343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11345 if (!SWIG_IsOK(res1)) {
11346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11347 }
11348 arg1 = reinterpret_cast< wxWindow * >(argp1);
11349 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11350 if (!SWIG_IsOK(res2)) {
11351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11352 }
11353 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11354 if (obj2) {
11355 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11356 if (!SWIG_IsOK(ecode3)) {
11357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11358 }
11359 arg3 = static_cast< bool >(val3);
11360 }
11361 {
11362 if (!wxPyCheckForApp()) SWIG_fail;
11363 PyThreadState* __tstate = wxPyBeginAllowThreads();
11364 result = (bool)wxShowTip(arg1,arg2,arg3);
11365 wxPyEndAllowThreads(__tstate);
11366 if (PyErr_Occurred()) SWIG_fail;
11367 }
11368 {
11369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11370 }
11371 return resultobj;
11372 fail:
11373 return NULL;
11374 }
11375
11376
11377 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11378 PyObject *resultobj = 0;
11379 wxString *arg1 = 0 ;
11380 size_t arg2 ;
11381 wxTipProvider *result = 0 ;
11382 bool temp1 = false ;
11383 size_t val2 ;
11384 int ecode2 = 0 ;
11385 PyObject * obj0 = 0 ;
11386 PyObject * obj1 = 0 ;
11387 char * kwnames[] = {
11388 (char *) "filename",(char *) "currentTip", NULL
11389 };
11390
11391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11392 {
11393 arg1 = wxString_in_helper(obj0);
11394 if (arg1 == NULL) SWIG_fail;
11395 temp1 = true;
11396 }
11397 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11398 if (!SWIG_IsOK(ecode2)) {
11399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11400 }
11401 arg2 = static_cast< size_t >(val2);
11402 {
11403 if (!wxPyCheckForApp()) SWIG_fail;
11404 PyThreadState* __tstate = wxPyBeginAllowThreads();
11405 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11406 wxPyEndAllowThreads(__tstate);
11407 if (PyErr_Occurred()) SWIG_fail;
11408 }
11409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11410 {
11411 if (temp1)
11412 delete arg1;
11413 }
11414 return resultobj;
11415 fail:
11416 {
11417 if (temp1)
11418 delete arg1;
11419 }
11420 return NULL;
11421 }
11422
11423
11424 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11425 PyObject *resultobj = 0;
11426 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11427 int arg2 = (int) wxID_ANY ;
11428 wxPyTimer *result = 0 ;
11429 void *argp1 = 0 ;
11430 int res1 = 0 ;
11431 int val2 ;
11432 int ecode2 = 0 ;
11433 PyObject * obj0 = 0 ;
11434 PyObject * obj1 = 0 ;
11435 char * kwnames[] = {
11436 (char *) "owner",(char *) "id", NULL
11437 };
11438
11439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11440 if (obj0) {
11441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11442 if (!SWIG_IsOK(res1)) {
11443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11444 }
11445 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11446 }
11447 if (obj1) {
11448 ecode2 = SWIG_AsVal_int(obj1, &val2);
11449 if (!SWIG_IsOK(ecode2)) {
11450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11451 }
11452 arg2 = static_cast< int >(val2);
11453 }
11454 {
11455 if (!wxPyCheckForApp()) SWIG_fail;
11456 PyThreadState* __tstate = wxPyBeginAllowThreads();
11457 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11458 wxPyEndAllowThreads(__tstate);
11459 if (PyErr_Occurred()) SWIG_fail;
11460 }
11461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11462 return resultobj;
11463 fail:
11464 return NULL;
11465 }
11466
11467
11468 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11469 PyObject *resultobj = 0;
11470 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11471 void *argp1 = 0 ;
11472 int res1 = 0 ;
11473 PyObject *swig_obj[1] ;
11474
11475 if (!args) SWIG_fail;
11476 swig_obj[0] = args;
11477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11478 if (!SWIG_IsOK(res1)) {
11479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11480 }
11481 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11482 {
11483 PyThreadState* __tstate = wxPyBeginAllowThreads();
11484 delete arg1;
11485
11486 wxPyEndAllowThreads(__tstate);
11487 if (PyErr_Occurred()) SWIG_fail;
11488 }
11489 resultobj = SWIG_Py_Void();
11490 return resultobj;
11491 fail:
11492 return NULL;
11493 }
11494
11495
11496 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11497 PyObject *resultobj = 0;
11498 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11499 PyObject *arg2 = (PyObject *) 0 ;
11500 PyObject *arg3 = (PyObject *) 0 ;
11501 int arg4 = (int) 1 ;
11502 void *argp1 = 0 ;
11503 int res1 = 0 ;
11504 int val4 ;
11505 int ecode4 = 0 ;
11506 PyObject * obj0 = 0 ;
11507 PyObject * obj1 = 0 ;
11508 PyObject * obj2 = 0 ;
11509 PyObject * obj3 = 0 ;
11510 char * kwnames[] = {
11511 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11512 };
11513
11514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11516 if (!SWIG_IsOK(res1)) {
11517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11518 }
11519 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11520 arg2 = obj1;
11521 arg3 = obj2;
11522 if (obj3) {
11523 ecode4 = SWIG_AsVal_int(obj3, &val4);
11524 if (!SWIG_IsOK(ecode4)) {
11525 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11526 }
11527 arg4 = static_cast< int >(val4);
11528 }
11529 {
11530 PyThreadState* __tstate = wxPyBeginAllowThreads();
11531 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11532 wxPyEndAllowThreads(__tstate);
11533 if (PyErr_Occurred()) SWIG_fail;
11534 }
11535 resultobj = SWIG_Py_Void();
11536 return resultobj;
11537 fail:
11538 return NULL;
11539 }
11540
11541
11542 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11543 PyObject *resultobj = 0;
11544 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11545 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11546 int arg3 = (int) wxID_ANY ;
11547 void *argp1 = 0 ;
11548 int res1 = 0 ;
11549 void *argp2 = 0 ;
11550 int res2 = 0 ;
11551 int val3 ;
11552 int ecode3 = 0 ;
11553 PyObject * obj0 = 0 ;
11554 PyObject * obj1 = 0 ;
11555 PyObject * obj2 = 0 ;
11556 char * kwnames[] = {
11557 (char *) "self",(char *) "owner",(char *) "id", NULL
11558 };
11559
11560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11562 if (!SWIG_IsOK(res1)) {
11563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11564 }
11565 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11566 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11567 if (!SWIG_IsOK(res2)) {
11568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11569 }
11570 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11571 if (obj2) {
11572 ecode3 = SWIG_AsVal_int(obj2, &val3);
11573 if (!SWIG_IsOK(ecode3)) {
11574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11575 }
11576 arg3 = static_cast< int >(val3);
11577 }
11578 {
11579 PyThreadState* __tstate = wxPyBeginAllowThreads();
11580 (arg1)->SetOwner(arg2,arg3);
11581 wxPyEndAllowThreads(__tstate);
11582 if (PyErr_Occurred()) SWIG_fail;
11583 }
11584 resultobj = SWIG_Py_Void();
11585 return resultobj;
11586 fail:
11587 return NULL;
11588 }
11589
11590
11591 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11592 PyObject *resultobj = 0;
11593 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11594 wxEvtHandler *result = 0 ;
11595 void *argp1 = 0 ;
11596 int res1 = 0 ;
11597 PyObject *swig_obj[1] ;
11598
11599 if (!args) SWIG_fail;
11600 swig_obj[0] = args;
11601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11602 if (!SWIG_IsOK(res1)) {
11603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11604 }
11605 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11606 {
11607 PyThreadState* __tstate = wxPyBeginAllowThreads();
11608 result = (wxEvtHandler *)(arg1)->GetOwner();
11609 wxPyEndAllowThreads(__tstate);
11610 if (PyErr_Occurred()) SWIG_fail;
11611 }
11612 {
11613 resultobj = wxPyMake_wxObject(result, 0);
11614 }
11615 return resultobj;
11616 fail:
11617 return NULL;
11618 }
11619
11620
11621 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11622 PyObject *resultobj = 0;
11623 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11624 int arg2 = (int) -1 ;
11625 bool arg3 = (bool) false ;
11626 bool result;
11627 void *argp1 = 0 ;
11628 int res1 = 0 ;
11629 int val2 ;
11630 int ecode2 = 0 ;
11631 bool val3 ;
11632 int ecode3 = 0 ;
11633 PyObject * obj0 = 0 ;
11634 PyObject * obj1 = 0 ;
11635 PyObject * obj2 = 0 ;
11636 char * kwnames[] = {
11637 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11638 };
11639
11640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11642 if (!SWIG_IsOK(res1)) {
11643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11644 }
11645 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11646 if (obj1) {
11647 ecode2 = SWIG_AsVal_int(obj1, &val2);
11648 if (!SWIG_IsOK(ecode2)) {
11649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11650 }
11651 arg2 = static_cast< int >(val2);
11652 }
11653 if (obj2) {
11654 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11655 if (!SWIG_IsOK(ecode3)) {
11656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11657 }
11658 arg3 = static_cast< bool >(val3);
11659 }
11660 {
11661 PyThreadState* __tstate = wxPyBeginAllowThreads();
11662 result = (bool)(arg1)->Start(arg2,arg3);
11663 wxPyEndAllowThreads(__tstate);
11664 if (PyErr_Occurred()) SWIG_fail;
11665 }
11666 {
11667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11668 }
11669 return resultobj;
11670 fail:
11671 return NULL;
11672 }
11673
11674
11675 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11676 PyObject *resultobj = 0;
11677 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11678 void *argp1 = 0 ;
11679 int res1 = 0 ;
11680 PyObject *swig_obj[1] ;
11681
11682 if (!args) SWIG_fail;
11683 swig_obj[0] = args;
11684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11685 if (!SWIG_IsOK(res1)) {
11686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11687 }
11688 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11689 {
11690 PyThreadState* __tstate = wxPyBeginAllowThreads();
11691 (arg1)->Stop();
11692 wxPyEndAllowThreads(__tstate);
11693 if (PyErr_Occurred()) SWIG_fail;
11694 }
11695 resultobj = SWIG_Py_Void();
11696 return resultobj;
11697 fail:
11698 return NULL;
11699 }
11700
11701
11702 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11703 PyObject *resultobj = 0;
11704 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11705 void *argp1 = 0 ;
11706 int res1 = 0 ;
11707 PyObject *swig_obj[1] ;
11708
11709 if (!args) SWIG_fail;
11710 swig_obj[0] = args;
11711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11712 if (!SWIG_IsOK(res1)) {
11713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11714 }
11715 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11716 {
11717 PyThreadState* __tstate = wxPyBeginAllowThreads();
11718 (arg1)->Notify();
11719 wxPyEndAllowThreads(__tstate);
11720 if (PyErr_Occurred()) SWIG_fail;
11721 }
11722 resultobj = SWIG_Py_Void();
11723 return resultobj;
11724 fail:
11725 return NULL;
11726 }
11727
11728
11729 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11730 PyObject *resultobj = 0;
11731 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11732 bool result;
11733 void *argp1 = 0 ;
11734 int res1 = 0 ;
11735 PyObject *swig_obj[1] ;
11736
11737 if (!args) SWIG_fail;
11738 swig_obj[0] = args;
11739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11740 if (!SWIG_IsOK(res1)) {
11741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11742 }
11743 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11744 {
11745 PyThreadState* __tstate = wxPyBeginAllowThreads();
11746 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11747 wxPyEndAllowThreads(__tstate);
11748 if (PyErr_Occurred()) SWIG_fail;
11749 }
11750 {
11751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11752 }
11753 return resultobj;
11754 fail:
11755 return NULL;
11756 }
11757
11758
11759 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11760 PyObject *resultobj = 0;
11761 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11762 int result;
11763 void *argp1 = 0 ;
11764 int res1 = 0 ;
11765 PyObject *swig_obj[1] ;
11766
11767 if (!args) SWIG_fail;
11768 swig_obj[0] = args;
11769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11770 if (!SWIG_IsOK(res1)) {
11771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11772 }
11773 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11774 {
11775 PyThreadState* __tstate = wxPyBeginAllowThreads();
11776 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11777 wxPyEndAllowThreads(__tstate);
11778 if (PyErr_Occurred()) SWIG_fail;
11779 }
11780 resultobj = SWIG_From_int(static_cast< int >(result));
11781 return resultobj;
11782 fail:
11783 return NULL;
11784 }
11785
11786
11787 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11788 PyObject *resultobj = 0;
11789 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11790 int result;
11791 void *argp1 = 0 ;
11792 int res1 = 0 ;
11793 PyObject *swig_obj[1] ;
11794
11795 if (!args) SWIG_fail;
11796 swig_obj[0] = args;
11797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11798 if (!SWIG_IsOK(res1)) {
11799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11800 }
11801 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11802 {
11803 PyThreadState* __tstate = wxPyBeginAllowThreads();
11804 result = (int)((wxPyTimer const *)arg1)->GetId();
11805 wxPyEndAllowThreads(__tstate);
11806 if (PyErr_Occurred()) SWIG_fail;
11807 }
11808 resultobj = SWIG_From_int(static_cast< int >(result));
11809 return resultobj;
11810 fail:
11811 return NULL;
11812 }
11813
11814
11815 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11816 PyObject *resultobj = 0;
11817 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11818 bool result;
11819 void *argp1 = 0 ;
11820 int res1 = 0 ;
11821 PyObject *swig_obj[1] ;
11822
11823 if (!args) SWIG_fail;
11824 swig_obj[0] = args;
11825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11826 if (!SWIG_IsOK(res1)) {
11827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11828 }
11829 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11830 {
11831 PyThreadState* __tstate = wxPyBeginAllowThreads();
11832 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11833 wxPyEndAllowThreads(__tstate);
11834 if (PyErr_Occurred()) SWIG_fail;
11835 }
11836 {
11837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11838 }
11839 return resultobj;
11840 fail:
11841 return NULL;
11842 }
11843
11844
11845 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11846 PyObject *obj;
11847 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11848 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11849 return SWIG_Py_Void();
11850 }
11851
11852 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11853 return SWIG_Python_InitShadowInstance(args);
11854 }
11855
11856 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11857 PyObject *resultobj = 0;
11858 int arg1 = (int) 0 ;
11859 int arg2 = (int) 0 ;
11860 wxTimerEvent *result = 0 ;
11861 int val1 ;
11862 int ecode1 = 0 ;
11863 int val2 ;
11864 int ecode2 = 0 ;
11865 PyObject * obj0 = 0 ;
11866 PyObject * obj1 = 0 ;
11867 char * kwnames[] = {
11868 (char *) "timerid",(char *) "interval", NULL
11869 };
11870
11871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11872 if (obj0) {
11873 ecode1 = SWIG_AsVal_int(obj0, &val1);
11874 if (!SWIG_IsOK(ecode1)) {
11875 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11876 }
11877 arg1 = static_cast< int >(val1);
11878 }
11879 if (obj1) {
11880 ecode2 = SWIG_AsVal_int(obj1, &val2);
11881 if (!SWIG_IsOK(ecode2)) {
11882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11883 }
11884 arg2 = static_cast< int >(val2);
11885 }
11886 {
11887 PyThreadState* __tstate = wxPyBeginAllowThreads();
11888 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11889 wxPyEndAllowThreads(__tstate);
11890 if (PyErr_Occurred()) SWIG_fail;
11891 }
11892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11893 return resultobj;
11894 fail:
11895 return NULL;
11896 }
11897
11898
11899 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11900 PyObject *resultobj = 0;
11901 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11902 int result;
11903 void *argp1 = 0 ;
11904 int res1 = 0 ;
11905 PyObject *swig_obj[1] ;
11906
11907 if (!args) SWIG_fail;
11908 swig_obj[0] = args;
11909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11910 if (!SWIG_IsOK(res1)) {
11911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11912 }
11913 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11914 {
11915 PyThreadState* __tstate = wxPyBeginAllowThreads();
11916 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11917 wxPyEndAllowThreads(__tstate);
11918 if (PyErr_Occurred()) SWIG_fail;
11919 }
11920 resultobj = SWIG_From_int(static_cast< int >(result));
11921 return resultobj;
11922 fail:
11923 return NULL;
11924 }
11925
11926
11927 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11928 PyObject *obj;
11929 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11930 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11931 return SWIG_Py_Void();
11932 }
11933
11934 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11935 return SWIG_Python_InitShadowInstance(args);
11936 }
11937
11938 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11939 PyObject *resultobj = 0;
11940 wxTimer *arg1 = 0 ;
11941 wxTimerRunner *result = 0 ;
11942 void *argp1 = 0 ;
11943 int res1 = 0 ;
11944
11945 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11947 if (!SWIG_IsOK(res1)) {
11948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11949 }
11950 if (!argp1) {
11951 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11952 }
11953 arg1 = reinterpret_cast< wxTimer * >(argp1);
11954 {
11955 if (!wxPyCheckForApp()) SWIG_fail;
11956 PyThreadState* __tstate = wxPyBeginAllowThreads();
11957 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11958 wxPyEndAllowThreads(__tstate);
11959 if (PyErr_Occurred()) SWIG_fail;
11960 }
11961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11962 return resultobj;
11963 fail:
11964 return NULL;
11965 }
11966
11967
11968 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11969 PyObject *resultobj = 0;
11970 wxTimer *arg1 = 0 ;
11971 int arg2 ;
11972 bool arg3 = (bool) false ;
11973 wxTimerRunner *result = 0 ;
11974 void *argp1 = 0 ;
11975 int res1 = 0 ;
11976 int val2 ;
11977 int ecode2 = 0 ;
11978 bool val3 ;
11979 int ecode3 = 0 ;
11980
11981 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
11982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11983 if (!SWIG_IsOK(res1)) {
11984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11985 }
11986 if (!argp1) {
11987 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11988 }
11989 arg1 = reinterpret_cast< wxTimer * >(argp1);
11990 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11991 if (!SWIG_IsOK(ecode2)) {
11992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
11993 }
11994 arg2 = static_cast< int >(val2);
11995 if (swig_obj[2]) {
11996 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
11997 if (!SWIG_IsOK(ecode3)) {
11998 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
11999 }
12000 arg3 = static_cast< bool >(val3);
12001 }
12002 {
12003 if (!wxPyCheckForApp()) SWIG_fail;
12004 PyThreadState* __tstate = wxPyBeginAllowThreads();
12005 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12006 wxPyEndAllowThreads(__tstate);
12007 if (PyErr_Occurred()) SWIG_fail;
12008 }
12009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12010 return resultobj;
12011 fail:
12012 return NULL;
12013 }
12014
12015
12016 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12017 int argc;
12018 PyObject *argv[4];
12019
12020 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12021 --argc;
12022 if (argc == 1) {
12023 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12024 }
12025 if ((argc >= 2) && (argc <= 3)) {
12026 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12027 }
12028
12029 fail:
12030 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12031 return NULL;
12032 }
12033
12034
12035 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12036 PyObject *resultobj = 0;
12037 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12038 void *argp1 = 0 ;
12039 int res1 = 0 ;
12040 PyObject *swig_obj[1] ;
12041
12042 if (!args) SWIG_fail;
12043 swig_obj[0] = args;
12044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12045 if (!SWIG_IsOK(res1)) {
12046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12047 }
12048 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12049 {
12050 PyThreadState* __tstate = wxPyBeginAllowThreads();
12051 delete arg1;
12052
12053 wxPyEndAllowThreads(__tstate);
12054 if (PyErr_Occurred()) SWIG_fail;
12055 }
12056 resultobj = SWIG_Py_Void();
12057 return resultobj;
12058 fail:
12059 return NULL;
12060 }
12061
12062
12063 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12064 PyObject *resultobj = 0;
12065 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12066 int arg2 ;
12067 bool arg3 = (bool) false ;
12068 void *argp1 = 0 ;
12069 int res1 = 0 ;
12070 int val2 ;
12071 int ecode2 = 0 ;
12072 bool val3 ;
12073 int ecode3 = 0 ;
12074 PyObject * obj0 = 0 ;
12075 PyObject * obj1 = 0 ;
12076 PyObject * obj2 = 0 ;
12077 char * kwnames[] = {
12078 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12079 };
12080
12081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12083 if (!SWIG_IsOK(res1)) {
12084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12085 }
12086 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12087 ecode2 = SWIG_AsVal_int(obj1, &val2);
12088 if (!SWIG_IsOK(ecode2)) {
12089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12090 }
12091 arg2 = static_cast< int >(val2);
12092 if (obj2) {
12093 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12094 if (!SWIG_IsOK(ecode3)) {
12095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12096 }
12097 arg3 = static_cast< bool >(val3);
12098 }
12099 {
12100 PyThreadState* __tstate = wxPyBeginAllowThreads();
12101 (arg1)->Start(arg2,arg3);
12102 wxPyEndAllowThreads(__tstate);
12103 if (PyErr_Occurred()) SWIG_fail;
12104 }
12105 resultobj = SWIG_Py_Void();
12106 return resultobj;
12107 fail:
12108 return NULL;
12109 }
12110
12111
12112 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12113 PyObject *obj;
12114 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12115 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12116 return SWIG_Py_Void();
12117 }
12118
12119 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12120 return SWIG_Python_InitShadowInstance(args);
12121 }
12122
12123 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12124 PyObject *resultobj = 0;
12125 wxLog *result = 0 ;
12126
12127 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12128 {
12129 PyThreadState* __tstate = wxPyBeginAllowThreads();
12130 result = (wxLog *)new wxLog();
12131 wxPyEndAllowThreads(__tstate);
12132 if (PyErr_Occurred()) SWIG_fail;
12133 }
12134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12135 return resultobj;
12136 fail:
12137 return NULL;
12138 }
12139
12140
12141 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12142 PyObject *resultobj = 0;
12143 wxLog *arg1 = (wxLog *) 0 ;
12144 void *argp1 = 0 ;
12145 int res1 = 0 ;
12146 PyObject *swig_obj[1] ;
12147
12148 if (!args) SWIG_fail;
12149 swig_obj[0] = args;
12150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12151 if (!SWIG_IsOK(res1)) {
12152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12153 }
12154 arg1 = reinterpret_cast< wxLog * >(argp1);
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 delete arg1;
12158
12159 wxPyEndAllowThreads(__tstate);
12160 if (PyErr_Occurred()) SWIG_fail;
12161 }
12162 resultobj = SWIG_Py_Void();
12163 return resultobj;
12164 fail:
12165 return NULL;
12166 }
12167
12168
12169 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12170 PyObject *resultobj = 0;
12171 bool result;
12172
12173 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12174 {
12175 PyThreadState* __tstate = wxPyBeginAllowThreads();
12176 result = (bool)wxLog::IsEnabled();
12177 wxPyEndAllowThreads(__tstate);
12178 if (PyErr_Occurred()) SWIG_fail;
12179 }
12180 {
12181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12182 }
12183 return resultobj;
12184 fail:
12185 return NULL;
12186 }
12187
12188
12189 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12190 PyObject *resultobj = 0;
12191 bool arg1 = (bool) true ;
12192 bool result;
12193 bool val1 ;
12194 int ecode1 = 0 ;
12195 PyObject * obj0 = 0 ;
12196 char * kwnames[] = {
12197 (char *) "doIt", NULL
12198 };
12199
12200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12201 if (obj0) {
12202 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12203 if (!SWIG_IsOK(ecode1)) {
12204 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12205 }
12206 arg1 = static_cast< bool >(val1);
12207 }
12208 {
12209 PyThreadState* __tstate = wxPyBeginAllowThreads();
12210 result = (bool)wxLog::EnableLogging(arg1);
12211 wxPyEndAllowThreads(__tstate);
12212 if (PyErr_Occurred()) SWIG_fail;
12213 }
12214 {
12215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12216 }
12217 return resultobj;
12218 fail:
12219 return NULL;
12220 }
12221
12222
12223 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12224 PyObject *resultobj = 0;
12225 wxLogLevel arg1 ;
12226 wxChar *arg2 = (wxChar *) 0 ;
12227 time_t arg3 ;
12228 unsigned long val1 ;
12229 int ecode1 = 0 ;
12230 void *argp2 = 0 ;
12231 int res2 = 0 ;
12232 unsigned int val3 ;
12233 int ecode3 = 0 ;
12234 PyObject * obj0 = 0 ;
12235 PyObject * obj1 = 0 ;
12236 PyObject * obj2 = 0 ;
12237 char * kwnames[] = {
12238 (char *) "level",(char *) "szString",(char *) "t", NULL
12239 };
12240
12241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12242 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12243 if (!SWIG_IsOK(ecode1)) {
12244 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12245 }
12246 arg1 = static_cast< wxLogLevel >(val1);
12247 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12248 if (!SWIG_IsOK(res2)) {
12249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12250 }
12251 arg2 = reinterpret_cast< wxChar * >(argp2);
12252 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12253 if (!SWIG_IsOK(ecode3)) {
12254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12255 }
12256 arg3 = static_cast< time_t >(val3);
12257 {
12258 PyThreadState* __tstate = wxPyBeginAllowThreads();
12259 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12260 wxPyEndAllowThreads(__tstate);
12261 if (PyErr_Occurred()) SWIG_fail;
12262 }
12263 resultobj = SWIG_Py_Void();
12264 return resultobj;
12265 fail:
12266 return NULL;
12267 }
12268
12269
12270 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12271 PyObject *resultobj = 0;
12272 wxLog *arg1 = (wxLog *) 0 ;
12273 void *argp1 = 0 ;
12274 int res1 = 0 ;
12275 PyObject *swig_obj[1] ;
12276
12277 if (!args) SWIG_fail;
12278 swig_obj[0] = args;
12279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12280 if (!SWIG_IsOK(res1)) {
12281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12282 }
12283 arg1 = reinterpret_cast< wxLog * >(argp1);
12284 {
12285 PyThreadState* __tstate = wxPyBeginAllowThreads();
12286 (arg1)->Flush();
12287 wxPyEndAllowThreads(__tstate);
12288 if (PyErr_Occurred()) SWIG_fail;
12289 }
12290 resultobj = SWIG_Py_Void();
12291 return resultobj;
12292 fail:
12293 return NULL;
12294 }
12295
12296
12297 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12298 PyObject *resultobj = 0;
12299
12300 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12301 {
12302 PyThreadState* __tstate = wxPyBeginAllowThreads();
12303 wxLog::FlushActive();
12304 wxPyEndAllowThreads(__tstate);
12305 if (PyErr_Occurred()) SWIG_fail;
12306 }
12307 resultobj = SWIG_Py_Void();
12308 return resultobj;
12309 fail:
12310 return NULL;
12311 }
12312
12313
12314 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12315 PyObject *resultobj = 0;
12316 wxLog *result = 0 ;
12317
12318 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12319 {
12320 PyThreadState* __tstate = wxPyBeginAllowThreads();
12321 result = (wxLog *)wxLog::GetActiveTarget();
12322 wxPyEndAllowThreads(__tstate);
12323 if (PyErr_Occurred()) SWIG_fail;
12324 }
12325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12326 return resultobj;
12327 fail:
12328 return NULL;
12329 }
12330
12331
12332 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12333 PyObject *resultobj = 0;
12334 wxLog *arg1 = (wxLog *) 0 ;
12335 wxLog *result = 0 ;
12336 int res1 = 0 ;
12337 PyObject * obj0 = 0 ;
12338 char * kwnames[] = {
12339 (char *) "pLogger", NULL
12340 };
12341
12342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12343 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12344 if (!SWIG_IsOK(res1)) {
12345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12346 }
12347 {
12348 PyThreadState* __tstate = wxPyBeginAllowThreads();
12349 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12350 wxPyEndAllowThreads(__tstate);
12351 if (PyErr_Occurred()) SWIG_fail;
12352 }
12353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12354 return resultobj;
12355 fail:
12356 return NULL;
12357 }
12358
12359
12360 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12361 PyObject *resultobj = 0;
12362
12363 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12364 {
12365 PyThreadState* __tstate = wxPyBeginAllowThreads();
12366 wxLog::Suspend();
12367 wxPyEndAllowThreads(__tstate);
12368 if (PyErr_Occurred()) SWIG_fail;
12369 }
12370 resultobj = SWIG_Py_Void();
12371 return resultobj;
12372 fail:
12373 return NULL;
12374 }
12375
12376
12377 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12378 PyObject *resultobj = 0;
12379
12380 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12381 {
12382 PyThreadState* __tstate = wxPyBeginAllowThreads();
12383 wxLog::Resume();
12384 wxPyEndAllowThreads(__tstate);
12385 if (PyErr_Occurred()) SWIG_fail;
12386 }
12387 resultobj = SWIG_Py_Void();
12388 return resultobj;
12389 fail:
12390 return NULL;
12391 }
12392
12393
12394 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12395 PyObject *resultobj = 0;
12396 bool arg1 = (bool) true ;
12397 bool val1 ;
12398 int ecode1 = 0 ;
12399 PyObject * obj0 = 0 ;
12400 char * kwnames[] = {
12401 (char *) "bVerbose", NULL
12402 };
12403
12404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12405 if (obj0) {
12406 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12407 if (!SWIG_IsOK(ecode1)) {
12408 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12409 }
12410 arg1 = static_cast< bool >(val1);
12411 }
12412 {
12413 PyThreadState* __tstate = wxPyBeginAllowThreads();
12414 wxLog::SetVerbose(arg1);
12415 wxPyEndAllowThreads(__tstate);
12416 if (PyErr_Occurred()) SWIG_fail;
12417 }
12418 resultobj = SWIG_Py_Void();
12419 return resultobj;
12420 fail:
12421 return NULL;
12422 }
12423
12424
12425 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12426 PyObject *resultobj = 0;
12427 wxLogLevel arg1 ;
12428 unsigned long val1 ;
12429 int ecode1 = 0 ;
12430 PyObject * obj0 = 0 ;
12431 char * kwnames[] = {
12432 (char *) "logLevel", NULL
12433 };
12434
12435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12436 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12437 if (!SWIG_IsOK(ecode1)) {
12438 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12439 }
12440 arg1 = static_cast< wxLogLevel >(val1);
12441 {
12442 PyThreadState* __tstate = wxPyBeginAllowThreads();
12443 wxLog::SetLogLevel(arg1);
12444 wxPyEndAllowThreads(__tstate);
12445 if (PyErr_Occurred()) SWIG_fail;
12446 }
12447 resultobj = SWIG_Py_Void();
12448 return resultobj;
12449 fail:
12450 return NULL;
12451 }
12452
12453
12454 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12455 PyObject *resultobj = 0;
12456
12457 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12458 {
12459 PyThreadState* __tstate = wxPyBeginAllowThreads();
12460 wxLog::DontCreateOnDemand();
12461 wxPyEndAllowThreads(__tstate);
12462 if (PyErr_Occurred()) SWIG_fail;
12463 }
12464 resultobj = SWIG_Py_Void();
12465 return resultobj;
12466 fail:
12467 return NULL;
12468 }
12469
12470
12471 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12472 PyObject *resultobj = 0;
12473 bool arg1 = (bool) true ;
12474 bool val1 ;
12475 int ecode1 = 0 ;
12476 PyObject * obj0 = 0 ;
12477 char * kwnames[] = {
12478 (char *) "bRepetCounting", NULL
12479 };
12480
12481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12482 if (obj0) {
12483 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12484 if (!SWIG_IsOK(ecode1)) {
12485 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12486 }
12487 arg1 = static_cast< bool >(val1);
12488 }
12489 {
12490 PyThreadState* __tstate = wxPyBeginAllowThreads();
12491 wxLog::SetRepetitionCounting(arg1);
12492 wxPyEndAllowThreads(__tstate);
12493 if (PyErr_Occurred()) SWIG_fail;
12494 }
12495 resultobj = SWIG_Py_Void();
12496 return resultobj;
12497 fail:
12498 return NULL;
12499 }
12500
12501
12502 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12503 PyObject *resultobj = 0;
12504 bool result;
12505
12506 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12507 {
12508 PyThreadState* __tstate = wxPyBeginAllowThreads();
12509 result = (bool)wxLog::GetRepetitionCounting();
12510 wxPyEndAllowThreads(__tstate);
12511 if (PyErr_Occurred()) SWIG_fail;
12512 }
12513 {
12514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12515 }
12516 return resultobj;
12517 fail:
12518 return NULL;
12519 }
12520
12521
12522 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12523 PyObject *resultobj = 0;
12524 wxTraceMask arg1 ;
12525 unsigned long val1 ;
12526 int ecode1 = 0 ;
12527 PyObject * obj0 = 0 ;
12528 char * kwnames[] = {
12529 (char *) "ulMask", NULL
12530 };
12531
12532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12533 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12534 if (!SWIG_IsOK(ecode1)) {
12535 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12536 }
12537 arg1 = static_cast< wxTraceMask >(val1);
12538 {
12539 PyThreadState* __tstate = wxPyBeginAllowThreads();
12540 wxLog::SetTraceMask(arg1);
12541 wxPyEndAllowThreads(__tstate);
12542 if (PyErr_Occurred()) SWIG_fail;
12543 }
12544 resultobj = SWIG_Py_Void();
12545 return resultobj;
12546 fail:
12547 return NULL;
12548 }
12549
12550
12551 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12552 PyObject *resultobj = 0;
12553 wxString *arg1 = 0 ;
12554 bool temp1 = false ;
12555 PyObject * obj0 = 0 ;
12556 char * kwnames[] = {
12557 (char *) "str", NULL
12558 };
12559
12560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12561 {
12562 arg1 = wxString_in_helper(obj0);
12563 if (arg1 == NULL) SWIG_fail;
12564 temp1 = true;
12565 }
12566 {
12567 PyThreadState* __tstate = wxPyBeginAllowThreads();
12568 wxLog::AddTraceMask((wxString const &)*arg1);
12569 wxPyEndAllowThreads(__tstate);
12570 if (PyErr_Occurred()) SWIG_fail;
12571 }
12572 resultobj = SWIG_Py_Void();
12573 {
12574 if (temp1)
12575 delete arg1;
12576 }
12577 return resultobj;
12578 fail:
12579 {
12580 if (temp1)
12581 delete arg1;
12582 }
12583 return NULL;
12584 }
12585
12586
12587 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12588 PyObject *resultobj = 0;
12589 wxString *arg1 = 0 ;
12590 bool temp1 = false ;
12591 PyObject * obj0 = 0 ;
12592 char * kwnames[] = {
12593 (char *) "str", NULL
12594 };
12595
12596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12597 {
12598 arg1 = wxString_in_helper(obj0);
12599 if (arg1 == NULL) SWIG_fail;
12600 temp1 = true;
12601 }
12602 {
12603 PyThreadState* __tstate = wxPyBeginAllowThreads();
12604 wxLog::RemoveTraceMask((wxString const &)*arg1);
12605 wxPyEndAllowThreads(__tstate);
12606 if (PyErr_Occurred()) SWIG_fail;
12607 }
12608 resultobj = SWIG_Py_Void();
12609 {
12610 if (temp1)
12611 delete arg1;
12612 }
12613 return resultobj;
12614 fail:
12615 {
12616 if (temp1)
12617 delete arg1;
12618 }
12619 return NULL;
12620 }
12621
12622
12623 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12624 PyObject *resultobj = 0;
12625
12626 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12627 {
12628 PyThreadState* __tstate = wxPyBeginAllowThreads();
12629 wxLog::ClearTraceMasks();
12630 wxPyEndAllowThreads(__tstate);
12631 if (PyErr_Occurred()) SWIG_fail;
12632 }
12633 resultobj = SWIG_Py_Void();
12634 return resultobj;
12635 fail:
12636 return NULL;
12637 }
12638
12639
12640 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12641 PyObject *resultobj = 0;
12642 wxArrayString *result = 0 ;
12643
12644 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12645 {
12646 PyThreadState* __tstate = wxPyBeginAllowThreads();
12647 {
12648 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12649 result = (wxArrayString *) &_result_ref;
12650 }
12651 wxPyEndAllowThreads(__tstate);
12652 if (PyErr_Occurred()) SWIG_fail;
12653 }
12654 {
12655 resultobj = wxArrayString2PyList_helper(*result);
12656 }
12657 return resultobj;
12658 fail:
12659 return NULL;
12660 }
12661
12662
12663 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12664 PyObject *resultobj = 0;
12665 wxChar *arg1 = (wxChar *) 0 ;
12666 void *argp1 = 0 ;
12667 int res1 = 0 ;
12668 PyObject * obj0 = 0 ;
12669 char * kwnames[] = {
12670 (char *) "ts", NULL
12671 };
12672
12673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12675 if (!SWIG_IsOK(res1)) {
12676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12677 }
12678 arg1 = reinterpret_cast< wxChar * >(argp1);
12679 {
12680 PyThreadState* __tstate = wxPyBeginAllowThreads();
12681 wxLog::SetTimestamp((wxChar const *)arg1);
12682 wxPyEndAllowThreads(__tstate);
12683 if (PyErr_Occurred()) SWIG_fail;
12684 }
12685 resultobj = SWIG_Py_Void();
12686 return resultobj;
12687 fail:
12688 return NULL;
12689 }
12690
12691
12692 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12693 PyObject *resultobj = 0;
12694 bool result;
12695
12696 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12697 {
12698 PyThreadState* __tstate = wxPyBeginAllowThreads();
12699 result = (bool)wxLog::GetVerbose();
12700 wxPyEndAllowThreads(__tstate);
12701 if (PyErr_Occurred()) SWIG_fail;
12702 }
12703 {
12704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12705 }
12706 return resultobj;
12707 fail:
12708 return NULL;
12709 }
12710
12711
12712 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12713 PyObject *resultobj = 0;
12714 wxTraceMask result;
12715
12716 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12717 {
12718 PyThreadState* __tstate = wxPyBeginAllowThreads();
12719 result = (wxTraceMask)wxLog::GetTraceMask();
12720 wxPyEndAllowThreads(__tstate);
12721 if (PyErr_Occurred()) SWIG_fail;
12722 }
12723 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12724 return resultobj;
12725 fail:
12726 return NULL;
12727 }
12728
12729
12730 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12731 PyObject *resultobj = 0;
12732 wxChar *arg1 = (wxChar *) 0 ;
12733 bool result;
12734 void *argp1 = 0 ;
12735 int res1 = 0 ;
12736 PyObject * obj0 = 0 ;
12737 char * kwnames[] = {
12738 (char *) "mask", NULL
12739 };
12740
12741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12743 if (!SWIG_IsOK(res1)) {
12744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12745 }
12746 arg1 = reinterpret_cast< wxChar * >(argp1);
12747 {
12748 PyThreadState* __tstate = wxPyBeginAllowThreads();
12749 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12750 wxPyEndAllowThreads(__tstate);
12751 if (PyErr_Occurred()) SWIG_fail;
12752 }
12753 {
12754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12755 }
12756 return resultobj;
12757 fail:
12758 return NULL;
12759 }
12760
12761
12762 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12763 PyObject *resultobj = 0;
12764 wxLogLevel result;
12765
12766 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12767 {
12768 PyThreadState* __tstate = wxPyBeginAllowThreads();
12769 result = (wxLogLevel)wxLog::GetLogLevel();
12770 wxPyEndAllowThreads(__tstate);
12771 if (PyErr_Occurred()) SWIG_fail;
12772 }
12773 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12774 return resultobj;
12775 fail:
12776 return NULL;
12777 }
12778
12779
12780 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12781 PyObject *resultobj = 0;
12782 wxChar *result = 0 ;
12783
12784 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12785 {
12786 PyThreadState* __tstate = wxPyBeginAllowThreads();
12787 result = (wxChar *)wxLog::GetTimestamp();
12788 wxPyEndAllowThreads(__tstate);
12789 if (PyErr_Occurred()) SWIG_fail;
12790 }
12791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12792 return resultobj;
12793 fail:
12794 return NULL;
12795 }
12796
12797
12798 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12799 PyObject *resultobj = 0;
12800 wxString result;
12801
12802 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12803 {
12804 PyThreadState* __tstate = wxPyBeginAllowThreads();
12805 result = wxLog_TimeStamp();
12806 wxPyEndAllowThreads(__tstate);
12807 if (PyErr_Occurred()) SWIG_fail;
12808 }
12809 {
12810 #if wxUSE_UNICODE
12811 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12812 #else
12813 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12814 #endif
12815 }
12816 return resultobj;
12817 fail:
12818 return NULL;
12819 }
12820
12821
12822 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12823 PyObject *resultobj = 0;
12824 wxLog *arg1 = (wxLog *) 0 ;
12825 void *argp1 = 0 ;
12826 int res1 = 0 ;
12827 PyObject *swig_obj[1] ;
12828
12829 if (!args) SWIG_fail;
12830 swig_obj[0] = args;
12831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12832 if (!SWIG_IsOK(res1)) {
12833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12834 }
12835 arg1 = reinterpret_cast< wxLog * >(argp1);
12836 {
12837 PyThreadState* __tstate = wxPyBeginAllowThreads();
12838 wxLog_Destroy(arg1);
12839 wxPyEndAllowThreads(__tstate);
12840 if (PyErr_Occurred()) SWIG_fail;
12841 }
12842 resultobj = SWIG_Py_Void();
12843 return resultobj;
12844 fail:
12845 return NULL;
12846 }
12847
12848
12849 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12850 PyObject *obj;
12851 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12852 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12853 return SWIG_Py_Void();
12854 }
12855
12856 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12857 return SWIG_Python_InitShadowInstance(args);
12858 }
12859
12860 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12861 PyObject *resultobj = 0;
12862 wxLogStderr *result = 0 ;
12863
12864 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12865 {
12866 PyThreadState* __tstate = wxPyBeginAllowThreads();
12867 result = (wxLogStderr *)new wxLogStderr();
12868 wxPyEndAllowThreads(__tstate);
12869 if (PyErr_Occurred()) SWIG_fail;
12870 }
12871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12872 return resultobj;
12873 fail:
12874 return NULL;
12875 }
12876
12877
12878 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12879 PyObject *obj;
12880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12881 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12882 return SWIG_Py_Void();
12883 }
12884
12885 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12886 return SWIG_Python_InitShadowInstance(args);
12887 }
12888
12889 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12890 PyObject *resultobj = 0;
12891 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12892 wxLogTextCtrl *result = 0 ;
12893 void *argp1 = 0 ;
12894 int res1 = 0 ;
12895 PyObject * obj0 = 0 ;
12896 char * kwnames[] = {
12897 (char *) "pTextCtrl", NULL
12898 };
12899
12900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12902 if (!SWIG_IsOK(res1)) {
12903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12904 }
12905 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12906 {
12907 PyThreadState* __tstate = wxPyBeginAllowThreads();
12908 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12909 wxPyEndAllowThreads(__tstate);
12910 if (PyErr_Occurred()) SWIG_fail;
12911 }
12912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12913 return resultobj;
12914 fail:
12915 return NULL;
12916 }
12917
12918
12919 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12920 PyObject *obj;
12921 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12922 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12923 return SWIG_Py_Void();
12924 }
12925
12926 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12927 return SWIG_Python_InitShadowInstance(args);
12928 }
12929
12930 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12931 PyObject *resultobj = 0;
12932 wxLogGui *result = 0 ;
12933
12934 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12935 {
12936 PyThreadState* __tstate = wxPyBeginAllowThreads();
12937 result = (wxLogGui *)new wxLogGui();
12938 wxPyEndAllowThreads(__tstate);
12939 if (PyErr_Occurred()) SWIG_fail;
12940 }
12941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12942 return resultobj;
12943 fail:
12944 return NULL;
12945 }
12946
12947
12948 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12949 PyObject *obj;
12950 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12951 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12952 return SWIG_Py_Void();
12953 }
12954
12955 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12956 return SWIG_Python_InitShadowInstance(args);
12957 }
12958
12959 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12960 PyObject *resultobj = 0;
12961 wxFrame *arg1 = (wxFrame *) 0 ;
12962 wxString *arg2 = 0 ;
12963 bool arg3 = (bool) true ;
12964 bool arg4 = (bool) true ;
12965 wxLogWindow *result = 0 ;
12966 void *argp1 = 0 ;
12967 int res1 = 0 ;
12968 bool temp2 = false ;
12969 bool val3 ;
12970 int ecode3 = 0 ;
12971 bool val4 ;
12972 int ecode4 = 0 ;
12973 PyObject * obj0 = 0 ;
12974 PyObject * obj1 = 0 ;
12975 PyObject * obj2 = 0 ;
12976 PyObject * obj3 = 0 ;
12977 char * kwnames[] = {
12978 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
12979 };
12980
12981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12983 if (!SWIG_IsOK(res1)) {
12984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
12985 }
12986 arg1 = reinterpret_cast< wxFrame * >(argp1);
12987 {
12988 arg2 = wxString_in_helper(obj1);
12989 if (arg2 == NULL) SWIG_fail;
12990 temp2 = true;
12991 }
12992 if (obj2) {
12993 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12994 if (!SWIG_IsOK(ecode3)) {
12995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
12996 }
12997 arg3 = static_cast< bool >(val3);
12998 }
12999 if (obj3) {
13000 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13001 if (!SWIG_IsOK(ecode4)) {
13002 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13003 }
13004 arg4 = static_cast< bool >(val4);
13005 }
13006 {
13007 PyThreadState* __tstate = wxPyBeginAllowThreads();
13008 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13009 wxPyEndAllowThreads(__tstate);
13010 if (PyErr_Occurred()) SWIG_fail;
13011 }
13012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13013 {
13014 if (temp2)
13015 delete arg2;
13016 }
13017 return resultobj;
13018 fail:
13019 {
13020 if (temp2)
13021 delete arg2;
13022 }
13023 return NULL;
13024 }
13025
13026
13027 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13028 PyObject *resultobj = 0;
13029 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13030 bool arg2 = (bool) true ;
13031 void *argp1 = 0 ;
13032 int res1 = 0 ;
13033 bool val2 ;
13034 int ecode2 = 0 ;
13035 PyObject * obj0 = 0 ;
13036 PyObject * obj1 = 0 ;
13037 char * kwnames[] = {
13038 (char *) "self",(char *) "bShow", NULL
13039 };
13040
13041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13043 if (!SWIG_IsOK(res1)) {
13044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13045 }
13046 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13047 if (obj1) {
13048 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13049 if (!SWIG_IsOK(ecode2)) {
13050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13051 }
13052 arg2 = static_cast< bool >(val2);
13053 }
13054 {
13055 PyThreadState* __tstate = wxPyBeginAllowThreads();
13056 (arg1)->Show(arg2);
13057 wxPyEndAllowThreads(__tstate);
13058 if (PyErr_Occurred()) SWIG_fail;
13059 }
13060 resultobj = SWIG_Py_Void();
13061 return resultobj;
13062 fail:
13063 return NULL;
13064 }
13065
13066
13067 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13068 PyObject *resultobj = 0;
13069 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13070 wxFrame *result = 0 ;
13071 void *argp1 = 0 ;
13072 int res1 = 0 ;
13073 PyObject *swig_obj[1] ;
13074
13075 if (!args) SWIG_fail;
13076 swig_obj[0] = args;
13077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13078 if (!SWIG_IsOK(res1)) {
13079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13080 }
13081 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13082 {
13083 PyThreadState* __tstate = wxPyBeginAllowThreads();
13084 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13085 wxPyEndAllowThreads(__tstate);
13086 if (PyErr_Occurred()) SWIG_fail;
13087 }
13088 {
13089 resultobj = wxPyMake_wxObject(result, (bool)0);
13090 }
13091 return resultobj;
13092 fail:
13093 return NULL;
13094 }
13095
13096
13097 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13098 PyObject *resultobj = 0;
13099 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13100 wxLog *result = 0 ;
13101 void *argp1 = 0 ;
13102 int res1 = 0 ;
13103 PyObject *swig_obj[1] ;
13104
13105 if (!args) SWIG_fail;
13106 swig_obj[0] = args;
13107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13108 if (!SWIG_IsOK(res1)) {
13109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13110 }
13111 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13112 {
13113 PyThreadState* __tstate = wxPyBeginAllowThreads();
13114 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13115 wxPyEndAllowThreads(__tstate);
13116 if (PyErr_Occurred()) SWIG_fail;
13117 }
13118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13119 return resultobj;
13120 fail:
13121 return NULL;
13122 }
13123
13124
13125 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13126 PyObject *resultobj = 0;
13127 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13128 bool result;
13129 void *argp1 = 0 ;
13130 int res1 = 0 ;
13131 PyObject *swig_obj[1] ;
13132
13133 if (!args) SWIG_fail;
13134 swig_obj[0] = args;
13135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13136 if (!SWIG_IsOK(res1)) {
13137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13138 }
13139 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13140 {
13141 PyThreadState* __tstate = wxPyBeginAllowThreads();
13142 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13143 wxPyEndAllowThreads(__tstate);
13144 if (PyErr_Occurred()) SWIG_fail;
13145 }
13146 {
13147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13148 }
13149 return resultobj;
13150 fail:
13151 return NULL;
13152 }
13153
13154
13155 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13156 PyObject *resultobj = 0;
13157 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13158 bool arg2 ;
13159 void *argp1 = 0 ;
13160 int res1 = 0 ;
13161 bool val2 ;
13162 int ecode2 = 0 ;
13163 PyObject * obj0 = 0 ;
13164 PyObject * obj1 = 0 ;
13165 char * kwnames[] = {
13166 (char *) "self",(char *) "bDoPass", NULL
13167 };
13168
13169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13171 if (!SWIG_IsOK(res1)) {
13172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13173 }
13174 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13175 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13176 if (!SWIG_IsOK(ecode2)) {
13177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13178 }
13179 arg2 = static_cast< bool >(val2);
13180 {
13181 PyThreadState* __tstate = wxPyBeginAllowThreads();
13182 (arg1)->PassMessages(arg2);
13183 wxPyEndAllowThreads(__tstate);
13184 if (PyErr_Occurred()) SWIG_fail;
13185 }
13186 resultobj = SWIG_Py_Void();
13187 return resultobj;
13188 fail:
13189 return NULL;
13190 }
13191
13192
13193 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13194 PyObject *obj;
13195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13196 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13197 return SWIG_Py_Void();
13198 }
13199
13200 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13201 return SWIG_Python_InitShadowInstance(args);
13202 }
13203
13204 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13205 PyObject *resultobj = 0;
13206 wxLog *arg1 = (wxLog *) 0 ;
13207 wxLogChain *result = 0 ;
13208 void *argp1 = 0 ;
13209 int res1 = 0 ;
13210 PyObject * obj0 = 0 ;
13211 char * kwnames[] = {
13212 (char *) "logger", NULL
13213 };
13214
13215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13217 if (!SWIG_IsOK(res1)) {
13218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13219 }
13220 arg1 = reinterpret_cast< wxLog * >(argp1);
13221 {
13222 PyThreadState* __tstate = wxPyBeginAllowThreads();
13223 result = (wxLogChain *)new wxLogChain(arg1);
13224 wxPyEndAllowThreads(__tstate);
13225 if (PyErr_Occurred()) SWIG_fail;
13226 }
13227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13228 return resultobj;
13229 fail:
13230 return NULL;
13231 }
13232
13233
13234 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13235 PyObject *resultobj = 0;
13236 wxLogChain *arg1 = (wxLogChain *) 0 ;
13237 wxLog *arg2 = (wxLog *) 0 ;
13238 void *argp1 = 0 ;
13239 int res1 = 0 ;
13240 void *argp2 = 0 ;
13241 int res2 = 0 ;
13242 PyObject * obj0 = 0 ;
13243 PyObject * obj1 = 0 ;
13244 char * kwnames[] = {
13245 (char *) "self",(char *) "logger", NULL
13246 };
13247
13248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13250 if (!SWIG_IsOK(res1)) {
13251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13252 }
13253 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13254 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13255 if (!SWIG_IsOK(res2)) {
13256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13257 }
13258 arg2 = reinterpret_cast< wxLog * >(argp2);
13259 {
13260 PyThreadState* __tstate = wxPyBeginAllowThreads();
13261 (arg1)->SetLog(arg2);
13262 wxPyEndAllowThreads(__tstate);
13263 if (PyErr_Occurred()) SWIG_fail;
13264 }
13265 resultobj = SWIG_Py_Void();
13266 return resultobj;
13267 fail:
13268 return NULL;
13269 }
13270
13271
13272 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13273 PyObject *resultobj = 0;
13274 wxLogChain *arg1 = (wxLogChain *) 0 ;
13275 bool arg2 ;
13276 void *argp1 = 0 ;
13277 int res1 = 0 ;
13278 bool val2 ;
13279 int ecode2 = 0 ;
13280 PyObject * obj0 = 0 ;
13281 PyObject * obj1 = 0 ;
13282 char * kwnames[] = {
13283 (char *) "self",(char *) "bDoPass", NULL
13284 };
13285
13286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13288 if (!SWIG_IsOK(res1)) {
13289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13290 }
13291 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13292 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13293 if (!SWIG_IsOK(ecode2)) {
13294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13295 }
13296 arg2 = static_cast< bool >(val2);
13297 {
13298 PyThreadState* __tstate = wxPyBeginAllowThreads();
13299 (arg1)->PassMessages(arg2);
13300 wxPyEndAllowThreads(__tstate);
13301 if (PyErr_Occurred()) SWIG_fail;
13302 }
13303 resultobj = SWIG_Py_Void();
13304 return resultobj;
13305 fail:
13306 return NULL;
13307 }
13308
13309
13310 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13311 PyObject *resultobj = 0;
13312 wxLogChain *arg1 = (wxLogChain *) 0 ;
13313 bool result;
13314 void *argp1 = 0 ;
13315 int res1 = 0 ;
13316 PyObject *swig_obj[1] ;
13317
13318 if (!args) SWIG_fail;
13319 swig_obj[0] = args;
13320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13321 if (!SWIG_IsOK(res1)) {
13322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13323 }
13324 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13325 {
13326 PyThreadState* __tstate = wxPyBeginAllowThreads();
13327 result = (bool)(arg1)->IsPassingMessages();
13328 wxPyEndAllowThreads(__tstate);
13329 if (PyErr_Occurred()) SWIG_fail;
13330 }
13331 {
13332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13333 }
13334 return resultobj;
13335 fail:
13336 return NULL;
13337 }
13338
13339
13340 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13341 PyObject *resultobj = 0;
13342 wxLogChain *arg1 = (wxLogChain *) 0 ;
13343 wxLog *result = 0 ;
13344 void *argp1 = 0 ;
13345 int res1 = 0 ;
13346 PyObject *swig_obj[1] ;
13347
13348 if (!args) SWIG_fail;
13349 swig_obj[0] = args;
13350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13351 if (!SWIG_IsOK(res1)) {
13352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13353 }
13354 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13355 {
13356 PyThreadState* __tstate = wxPyBeginAllowThreads();
13357 result = (wxLog *)(arg1)->GetOldLog();
13358 wxPyEndAllowThreads(__tstate);
13359 if (PyErr_Occurred()) SWIG_fail;
13360 }
13361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13362 return resultobj;
13363 fail:
13364 return NULL;
13365 }
13366
13367
13368 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13369 PyObject *obj;
13370 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13371 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13372 return SWIG_Py_Void();
13373 }
13374
13375 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13376 return SWIG_Python_InitShadowInstance(args);
13377 }
13378
13379 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13380 PyObject *resultobj = 0;
13381 wxLogBuffer *result = 0 ;
13382
13383 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13384 {
13385 PyThreadState* __tstate = wxPyBeginAllowThreads();
13386 result = (wxLogBuffer *)new wxLogBuffer();
13387 wxPyEndAllowThreads(__tstate);
13388 if (PyErr_Occurred()) SWIG_fail;
13389 }
13390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13391 return resultobj;
13392 fail:
13393 return NULL;
13394 }
13395
13396
13397 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13398 PyObject *resultobj = 0;
13399 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13400 wxString *result = 0 ;
13401 void *argp1 = 0 ;
13402 int res1 = 0 ;
13403 PyObject *swig_obj[1] ;
13404
13405 if (!args) SWIG_fail;
13406 swig_obj[0] = args;
13407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13408 if (!SWIG_IsOK(res1)) {
13409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13410 }
13411 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13412 {
13413 PyThreadState* __tstate = wxPyBeginAllowThreads();
13414 {
13415 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13416 result = (wxString *) &_result_ref;
13417 }
13418 wxPyEndAllowThreads(__tstate);
13419 if (PyErr_Occurred()) SWIG_fail;
13420 }
13421 {
13422 #if wxUSE_UNICODE
13423 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13424 #else
13425 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13426 #endif
13427 }
13428 return resultobj;
13429 fail:
13430 return NULL;
13431 }
13432
13433
13434 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13435 PyObject *obj;
13436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13437 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13438 return SWIG_Py_Void();
13439 }
13440
13441 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13442 return SWIG_Python_InitShadowInstance(args);
13443 }
13444
13445 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13446 PyObject *resultobj = 0;
13447 unsigned long result;
13448
13449 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13450 {
13451 PyThreadState* __tstate = wxPyBeginAllowThreads();
13452 result = (unsigned long)wxSysErrorCode();
13453 wxPyEndAllowThreads(__tstate);
13454 if (PyErr_Occurred()) SWIG_fail;
13455 }
13456 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13457 return resultobj;
13458 fail:
13459 return NULL;
13460 }
13461
13462
13463 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13464 PyObject *resultobj = 0;
13465 unsigned long arg1 = (unsigned long) 0 ;
13466 wxString result;
13467 unsigned long val1 ;
13468 int ecode1 = 0 ;
13469 PyObject * obj0 = 0 ;
13470 char * kwnames[] = {
13471 (char *) "nErrCode", NULL
13472 };
13473
13474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13475 if (obj0) {
13476 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13477 if (!SWIG_IsOK(ecode1)) {
13478 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13479 }
13480 arg1 = static_cast< unsigned long >(val1);
13481 }
13482 {
13483 PyThreadState* __tstate = wxPyBeginAllowThreads();
13484 result = wxSysErrorMsg(arg1);
13485 wxPyEndAllowThreads(__tstate);
13486 if (PyErr_Occurred()) SWIG_fail;
13487 }
13488 {
13489 #if wxUSE_UNICODE
13490 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13491 #else
13492 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13493 #endif
13494 }
13495 return resultobj;
13496 fail:
13497 return NULL;
13498 }
13499
13500
13501 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13502 PyObject *resultobj = 0;
13503 wxString *arg1 = 0 ;
13504 bool temp1 = false ;
13505 PyObject * obj0 = 0 ;
13506 char * kwnames[] = {
13507 (char *) "msg", NULL
13508 };
13509
13510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13511 {
13512 arg1 = wxString_in_helper(obj0);
13513 if (arg1 == NULL) SWIG_fail;
13514 temp1 = true;
13515 }
13516 {
13517 PyThreadState* __tstate = wxPyBeginAllowThreads();
13518 wxPyLogFatalError((wxString const &)*arg1);
13519 wxPyEndAllowThreads(__tstate);
13520 if (PyErr_Occurred()) SWIG_fail;
13521 }
13522 resultobj = SWIG_Py_Void();
13523 {
13524 if (temp1)
13525 delete arg1;
13526 }
13527 return resultobj;
13528 fail:
13529 {
13530 if (temp1)
13531 delete arg1;
13532 }
13533 return NULL;
13534 }
13535
13536
13537 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13538 PyObject *resultobj = 0;
13539 wxString *arg1 = 0 ;
13540 bool temp1 = false ;
13541 PyObject * obj0 = 0 ;
13542 char * kwnames[] = {
13543 (char *) "msg", NULL
13544 };
13545
13546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13547 {
13548 arg1 = wxString_in_helper(obj0);
13549 if (arg1 == NULL) SWIG_fail;
13550 temp1 = true;
13551 }
13552 {
13553 PyThreadState* __tstate = wxPyBeginAllowThreads();
13554 wxPyLogError((wxString const &)*arg1);
13555 wxPyEndAllowThreads(__tstate);
13556 if (PyErr_Occurred()) SWIG_fail;
13557 }
13558 resultobj = SWIG_Py_Void();
13559 {
13560 if (temp1)
13561 delete arg1;
13562 }
13563 return resultobj;
13564 fail:
13565 {
13566 if (temp1)
13567 delete arg1;
13568 }
13569 return NULL;
13570 }
13571
13572
13573 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13574 PyObject *resultobj = 0;
13575 wxString *arg1 = 0 ;
13576 bool temp1 = false ;
13577 PyObject * obj0 = 0 ;
13578 char * kwnames[] = {
13579 (char *) "msg", NULL
13580 };
13581
13582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13583 {
13584 arg1 = wxString_in_helper(obj0);
13585 if (arg1 == NULL) SWIG_fail;
13586 temp1 = true;
13587 }
13588 {
13589 PyThreadState* __tstate = wxPyBeginAllowThreads();
13590 wxPyLogWarning((wxString const &)*arg1);
13591 wxPyEndAllowThreads(__tstate);
13592 if (PyErr_Occurred()) SWIG_fail;
13593 }
13594 resultobj = SWIG_Py_Void();
13595 {
13596 if (temp1)
13597 delete arg1;
13598 }
13599 return resultobj;
13600 fail:
13601 {
13602 if (temp1)
13603 delete arg1;
13604 }
13605 return NULL;
13606 }
13607
13608
13609 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13610 PyObject *resultobj = 0;
13611 wxString *arg1 = 0 ;
13612 bool temp1 = false ;
13613 PyObject * obj0 = 0 ;
13614 char * kwnames[] = {
13615 (char *) "msg", NULL
13616 };
13617
13618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13619 {
13620 arg1 = wxString_in_helper(obj0);
13621 if (arg1 == NULL) SWIG_fail;
13622 temp1 = true;
13623 }
13624 {
13625 PyThreadState* __tstate = wxPyBeginAllowThreads();
13626 wxPyLogMessage((wxString const &)*arg1);
13627 wxPyEndAllowThreads(__tstate);
13628 if (PyErr_Occurred()) SWIG_fail;
13629 }
13630 resultobj = SWIG_Py_Void();
13631 {
13632 if (temp1)
13633 delete arg1;
13634 }
13635 return resultobj;
13636 fail:
13637 {
13638 if (temp1)
13639 delete arg1;
13640 }
13641 return NULL;
13642 }
13643
13644
13645 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13646 PyObject *resultobj = 0;
13647 wxString *arg1 = 0 ;
13648 bool temp1 = false ;
13649 PyObject * obj0 = 0 ;
13650 char * kwnames[] = {
13651 (char *) "msg", NULL
13652 };
13653
13654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13655 {
13656 arg1 = wxString_in_helper(obj0);
13657 if (arg1 == NULL) SWIG_fail;
13658 temp1 = true;
13659 }
13660 {
13661 PyThreadState* __tstate = wxPyBeginAllowThreads();
13662 wxPyLogInfo((wxString const &)*arg1);
13663 wxPyEndAllowThreads(__tstate);
13664 if (PyErr_Occurred()) SWIG_fail;
13665 }
13666 resultobj = SWIG_Py_Void();
13667 {
13668 if (temp1)
13669 delete arg1;
13670 }
13671 return resultobj;
13672 fail:
13673 {
13674 if (temp1)
13675 delete arg1;
13676 }
13677 return NULL;
13678 }
13679
13680
13681 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13682 PyObject *resultobj = 0;
13683 wxString *arg1 = 0 ;
13684 bool temp1 = false ;
13685 PyObject * obj0 = 0 ;
13686 char * kwnames[] = {
13687 (char *) "msg", NULL
13688 };
13689
13690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13691 {
13692 arg1 = wxString_in_helper(obj0);
13693 if (arg1 == NULL) SWIG_fail;
13694 temp1 = true;
13695 }
13696 {
13697 PyThreadState* __tstate = wxPyBeginAllowThreads();
13698 wxPyLogDebug((wxString const &)*arg1);
13699 wxPyEndAllowThreads(__tstate);
13700 if (PyErr_Occurred()) SWIG_fail;
13701 }
13702 resultobj = SWIG_Py_Void();
13703 {
13704 if (temp1)
13705 delete arg1;
13706 }
13707 return resultobj;
13708 fail:
13709 {
13710 if (temp1)
13711 delete arg1;
13712 }
13713 return NULL;
13714 }
13715
13716
13717 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13718 PyObject *resultobj = 0;
13719 wxString *arg1 = 0 ;
13720 bool temp1 = false ;
13721 PyObject * obj0 = 0 ;
13722 char * kwnames[] = {
13723 (char *) "msg", NULL
13724 };
13725
13726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13727 {
13728 arg1 = wxString_in_helper(obj0);
13729 if (arg1 == NULL) SWIG_fail;
13730 temp1 = true;
13731 }
13732 {
13733 PyThreadState* __tstate = wxPyBeginAllowThreads();
13734 wxPyLogVerbose((wxString const &)*arg1);
13735 wxPyEndAllowThreads(__tstate);
13736 if (PyErr_Occurred()) SWIG_fail;
13737 }
13738 resultobj = SWIG_Py_Void();
13739 {
13740 if (temp1)
13741 delete arg1;
13742 }
13743 return resultobj;
13744 fail:
13745 {
13746 if (temp1)
13747 delete arg1;
13748 }
13749 return NULL;
13750 }
13751
13752
13753 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13754 PyObject *resultobj = 0;
13755 wxString *arg1 = 0 ;
13756 bool temp1 = false ;
13757 PyObject * obj0 = 0 ;
13758 char * kwnames[] = {
13759 (char *) "msg", NULL
13760 };
13761
13762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13763 {
13764 arg1 = wxString_in_helper(obj0);
13765 if (arg1 == NULL) SWIG_fail;
13766 temp1 = true;
13767 }
13768 {
13769 PyThreadState* __tstate = wxPyBeginAllowThreads();
13770 wxPyLogStatus((wxString const &)*arg1);
13771 wxPyEndAllowThreads(__tstate);
13772 if (PyErr_Occurred()) SWIG_fail;
13773 }
13774 resultobj = SWIG_Py_Void();
13775 {
13776 if (temp1)
13777 delete arg1;
13778 }
13779 return resultobj;
13780 fail:
13781 {
13782 if (temp1)
13783 delete arg1;
13784 }
13785 return NULL;
13786 }
13787
13788
13789 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13790 PyObject *resultobj = 0;
13791 wxFrame *arg1 = (wxFrame *) 0 ;
13792 wxString *arg2 = 0 ;
13793 void *argp1 = 0 ;
13794 int res1 = 0 ;
13795 bool temp2 = false ;
13796 PyObject * obj0 = 0 ;
13797 PyObject * obj1 = 0 ;
13798 char * kwnames[] = {
13799 (char *) "pFrame",(char *) "msg", NULL
13800 };
13801
13802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13804 if (!SWIG_IsOK(res1)) {
13805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13806 }
13807 arg1 = reinterpret_cast< wxFrame * >(argp1);
13808 {
13809 arg2 = wxString_in_helper(obj1);
13810 if (arg2 == NULL) SWIG_fail;
13811 temp2 = true;
13812 }
13813 {
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13816 wxPyEndAllowThreads(__tstate);
13817 if (PyErr_Occurred()) SWIG_fail;
13818 }
13819 resultobj = SWIG_Py_Void();
13820 {
13821 if (temp2)
13822 delete arg2;
13823 }
13824 return resultobj;
13825 fail:
13826 {
13827 if (temp2)
13828 delete arg2;
13829 }
13830 return NULL;
13831 }
13832
13833
13834 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13835 PyObject *resultobj = 0;
13836 wxString *arg1 = 0 ;
13837 bool temp1 = false ;
13838 PyObject * obj0 = 0 ;
13839 char * kwnames[] = {
13840 (char *) "msg", NULL
13841 };
13842
13843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13844 {
13845 arg1 = wxString_in_helper(obj0);
13846 if (arg1 == NULL) SWIG_fail;
13847 temp1 = true;
13848 }
13849 {
13850 PyThreadState* __tstate = wxPyBeginAllowThreads();
13851 wxPyLogSysError((wxString const &)*arg1);
13852 wxPyEndAllowThreads(__tstate);
13853 if (PyErr_Occurred()) SWIG_fail;
13854 }
13855 resultobj = SWIG_Py_Void();
13856 {
13857 if (temp1)
13858 delete arg1;
13859 }
13860 return resultobj;
13861 fail:
13862 {
13863 if (temp1)
13864 delete arg1;
13865 }
13866 return NULL;
13867 }
13868
13869
13870 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13871 PyObject *resultobj = 0;
13872 unsigned long arg1 ;
13873 wxString *arg2 = 0 ;
13874 unsigned long val1 ;
13875 int ecode1 = 0 ;
13876 bool temp2 = false ;
13877 PyObject * obj0 = 0 ;
13878 PyObject * obj1 = 0 ;
13879 char * kwnames[] = {
13880 (char *) "level",(char *) "msg", NULL
13881 };
13882
13883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13884 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13885 if (!SWIG_IsOK(ecode1)) {
13886 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13887 }
13888 arg1 = static_cast< unsigned long >(val1);
13889 {
13890 arg2 = wxString_in_helper(obj1);
13891 if (arg2 == NULL) SWIG_fail;
13892 temp2 = true;
13893 }
13894 {
13895 PyThreadState* __tstate = wxPyBeginAllowThreads();
13896 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13897 wxPyEndAllowThreads(__tstate);
13898 if (PyErr_Occurred()) SWIG_fail;
13899 }
13900 resultobj = SWIG_Py_Void();
13901 {
13902 if (temp2)
13903 delete arg2;
13904 }
13905 return resultobj;
13906 fail:
13907 {
13908 if (temp2)
13909 delete arg2;
13910 }
13911 return NULL;
13912 }
13913
13914
13915 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13916 PyObject *resultobj = 0;
13917 unsigned long arg1 ;
13918 wxString *arg2 = 0 ;
13919 unsigned long val1 ;
13920 int ecode1 = 0 ;
13921 bool temp2 = false ;
13922
13923 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13924 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13925 if (!SWIG_IsOK(ecode1)) {
13926 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13927 }
13928 arg1 = static_cast< unsigned long >(val1);
13929 {
13930 arg2 = wxString_in_helper(swig_obj[1]);
13931 if (arg2 == NULL) SWIG_fail;
13932 temp2 = true;
13933 }
13934 {
13935 PyThreadState* __tstate = wxPyBeginAllowThreads();
13936 wxPyLogTrace(arg1,(wxString const &)*arg2);
13937 wxPyEndAllowThreads(__tstate);
13938 if (PyErr_Occurred()) SWIG_fail;
13939 }
13940 resultobj = SWIG_Py_Void();
13941 {
13942 if (temp2)
13943 delete arg2;
13944 }
13945 return resultobj;
13946 fail:
13947 {
13948 if (temp2)
13949 delete arg2;
13950 }
13951 return NULL;
13952 }
13953
13954
13955 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13956 PyObject *resultobj = 0;
13957 wxString *arg1 = 0 ;
13958 wxString *arg2 = 0 ;
13959 bool temp1 = false ;
13960 bool temp2 = false ;
13961
13962 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13963 {
13964 arg1 = wxString_in_helper(swig_obj[0]);
13965 if (arg1 == NULL) SWIG_fail;
13966 temp1 = true;
13967 }
13968 {
13969 arg2 = wxString_in_helper(swig_obj[1]);
13970 if (arg2 == NULL) SWIG_fail;
13971 temp2 = true;
13972 }
13973 {
13974 PyThreadState* __tstate = wxPyBeginAllowThreads();
13975 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
13976 wxPyEndAllowThreads(__tstate);
13977 if (PyErr_Occurred()) SWIG_fail;
13978 }
13979 resultobj = SWIG_Py_Void();
13980 {
13981 if (temp1)
13982 delete arg1;
13983 }
13984 {
13985 if (temp2)
13986 delete arg2;
13987 }
13988 return resultobj;
13989 fail:
13990 {
13991 if (temp1)
13992 delete arg1;
13993 }
13994 {
13995 if (temp2)
13996 delete arg2;
13997 }
13998 return NULL;
13999 }
14000
14001
14002 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14003 int argc;
14004 PyObject *argv[3];
14005
14006 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14007 --argc;
14008 if (argc == 2) {
14009 int _v = 0;
14010 {
14011 {
14012 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14013 }
14014 }
14015 if (!_v) goto check_1;
14016 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14017 }
14018 check_1:
14019
14020 if (argc == 2) {
14021 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14022 }
14023
14024 fail:
14025 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14026 return NULL;
14027 }
14028
14029
14030 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14031 PyObject *resultobj = 0;
14032 wxString *arg1 = 0 ;
14033 wxString *arg2 = 0 ;
14034 bool temp1 = false ;
14035 bool temp2 = false ;
14036 PyObject * obj0 = 0 ;
14037 PyObject * obj1 = 0 ;
14038 char * kwnames[] = {
14039 (char *) "title",(char *) "text", NULL
14040 };
14041
14042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14043 {
14044 arg1 = wxString_in_helper(obj0);
14045 if (arg1 == NULL) SWIG_fail;
14046 temp1 = true;
14047 }
14048 {
14049 arg2 = wxString_in_helper(obj1);
14050 if (arg2 == NULL) SWIG_fail;
14051 temp2 = true;
14052 }
14053 {
14054 PyThreadState* __tstate = wxPyBeginAllowThreads();
14055 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14056 wxPyEndAllowThreads(__tstate);
14057 if (PyErr_Occurred()) SWIG_fail;
14058 }
14059 resultobj = SWIG_Py_Void();
14060 {
14061 if (temp1)
14062 delete arg1;
14063 }
14064 {
14065 if (temp2)
14066 delete arg2;
14067 }
14068 return resultobj;
14069 fail:
14070 {
14071 if (temp1)
14072 delete arg1;
14073 }
14074 {
14075 if (temp2)
14076 delete arg2;
14077 }
14078 return NULL;
14079 }
14080
14081
14082 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14083 PyObject *resultobj = 0;
14084 wxLogNull *result = 0 ;
14085
14086 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14087 {
14088 PyThreadState* __tstate = wxPyBeginAllowThreads();
14089 result = (wxLogNull *)new wxLogNull();
14090 wxPyEndAllowThreads(__tstate);
14091 if (PyErr_Occurred()) SWIG_fail;
14092 }
14093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14094 return resultobj;
14095 fail:
14096 return NULL;
14097 }
14098
14099
14100 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14101 PyObject *resultobj = 0;
14102 wxLogNull *arg1 = (wxLogNull *) 0 ;
14103 void *argp1 = 0 ;
14104 int res1 = 0 ;
14105 PyObject *swig_obj[1] ;
14106
14107 if (!args) SWIG_fail;
14108 swig_obj[0] = args;
14109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14110 if (!SWIG_IsOK(res1)) {
14111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14112 }
14113 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14114 {
14115 PyThreadState* __tstate = wxPyBeginAllowThreads();
14116 delete arg1;
14117
14118 wxPyEndAllowThreads(__tstate);
14119 if (PyErr_Occurred()) SWIG_fail;
14120 }
14121 resultobj = SWIG_Py_Void();
14122 return resultobj;
14123 fail:
14124 return NULL;
14125 }
14126
14127
14128 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14129 PyObject *obj;
14130 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14131 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14132 return SWIG_Py_Void();
14133 }
14134
14135 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14136 return SWIG_Python_InitShadowInstance(args);
14137 }
14138
14139 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14140 PyObject *resultobj = 0;
14141 wxPyLog *result = 0 ;
14142
14143 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14144 {
14145 PyThreadState* __tstate = wxPyBeginAllowThreads();
14146 result = (wxPyLog *)new wxPyLog();
14147 wxPyEndAllowThreads(__tstate);
14148 if (PyErr_Occurred()) SWIG_fail;
14149 }
14150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14151 return resultobj;
14152 fail:
14153 return NULL;
14154 }
14155
14156
14157 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14158 PyObject *resultobj = 0;
14159 wxPyLog *arg1 = (wxPyLog *) 0 ;
14160 PyObject *arg2 = (PyObject *) 0 ;
14161 PyObject *arg3 = (PyObject *) 0 ;
14162 void *argp1 = 0 ;
14163 int res1 = 0 ;
14164 PyObject * obj0 = 0 ;
14165 PyObject * obj1 = 0 ;
14166 PyObject * obj2 = 0 ;
14167 char * kwnames[] = {
14168 (char *) "self",(char *) "self",(char *) "_class", NULL
14169 };
14170
14171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14173 if (!SWIG_IsOK(res1)) {
14174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14175 }
14176 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14177 arg2 = obj1;
14178 arg3 = obj2;
14179 {
14180 PyThreadState* __tstate = wxPyBeginAllowThreads();
14181 (arg1)->_setCallbackInfo(arg2,arg3);
14182 wxPyEndAllowThreads(__tstate);
14183 if (PyErr_Occurred()) SWIG_fail;
14184 }
14185 resultobj = SWIG_Py_Void();
14186 return resultobj;
14187 fail:
14188 return NULL;
14189 }
14190
14191
14192 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14193 PyObject *obj;
14194 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14195 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14196 return SWIG_Py_Void();
14197 }
14198
14199 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14200 return SWIG_Python_InitShadowInstance(args);
14201 }
14202
14203 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14204 PyObject *resultobj = 0;
14205 int arg1 ;
14206 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14207 int arg3 = (int) wxKILL_NOCHILDREN ;
14208 wxKillError result;
14209 int val1 ;
14210 int ecode1 = 0 ;
14211 int val2 ;
14212 int ecode2 = 0 ;
14213 int val3 ;
14214 int ecode3 = 0 ;
14215 PyObject * obj0 = 0 ;
14216 PyObject * obj1 = 0 ;
14217 PyObject * obj2 = 0 ;
14218 char * kwnames[] = {
14219 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14220 };
14221
14222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14223 ecode1 = SWIG_AsVal_int(obj0, &val1);
14224 if (!SWIG_IsOK(ecode1)) {
14225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14226 }
14227 arg1 = static_cast< int >(val1);
14228 if (obj1) {
14229 ecode2 = SWIG_AsVal_int(obj1, &val2);
14230 if (!SWIG_IsOK(ecode2)) {
14231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14232 }
14233 arg2 = static_cast< wxSignal >(val2);
14234 }
14235 if (obj2) {
14236 ecode3 = SWIG_AsVal_int(obj2, &val3);
14237 if (!SWIG_IsOK(ecode3)) {
14238 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14239 }
14240 arg3 = static_cast< int >(val3);
14241 }
14242 {
14243 PyThreadState* __tstate = wxPyBeginAllowThreads();
14244 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14245 wxPyEndAllowThreads(__tstate);
14246 if (PyErr_Occurred()) SWIG_fail;
14247 }
14248 resultobj = SWIG_From_int(static_cast< int >(result));
14249 return resultobj;
14250 fail:
14251 return NULL;
14252 }
14253
14254
14255 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14256 PyObject *resultobj = 0;
14257 int arg1 ;
14258 bool result;
14259 int val1 ;
14260 int ecode1 = 0 ;
14261 PyObject * obj0 = 0 ;
14262 char * kwnames[] = {
14263 (char *) "pid", NULL
14264 };
14265
14266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14267 ecode1 = SWIG_AsVal_int(obj0, &val1);
14268 if (!SWIG_IsOK(ecode1)) {
14269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14270 }
14271 arg1 = static_cast< int >(val1);
14272 {
14273 PyThreadState* __tstate = wxPyBeginAllowThreads();
14274 result = (bool)wxPyProcess::Exists(arg1);
14275 wxPyEndAllowThreads(__tstate);
14276 if (PyErr_Occurred()) SWIG_fail;
14277 }
14278 {
14279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14280 }
14281 return resultobj;
14282 fail:
14283 return NULL;
14284 }
14285
14286
14287 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14288 PyObject *resultobj = 0;
14289 wxString *arg1 = 0 ;
14290 int arg2 = (int) wxEXEC_ASYNC ;
14291 wxPyProcess *result = 0 ;
14292 bool temp1 = false ;
14293 int val2 ;
14294 int ecode2 = 0 ;
14295 PyObject * obj0 = 0 ;
14296 PyObject * obj1 = 0 ;
14297 char * kwnames[] = {
14298 (char *) "cmd",(char *) "flags", NULL
14299 };
14300
14301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14302 {
14303 arg1 = wxString_in_helper(obj0);
14304 if (arg1 == NULL) SWIG_fail;
14305 temp1 = true;
14306 }
14307 if (obj1) {
14308 ecode2 = SWIG_AsVal_int(obj1, &val2);
14309 if (!SWIG_IsOK(ecode2)) {
14310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14311 }
14312 arg2 = static_cast< int >(val2);
14313 }
14314 {
14315 PyThreadState* __tstate = wxPyBeginAllowThreads();
14316 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14317 wxPyEndAllowThreads(__tstate);
14318 if (PyErr_Occurred()) SWIG_fail;
14319 }
14320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14321 {
14322 if (temp1)
14323 delete arg1;
14324 }
14325 return resultobj;
14326 fail:
14327 {
14328 if (temp1)
14329 delete arg1;
14330 }
14331 return NULL;
14332 }
14333
14334
14335 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14336 PyObject *resultobj = 0;
14337 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14338 int arg2 = (int) -1 ;
14339 wxPyProcess *result = 0 ;
14340 void *argp1 = 0 ;
14341 int res1 = 0 ;
14342 int val2 ;
14343 int ecode2 = 0 ;
14344 PyObject * obj0 = 0 ;
14345 PyObject * obj1 = 0 ;
14346 char * kwnames[] = {
14347 (char *) "parent",(char *) "id", NULL
14348 };
14349
14350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14351 if (obj0) {
14352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14353 if (!SWIG_IsOK(res1)) {
14354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14355 }
14356 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14357 }
14358 if (obj1) {
14359 ecode2 = SWIG_AsVal_int(obj1, &val2);
14360 if (!SWIG_IsOK(ecode2)) {
14361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14362 }
14363 arg2 = static_cast< int >(val2);
14364 }
14365 {
14366 PyThreadState* __tstate = wxPyBeginAllowThreads();
14367 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14368 wxPyEndAllowThreads(__tstate);
14369 if (PyErr_Occurred()) SWIG_fail;
14370 }
14371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14372 return resultobj;
14373 fail:
14374 return NULL;
14375 }
14376
14377
14378 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14379 PyObject *resultobj = 0;
14380 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14381 PyObject *arg2 = (PyObject *) 0 ;
14382 PyObject *arg3 = (PyObject *) 0 ;
14383 void *argp1 = 0 ;
14384 int res1 = 0 ;
14385 PyObject * obj0 = 0 ;
14386 PyObject * obj1 = 0 ;
14387 PyObject * obj2 = 0 ;
14388 char * kwnames[] = {
14389 (char *) "self",(char *) "self",(char *) "_class", NULL
14390 };
14391
14392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14394 if (!SWIG_IsOK(res1)) {
14395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14396 }
14397 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14398 arg2 = obj1;
14399 arg3 = obj2;
14400 {
14401 PyThreadState* __tstate = wxPyBeginAllowThreads();
14402 (arg1)->_setCallbackInfo(arg2,arg3);
14403 wxPyEndAllowThreads(__tstate);
14404 if (PyErr_Occurred()) SWIG_fail;
14405 }
14406 resultobj = SWIG_Py_Void();
14407 return resultobj;
14408 fail:
14409 return NULL;
14410 }
14411
14412
14413 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14414 PyObject *resultobj = 0;
14415 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14416 int arg2 ;
14417 int arg3 ;
14418 void *argp1 = 0 ;
14419 int res1 = 0 ;
14420 int val2 ;
14421 int ecode2 = 0 ;
14422 int val3 ;
14423 int ecode3 = 0 ;
14424 PyObject * obj0 = 0 ;
14425 PyObject * obj1 = 0 ;
14426 PyObject * obj2 = 0 ;
14427 char * kwnames[] = {
14428 (char *) "self",(char *) "pid",(char *) "status", NULL
14429 };
14430
14431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14433 if (!SWIG_IsOK(res1)) {
14434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14435 }
14436 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14437 ecode2 = SWIG_AsVal_int(obj1, &val2);
14438 if (!SWIG_IsOK(ecode2)) {
14439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14440 }
14441 arg2 = static_cast< int >(val2);
14442 ecode3 = SWIG_AsVal_int(obj2, &val3);
14443 if (!SWIG_IsOK(ecode3)) {
14444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14445 }
14446 arg3 = static_cast< int >(val3);
14447 {
14448 PyThreadState* __tstate = wxPyBeginAllowThreads();
14449 (arg1)->OnTerminate(arg2,arg3);
14450 wxPyEndAllowThreads(__tstate);
14451 if (PyErr_Occurred()) SWIG_fail;
14452 }
14453 resultobj = SWIG_Py_Void();
14454 return resultobj;
14455 fail:
14456 return NULL;
14457 }
14458
14459
14460 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14461 PyObject *resultobj = 0;
14462 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14463 void *argp1 = 0 ;
14464 int res1 = 0 ;
14465 PyObject *swig_obj[1] ;
14466
14467 if (!args) SWIG_fail;
14468 swig_obj[0] = args;
14469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14470 if (!SWIG_IsOK(res1)) {
14471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14472 }
14473 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14474 {
14475 PyThreadState* __tstate = wxPyBeginAllowThreads();
14476 (arg1)->Redirect();
14477 wxPyEndAllowThreads(__tstate);
14478 if (PyErr_Occurred()) SWIG_fail;
14479 }
14480 resultobj = SWIG_Py_Void();
14481 return resultobj;
14482 fail:
14483 return NULL;
14484 }
14485
14486
14487 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14488 PyObject *resultobj = 0;
14489 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14490 bool result;
14491 void *argp1 = 0 ;
14492 int res1 = 0 ;
14493 PyObject *swig_obj[1] ;
14494
14495 if (!args) SWIG_fail;
14496 swig_obj[0] = args;
14497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14498 if (!SWIG_IsOK(res1)) {
14499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14500 }
14501 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14502 {
14503 PyThreadState* __tstate = wxPyBeginAllowThreads();
14504 result = (bool)(arg1)->IsRedirected();
14505 wxPyEndAllowThreads(__tstate);
14506 if (PyErr_Occurred()) SWIG_fail;
14507 }
14508 {
14509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14510 }
14511 return resultobj;
14512 fail:
14513 return NULL;
14514 }
14515
14516
14517 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14518 PyObject *resultobj = 0;
14519 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14520 void *argp1 = 0 ;
14521 int res1 = 0 ;
14522 PyObject *swig_obj[1] ;
14523
14524 if (!args) SWIG_fail;
14525 swig_obj[0] = args;
14526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14527 if (!SWIG_IsOK(res1)) {
14528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14529 }
14530 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14531 {
14532 PyThreadState* __tstate = wxPyBeginAllowThreads();
14533 (arg1)->Detach();
14534 wxPyEndAllowThreads(__tstate);
14535 if (PyErr_Occurred()) SWIG_fail;
14536 }
14537 resultobj = SWIG_Py_Void();
14538 return resultobj;
14539 fail:
14540 return NULL;
14541 }
14542
14543
14544 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14545 PyObject *resultobj = 0;
14546 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14547 wxInputStream *result = 0 ;
14548 void *argp1 = 0 ;
14549 int res1 = 0 ;
14550 PyObject *swig_obj[1] ;
14551
14552 if (!args) SWIG_fail;
14553 swig_obj[0] = args;
14554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14555 if (!SWIG_IsOK(res1)) {
14556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14557 }
14558 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14559 {
14560 PyThreadState* __tstate = wxPyBeginAllowThreads();
14561 result = (wxInputStream *)(arg1)->GetInputStream();
14562 wxPyEndAllowThreads(__tstate);
14563 if (PyErr_Occurred()) SWIG_fail;
14564 }
14565 {
14566 wxPyInputStream * _ptr = NULL;
14567
14568 if (result) {
14569 _ptr = new wxPyInputStream(result);
14570 }
14571 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14572 }
14573 return resultobj;
14574 fail:
14575 return NULL;
14576 }
14577
14578
14579 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14580 PyObject *resultobj = 0;
14581 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14582 wxInputStream *result = 0 ;
14583 void *argp1 = 0 ;
14584 int res1 = 0 ;
14585 PyObject *swig_obj[1] ;
14586
14587 if (!args) SWIG_fail;
14588 swig_obj[0] = args;
14589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14590 if (!SWIG_IsOK(res1)) {
14591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14592 }
14593 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14594 {
14595 PyThreadState* __tstate = wxPyBeginAllowThreads();
14596 result = (wxInputStream *)(arg1)->GetErrorStream();
14597 wxPyEndAllowThreads(__tstate);
14598 if (PyErr_Occurred()) SWIG_fail;
14599 }
14600 {
14601 wxPyInputStream * _ptr = NULL;
14602
14603 if (result) {
14604 _ptr = new wxPyInputStream(result);
14605 }
14606 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14607 }
14608 return resultobj;
14609 fail:
14610 return NULL;
14611 }
14612
14613
14614 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14615 PyObject *resultobj = 0;
14616 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14617 wxOutputStream *result = 0 ;
14618 void *argp1 = 0 ;
14619 int res1 = 0 ;
14620 PyObject *swig_obj[1] ;
14621
14622 if (!args) SWIG_fail;
14623 swig_obj[0] = args;
14624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14625 if (!SWIG_IsOK(res1)) {
14626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14627 }
14628 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14629 {
14630 PyThreadState* __tstate = wxPyBeginAllowThreads();
14631 result = (wxOutputStream *)(arg1)->GetOutputStream();
14632 wxPyEndAllowThreads(__tstate);
14633 if (PyErr_Occurred()) SWIG_fail;
14634 }
14635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14636 return resultobj;
14637 fail:
14638 return NULL;
14639 }
14640
14641
14642 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14643 PyObject *resultobj = 0;
14644 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14645 void *argp1 = 0 ;
14646 int res1 = 0 ;
14647 PyObject *swig_obj[1] ;
14648
14649 if (!args) SWIG_fail;
14650 swig_obj[0] = args;
14651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14652 if (!SWIG_IsOK(res1)) {
14653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14654 }
14655 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14656 {
14657 PyThreadState* __tstate = wxPyBeginAllowThreads();
14658 (arg1)->CloseOutput();
14659 wxPyEndAllowThreads(__tstate);
14660 if (PyErr_Occurred()) SWIG_fail;
14661 }
14662 resultobj = SWIG_Py_Void();
14663 return resultobj;
14664 fail:
14665 return NULL;
14666 }
14667
14668
14669 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14670 PyObject *resultobj = 0;
14671 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14672 bool result;
14673 void *argp1 = 0 ;
14674 int res1 = 0 ;
14675 PyObject *swig_obj[1] ;
14676
14677 if (!args) SWIG_fail;
14678 swig_obj[0] = args;
14679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14680 if (!SWIG_IsOK(res1)) {
14681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14682 }
14683 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14684 {
14685 PyThreadState* __tstate = wxPyBeginAllowThreads();
14686 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14687 wxPyEndAllowThreads(__tstate);
14688 if (PyErr_Occurred()) SWIG_fail;
14689 }
14690 {
14691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14692 }
14693 return resultobj;
14694 fail:
14695 return NULL;
14696 }
14697
14698
14699 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14700 PyObject *resultobj = 0;
14701 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14702 bool result;
14703 void *argp1 = 0 ;
14704 int res1 = 0 ;
14705 PyObject *swig_obj[1] ;
14706
14707 if (!args) SWIG_fail;
14708 swig_obj[0] = args;
14709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14710 if (!SWIG_IsOK(res1)) {
14711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14712 }
14713 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14714 {
14715 PyThreadState* __tstate = wxPyBeginAllowThreads();
14716 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14717 wxPyEndAllowThreads(__tstate);
14718 if (PyErr_Occurred()) SWIG_fail;
14719 }
14720 {
14721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14722 }
14723 return resultobj;
14724 fail:
14725 return NULL;
14726 }
14727
14728
14729 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14730 PyObject *resultobj = 0;
14731 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14732 bool result;
14733 void *argp1 = 0 ;
14734 int res1 = 0 ;
14735 PyObject *swig_obj[1] ;
14736
14737 if (!args) SWIG_fail;
14738 swig_obj[0] = args;
14739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14740 if (!SWIG_IsOK(res1)) {
14741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14742 }
14743 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14744 {
14745 PyThreadState* __tstate = wxPyBeginAllowThreads();
14746 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14747 wxPyEndAllowThreads(__tstate);
14748 if (PyErr_Occurred()) SWIG_fail;
14749 }
14750 {
14751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14752 }
14753 return resultobj;
14754 fail:
14755 return NULL;
14756 }
14757
14758
14759 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14760 PyObject *obj;
14761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14762 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14763 return SWIG_Py_Void();
14764 }
14765
14766 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14767 return SWIG_Python_InitShadowInstance(args);
14768 }
14769
14770 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14771 PyObject *resultobj = 0;
14772 int arg1 = (int) 0 ;
14773 int arg2 = (int) 0 ;
14774 int arg3 = (int) 0 ;
14775 wxProcessEvent *result = 0 ;
14776 int val1 ;
14777 int ecode1 = 0 ;
14778 int val2 ;
14779 int ecode2 = 0 ;
14780 int val3 ;
14781 int ecode3 = 0 ;
14782 PyObject * obj0 = 0 ;
14783 PyObject * obj1 = 0 ;
14784 PyObject * obj2 = 0 ;
14785 char * kwnames[] = {
14786 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14787 };
14788
14789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14790 if (obj0) {
14791 ecode1 = SWIG_AsVal_int(obj0, &val1);
14792 if (!SWIG_IsOK(ecode1)) {
14793 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14794 }
14795 arg1 = static_cast< int >(val1);
14796 }
14797 if (obj1) {
14798 ecode2 = SWIG_AsVal_int(obj1, &val2);
14799 if (!SWIG_IsOK(ecode2)) {
14800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14801 }
14802 arg2 = static_cast< int >(val2);
14803 }
14804 if (obj2) {
14805 ecode3 = SWIG_AsVal_int(obj2, &val3);
14806 if (!SWIG_IsOK(ecode3)) {
14807 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14808 }
14809 arg3 = static_cast< int >(val3);
14810 }
14811 {
14812 PyThreadState* __tstate = wxPyBeginAllowThreads();
14813 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14814 wxPyEndAllowThreads(__tstate);
14815 if (PyErr_Occurred()) SWIG_fail;
14816 }
14817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14818 return resultobj;
14819 fail:
14820 return NULL;
14821 }
14822
14823
14824 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14825 PyObject *resultobj = 0;
14826 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14827 int result;
14828 void *argp1 = 0 ;
14829 int res1 = 0 ;
14830 PyObject *swig_obj[1] ;
14831
14832 if (!args) SWIG_fail;
14833 swig_obj[0] = args;
14834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14835 if (!SWIG_IsOK(res1)) {
14836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14837 }
14838 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14839 {
14840 PyThreadState* __tstate = wxPyBeginAllowThreads();
14841 result = (int)(arg1)->GetPid();
14842 wxPyEndAllowThreads(__tstate);
14843 if (PyErr_Occurred()) SWIG_fail;
14844 }
14845 resultobj = SWIG_From_int(static_cast< int >(result));
14846 return resultobj;
14847 fail:
14848 return NULL;
14849 }
14850
14851
14852 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14853 PyObject *resultobj = 0;
14854 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14855 int result;
14856 void *argp1 = 0 ;
14857 int res1 = 0 ;
14858 PyObject *swig_obj[1] ;
14859
14860 if (!args) SWIG_fail;
14861 swig_obj[0] = args;
14862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14863 if (!SWIG_IsOK(res1)) {
14864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14865 }
14866 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14867 {
14868 PyThreadState* __tstate = wxPyBeginAllowThreads();
14869 result = (int)(arg1)->GetExitCode();
14870 wxPyEndAllowThreads(__tstate);
14871 if (PyErr_Occurred()) SWIG_fail;
14872 }
14873 resultobj = SWIG_From_int(static_cast< int >(result));
14874 return resultobj;
14875 fail:
14876 return NULL;
14877 }
14878
14879
14880 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14881 PyObject *resultobj = 0;
14882 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14883 int arg2 ;
14884 void *argp1 = 0 ;
14885 int res1 = 0 ;
14886 int val2 ;
14887 int ecode2 = 0 ;
14888 PyObject *swig_obj[2] ;
14889
14890 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14892 if (!SWIG_IsOK(res1)) {
14893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14894 }
14895 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14896 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14897 if (!SWIG_IsOK(ecode2)) {
14898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14899 }
14900 arg2 = static_cast< int >(val2);
14901 if (arg1) (arg1)->m_pid = arg2;
14902
14903 resultobj = SWIG_Py_Void();
14904 return resultobj;
14905 fail:
14906 return NULL;
14907 }
14908
14909
14910 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14911 PyObject *resultobj = 0;
14912 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14913 int result;
14914 void *argp1 = 0 ;
14915 int res1 = 0 ;
14916 PyObject *swig_obj[1] ;
14917
14918 if (!args) SWIG_fail;
14919 swig_obj[0] = args;
14920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14921 if (!SWIG_IsOK(res1)) {
14922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14923 }
14924 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14925 result = (int) ((arg1)->m_pid);
14926 resultobj = SWIG_From_int(static_cast< int >(result));
14927 return resultobj;
14928 fail:
14929 return NULL;
14930 }
14931
14932
14933 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14934 PyObject *resultobj = 0;
14935 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14936 int arg2 ;
14937 void *argp1 = 0 ;
14938 int res1 = 0 ;
14939 int val2 ;
14940 int ecode2 = 0 ;
14941 PyObject *swig_obj[2] ;
14942
14943 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
14944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14945 if (!SWIG_IsOK(res1)) {
14946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14947 }
14948 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14949 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14950 if (!SWIG_IsOK(ecode2)) {
14951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
14952 }
14953 arg2 = static_cast< int >(val2);
14954 if (arg1) (arg1)->m_exitcode = arg2;
14955
14956 resultobj = SWIG_Py_Void();
14957 return resultobj;
14958 fail:
14959 return NULL;
14960 }
14961
14962
14963 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14964 PyObject *resultobj = 0;
14965 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14966 int result;
14967 void *argp1 = 0 ;
14968 int res1 = 0 ;
14969 PyObject *swig_obj[1] ;
14970
14971 if (!args) SWIG_fail;
14972 swig_obj[0] = args;
14973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14974 if (!SWIG_IsOK(res1)) {
14975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14976 }
14977 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14978 result = (int) ((arg1)->m_exitcode);
14979 resultobj = SWIG_From_int(static_cast< int >(result));
14980 return resultobj;
14981 fail:
14982 return NULL;
14983 }
14984
14985
14986 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14987 PyObject *obj;
14988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14989 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
14990 return SWIG_Py_Void();
14991 }
14992
14993 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14994 return SWIG_Python_InitShadowInstance(args);
14995 }
14996
14997 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14998 PyObject *resultobj = 0;
14999 wxString *arg1 = 0 ;
15000 int arg2 = (int) wxEXEC_ASYNC ;
15001 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15002 long result;
15003 bool temp1 = false ;
15004 int val2 ;
15005 int ecode2 = 0 ;
15006 void *argp3 = 0 ;
15007 int res3 = 0 ;
15008 PyObject * obj0 = 0 ;
15009 PyObject * obj1 = 0 ;
15010 PyObject * obj2 = 0 ;
15011 char * kwnames[] = {
15012 (char *) "command",(char *) "flags",(char *) "process", NULL
15013 };
15014
15015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15016 {
15017 arg1 = wxString_in_helper(obj0);
15018 if (arg1 == NULL) SWIG_fail;
15019 temp1 = true;
15020 }
15021 if (obj1) {
15022 ecode2 = SWIG_AsVal_int(obj1, &val2);
15023 if (!SWIG_IsOK(ecode2)) {
15024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15025 }
15026 arg2 = static_cast< int >(val2);
15027 }
15028 if (obj2) {
15029 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15030 if (!SWIG_IsOK(res3)) {
15031 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15032 }
15033 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15034 }
15035 {
15036 if (!wxPyCheckForApp()) SWIG_fail;
15037 PyThreadState* __tstate = wxPyBeginAllowThreads();
15038 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15039 wxPyEndAllowThreads(__tstate);
15040 if (PyErr_Occurred()) SWIG_fail;
15041 }
15042 resultobj = SWIG_From_long(static_cast< long >(result));
15043 {
15044 if (temp1)
15045 delete arg1;
15046 }
15047 return resultobj;
15048 fail:
15049 {
15050 if (temp1)
15051 delete arg1;
15052 }
15053 return NULL;
15054 }
15055
15056
15057 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15058 PyObject *resultobj = 0;
15059 long arg1 ;
15060 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15061 wxKillError *arg3 = (wxKillError *) 0 ;
15062 int arg4 = (int) wxKILL_NOCHILDREN ;
15063 int result;
15064 long val1 ;
15065 int ecode1 = 0 ;
15066 int val2 ;
15067 int ecode2 = 0 ;
15068 wxKillError temp3 ;
15069 int val4 ;
15070 int ecode4 = 0 ;
15071 PyObject * obj0 = 0 ;
15072 PyObject * obj1 = 0 ;
15073 PyObject * obj2 = 0 ;
15074 char * kwnames[] = {
15075 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15076 };
15077
15078 {
15079 arg3 = &temp3;
15080 }
15081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15082 ecode1 = SWIG_AsVal_long(obj0, &val1);
15083 if (!SWIG_IsOK(ecode1)) {
15084 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15085 }
15086 arg1 = static_cast< long >(val1);
15087 if (obj1) {
15088 ecode2 = SWIG_AsVal_int(obj1, &val2);
15089 if (!SWIG_IsOK(ecode2)) {
15090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15091 }
15092 arg2 = static_cast< wxSignal >(val2);
15093 }
15094 if (obj2) {
15095 ecode4 = SWIG_AsVal_int(obj2, &val4);
15096 if (!SWIG_IsOK(ecode4)) {
15097 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15098 }
15099 arg4 = static_cast< int >(val4);
15100 }
15101 {
15102 PyThreadState* __tstate = wxPyBeginAllowThreads();
15103 result = (int)wxKill(arg1,arg2,arg3,arg4);
15104 wxPyEndAllowThreads(__tstate);
15105 if (PyErr_Occurred()) SWIG_fail;
15106 }
15107 resultobj = SWIG_From_int(static_cast< int >(result));
15108 {
15109 PyObject* o;
15110 o = PyInt_FromLong((long) (*arg3));
15111
15112
15113
15114 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15115
15116 }
15117 return resultobj;
15118 fail:
15119 return NULL;
15120 }
15121
15122
15123 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15124 PyObject *resultobj = 0;
15125 int arg1 = (int) wxJOYSTICK1 ;
15126 wxJoystick *result = 0 ;
15127 int val1 ;
15128 int ecode1 = 0 ;
15129 PyObject * obj0 = 0 ;
15130 char * kwnames[] = {
15131 (char *) "joystick", NULL
15132 };
15133
15134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15135 if (obj0) {
15136 ecode1 = SWIG_AsVal_int(obj0, &val1);
15137 if (!SWIG_IsOK(ecode1)) {
15138 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15139 }
15140 arg1 = static_cast< int >(val1);
15141 }
15142 {
15143 if (!wxPyCheckForApp()) SWIG_fail;
15144 PyThreadState* __tstate = wxPyBeginAllowThreads();
15145 result = (wxJoystick *)new wxJoystick(arg1);
15146 wxPyEndAllowThreads(__tstate);
15147 if (PyErr_Occurred()) SWIG_fail;
15148 }
15149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15150 return resultobj;
15151 fail:
15152 return NULL;
15153 }
15154
15155
15156 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15157 PyObject *resultobj = 0;
15158 wxJoystick *arg1 = (wxJoystick *) 0 ;
15159 void *argp1 = 0 ;
15160 int res1 = 0 ;
15161 PyObject *swig_obj[1] ;
15162
15163 if (!args) SWIG_fail;
15164 swig_obj[0] = args;
15165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15166 if (!SWIG_IsOK(res1)) {
15167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15168 }
15169 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15170 {
15171 PyThreadState* __tstate = wxPyBeginAllowThreads();
15172 delete arg1;
15173
15174 wxPyEndAllowThreads(__tstate);
15175 if (PyErr_Occurred()) SWIG_fail;
15176 }
15177 resultobj = SWIG_Py_Void();
15178 return resultobj;
15179 fail:
15180 return NULL;
15181 }
15182
15183
15184 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15185 PyObject *resultobj = 0;
15186 wxJoystick *arg1 = (wxJoystick *) 0 ;
15187 wxPoint result;
15188 void *argp1 = 0 ;
15189 int res1 = 0 ;
15190 PyObject *swig_obj[1] ;
15191
15192 if (!args) SWIG_fail;
15193 swig_obj[0] = args;
15194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15195 if (!SWIG_IsOK(res1)) {
15196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15197 }
15198 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15199 {
15200 PyThreadState* __tstate = wxPyBeginAllowThreads();
15201 result = (arg1)->GetPosition();
15202 wxPyEndAllowThreads(__tstate);
15203 if (PyErr_Occurred()) SWIG_fail;
15204 }
15205 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15206 return resultobj;
15207 fail:
15208 return NULL;
15209 }
15210
15211
15212 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15213 PyObject *resultobj = 0;
15214 wxJoystick *arg1 = (wxJoystick *) 0 ;
15215 int result;
15216 void *argp1 = 0 ;
15217 int res1 = 0 ;
15218 PyObject *swig_obj[1] ;
15219
15220 if (!args) SWIG_fail;
15221 swig_obj[0] = args;
15222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15223 if (!SWIG_IsOK(res1)) {
15224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15225 }
15226 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15227 {
15228 PyThreadState* __tstate = wxPyBeginAllowThreads();
15229 result = (int)(arg1)->GetZPosition();
15230 wxPyEndAllowThreads(__tstate);
15231 if (PyErr_Occurred()) SWIG_fail;
15232 }
15233 resultobj = SWIG_From_int(static_cast< int >(result));
15234 return resultobj;
15235 fail:
15236 return NULL;
15237 }
15238
15239
15240 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15241 PyObject *resultobj = 0;
15242 wxJoystick *arg1 = (wxJoystick *) 0 ;
15243 int result;
15244 void *argp1 = 0 ;
15245 int res1 = 0 ;
15246 PyObject *swig_obj[1] ;
15247
15248 if (!args) SWIG_fail;
15249 swig_obj[0] = args;
15250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15251 if (!SWIG_IsOK(res1)) {
15252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15253 }
15254 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15255 {
15256 PyThreadState* __tstate = wxPyBeginAllowThreads();
15257 result = (int)(arg1)->GetButtonState();
15258 wxPyEndAllowThreads(__tstate);
15259 if (PyErr_Occurred()) SWIG_fail;
15260 }
15261 resultobj = SWIG_From_int(static_cast< int >(result));
15262 return resultobj;
15263 fail:
15264 return NULL;
15265 }
15266
15267
15268 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15269 PyObject *resultobj = 0;
15270 wxJoystick *arg1 = (wxJoystick *) 0 ;
15271 int result;
15272 void *argp1 = 0 ;
15273 int res1 = 0 ;
15274 PyObject *swig_obj[1] ;
15275
15276 if (!args) SWIG_fail;
15277 swig_obj[0] = args;
15278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15279 if (!SWIG_IsOK(res1)) {
15280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15281 }
15282 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15283 {
15284 PyThreadState* __tstate = wxPyBeginAllowThreads();
15285 result = (int)(arg1)->GetPOVPosition();
15286 wxPyEndAllowThreads(__tstate);
15287 if (PyErr_Occurred()) SWIG_fail;
15288 }
15289 resultobj = SWIG_From_int(static_cast< int >(result));
15290 return resultobj;
15291 fail:
15292 return NULL;
15293 }
15294
15295
15296 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15297 PyObject *resultobj = 0;
15298 wxJoystick *arg1 = (wxJoystick *) 0 ;
15299 int result;
15300 void *argp1 = 0 ;
15301 int res1 = 0 ;
15302 PyObject *swig_obj[1] ;
15303
15304 if (!args) SWIG_fail;
15305 swig_obj[0] = args;
15306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15307 if (!SWIG_IsOK(res1)) {
15308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15309 }
15310 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15311 {
15312 PyThreadState* __tstate = wxPyBeginAllowThreads();
15313 result = (int)(arg1)->GetPOVCTSPosition();
15314 wxPyEndAllowThreads(__tstate);
15315 if (PyErr_Occurred()) SWIG_fail;
15316 }
15317 resultobj = SWIG_From_int(static_cast< int >(result));
15318 return resultobj;
15319 fail:
15320 return NULL;
15321 }
15322
15323
15324 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15325 PyObject *resultobj = 0;
15326 wxJoystick *arg1 = (wxJoystick *) 0 ;
15327 int result;
15328 void *argp1 = 0 ;
15329 int res1 = 0 ;
15330 PyObject *swig_obj[1] ;
15331
15332 if (!args) SWIG_fail;
15333 swig_obj[0] = args;
15334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15335 if (!SWIG_IsOK(res1)) {
15336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15337 }
15338 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15339 {
15340 PyThreadState* __tstate = wxPyBeginAllowThreads();
15341 result = (int)(arg1)->GetRudderPosition();
15342 wxPyEndAllowThreads(__tstate);
15343 if (PyErr_Occurred()) SWIG_fail;
15344 }
15345 resultobj = SWIG_From_int(static_cast< int >(result));
15346 return resultobj;
15347 fail:
15348 return NULL;
15349 }
15350
15351
15352 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15353 PyObject *resultobj = 0;
15354 wxJoystick *arg1 = (wxJoystick *) 0 ;
15355 int result;
15356 void *argp1 = 0 ;
15357 int res1 = 0 ;
15358 PyObject *swig_obj[1] ;
15359
15360 if (!args) SWIG_fail;
15361 swig_obj[0] = args;
15362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15363 if (!SWIG_IsOK(res1)) {
15364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15365 }
15366 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15367 {
15368 PyThreadState* __tstate = wxPyBeginAllowThreads();
15369 result = (int)(arg1)->GetUPosition();
15370 wxPyEndAllowThreads(__tstate);
15371 if (PyErr_Occurred()) SWIG_fail;
15372 }
15373 resultobj = SWIG_From_int(static_cast< int >(result));
15374 return resultobj;
15375 fail:
15376 return NULL;
15377 }
15378
15379
15380 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15381 PyObject *resultobj = 0;
15382 wxJoystick *arg1 = (wxJoystick *) 0 ;
15383 int result;
15384 void *argp1 = 0 ;
15385 int res1 = 0 ;
15386 PyObject *swig_obj[1] ;
15387
15388 if (!args) SWIG_fail;
15389 swig_obj[0] = args;
15390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15391 if (!SWIG_IsOK(res1)) {
15392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15393 }
15394 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15395 {
15396 PyThreadState* __tstate = wxPyBeginAllowThreads();
15397 result = (int)(arg1)->GetVPosition();
15398 wxPyEndAllowThreads(__tstate);
15399 if (PyErr_Occurred()) SWIG_fail;
15400 }
15401 resultobj = SWIG_From_int(static_cast< int >(result));
15402 return resultobj;
15403 fail:
15404 return NULL;
15405 }
15406
15407
15408 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15409 PyObject *resultobj = 0;
15410 wxJoystick *arg1 = (wxJoystick *) 0 ;
15411 int result;
15412 void *argp1 = 0 ;
15413 int res1 = 0 ;
15414 PyObject *swig_obj[1] ;
15415
15416 if (!args) SWIG_fail;
15417 swig_obj[0] = args;
15418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15419 if (!SWIG_IsOK(res1)) {
15420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15421 }
15422 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15423 {
15424 PyThreadState* __tstate = wxPyBeginAllowThreads();
15425 result = (int)(arg1)->GetMovementThreshold();
15426 wxPyEndAllowThreads(__tstate);
15427 if (PyErr_Occurred()) SWIG_fail;
15428 }
15429 resultobj = SWIG_From_int(static_cast< int >(result));
15430 return resultobj;
15431 fail:
15432 return NULL;
15433 }
15434
15435
15436 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15437 PyObject *resultobj = 0;
15438 wxJoystick *arg1 = (wxJoystick *) 0 ;
15439 int arg2 ;
15440 void *argp1 = 0 ;
15441 int res1 = 0 ;
15442 int val2 ;
15443 int ecode2 = 0 ;
15444 PyObject * obj0 = 0 ;
15445 PyObject * obj1 = 0 ;
15446 char * kwnames[] = {
15447 (char *) "self",(char *) "threshold", NULL
15448 };
15449
15450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15452 if (!SWIG_IsOK(res1)) {
15453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15454 }
15455 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15456 ecode2 = SWIG_AsVal_int(obj1, &val2);
15457 if (!SWIG_IsOK(ecode2)) {
15458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15459 }
15460 arg2 = static_cast< int >(val2);
15461 {
15462 PyThreadState* __tstate = wxPyBeginAllowThreads();
15463 (arg1)->SetMovementThreshold(arg2);
15464 wxPyEndAllowThreads(__tstate);
15465 if (PyErr_Occurred()) SWIG_fail;
15466 }
15467 resultobj = SWIG_Py_Void();
15468 return resultobj;
15469 fail:
15470 return NULL;
15471 }
15472
15473
15474 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15475 PyObject *resultobj = 0;
15476 wxJoystick *arg1 = (wxJoystick *) 0 ;
15477 bool result;
15478 void *argp1 = 0 ;
15479 int res1 = 0 ;
15480 PyObject *swig_obj[1] ;
15481
15482 if (!args) SWIG_fail;
15483 swig_obj[0] = args;
15484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15485 if (!SWIG_IsOK(res1)) {
15486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15487 }
15488 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15489 {
15490 PyThreadState* __tstate = wxPyBeginAllowThreads();
15491 result = (bool)(arg1)->IsOk();
15492 wxPyEndAllowThreads(__tstate);
15493 if (PyErr_Occurred()) SWIG_fail;
15494 }
15495 {
15496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15497 }
15498 return resultobj;
15499 fail:
15500 return NULL;
15501 }
15502
15503
15504 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15505 PyObject *resultobj = 0;
15506 wxJoystick *arg1 = (wxJoystick *) 0 ;
15507 int result;
15508 void *argp1 = 0 ;
15509 int res1 = 0 ;
15510 PyObject *swig_obj[1] ;
15511
15512 if (!args) SWIG_fail;
15513 swig_obj[0] = args;
15514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15515 if (!SWIG_IsOK(res1)) {
15516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15517 }
15518 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15519 {
15520 PyThreadState* __tstate = wxPyBeginAllowThreads();
15521 result = (int)(arg1)->GetNumberJoysticks();
15522 wxPyEndAllowThreads(__tstate);
15523 if (PyErr_Occurred()) SWIG_fail;
15524 }
15525 resultobj = SWIG_From_int(static_cast< int >(result));
15526 return resultobj;
15527 fail:
15528 return NULL;
15529 }
15530
15531
15532 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15533 PyObject *resultobj = 0;
15534 wxJoystick *arg1 = (wxJoystick *) 0 ;
15535 int result;
15536 void *argp1 = 0 ;
15537 int res1 = 0 ;
15538 PyObject *swig_obj[1] ;
15539
15540 if (!args) SWIG_fail;
15541 swig_obj[0] = args;
15542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15543 if (!SWIG_IsOK(res1)) {
15544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15545 }
15546 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15547 {
15548 PyThreadState* __tstate = wxPyBeginAllowThreads();
15549 result = (int)(arg1)->GetManufacturerId();
15550 wxPyEndAllowThreads(__tstate);
15551 if (PyErr_Occurred()) SWIG_fail;
15552 }
15553 resultobj = SWIG_From_int(static_cast< int >(result));
15554 return resultobj;
15555 fail:
15556 return NULL;
15557 }
15558
15559
15560 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15561 PyObject *resultobj = 0;
15562 wxJoystick *arg1 = (wxJoystick *) 0 ;
15563 int result;
15564 void *argp1 = 0 ;
15565 int res1 = 0 ;
15566 PyObject *swig_obj[1] ;
15567
15568 if (!args) SWIG_fail;
15569 swig_obj[0] = args;
15570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15571 if (!SWIG_IsOK(res1)) {
15572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15573 }
15574 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15575 {
15576 PyThreadState* __tstate = wxPyBeginAllowThreads();
15577 result = (int)(arg1)->GetProductId();
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 resultobj = SWIG_From_int(static_cast< int >(result));
15582 return resultobj;
15583 fail:
15584 return NULL;
15585 }
15586
15587
15588 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15589 PyObject *resultobj = 0;
15590 wxJoystick *arg1 = (wxJoystick *) 0 ;
15591 wxString result;
15592 void *argp1 = 0 ;
15593 int res1 = 0 ;
15594 PyObject *swig_obj[1] ;
15595
15596 if (!args) SWIG_fail;
15597 swig_obj[0] = args;
15598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15599 if (!SWIG_IsOK(res1)) {
15600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15601 }
15602 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15603 {
15604 PyThreadState* __tstate = wxPyBeginAllowThreads();
15605 result = (arg1)->GetProductName();
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 {
15610 #if wxUSE_UNICODE
15611 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15612 #else
15613 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15614 #endif
15615 }
15616 return resultobj;
15617 fail:
15618 return NULL;
15619 }
15620
15621
15622 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15623 PyObject *resultobj = 0;
15624 wxJoystick *arg1 = (wxJoystick *) 0 ;
15625 int result;
15626 void *argp1 = 0 ;
15627 int res1 = 0 ;
15628 PyObject *swig_obj[1] ;
15629
15630 if (!args) SWIG_fail;
15631 swig_obj[0] = args;
15632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15633 if (!SWIG_IsOK(res1)) {
15634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15635 }
15636 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15637 {
15638 PyThreadState* __tstate = wxPyBeginAllowThreads();
15639 result = (int)(arg1)->GetXMin();
15640 wxPyEndAllowThreads(__tstate);
15641 if (PyErr_Occurred()) SWIG_fail;
15642 }
15643 resultobj = SWIG_From_int(static_cast< int >(result));
15644 return resultobj;
15645 fail:
15646 return NULL;
15647 }
15648
15649
15650 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15651 PyObject *resultobj = 0;
15652 wxJoystick *arg1 = (wxJoystick *) 0 ;
15653 int result;
15654 void *argp1 = 0 ;
15655 int res1 = 0 ;
15656 PyObject *swig_obj[1] ;
15657
15658 if (!args) SWIG_fail;
15659 swig_obj[0] = args;
15660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15661 if (!SWIG_IsOK(res1)) {
15662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15663 }
15664 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15665 {
15666 PyThreadState* __tstate = wxPyBeginAllowThreads();
15667 result = (int)(arg1)->GetYMin();
15668 wxPyEndAllowThreads(__tstate);
15669 if (PyErr_Occurred()) SWIG_fail;
15670 }
15671 resultobj = SWIG_From_int(static_cast< int >(result));
15672 return resultobj;
15673 fail:
15674 return NULL;
15675 }
15676
15677
15678 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15679 PyObject *resultobj = 0;
15680 wxJoystick *arg1 = (wxJoystick *) 0 ;
15681 int result;
15682 void *argp1 = 0 ;
15683 int res1 = 0 ;
15684 PyObject *swig_obj[1] ;
15685
15686 if (!args) SWIG_fail;
15687 swig_obj[0] = args;
15688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15689 if (!SWIG_IsOK(res1)) {
15690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15691 }
15692 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15693 {
15694 PyThreadState* __tstate = wxPyBeginAllowThreads();
15695 result = (int)(arg1)->GetZMin();
15696 wxPyEndAllowThreads(__tstate);
15697 if (PyErr_Occurred()) SWIG_fail;
15698 }
15699 resultobj = SWIG_From_int(static_cast< int >(result));
15700 return resultobj;
15701 fail:
15702 return NULL;
15703 }
15704
15705
15706 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15707 PyObject *resultobj = 0;
15708 wxJoystick *arg1 = (wxJoystick *) 0 ;
15709 int result;
15710 void *argp1 = 0 ;
15711 int res1 = 0 ;
15712 PyObject *swig_obj[1] ;
15713
15714 if (!args) SWIG_fail;
15715 swig_obj[0] = args;
15716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15717 if (!SWIG_IsOK(res1)) {
15718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15719 }
15720 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15721 {
15722 PyThreadState* __tstate = wxPyBeginAllowThreads();
15723 result = (int)(arg1)->GetXMax();
15724 wxPyEndAllowThreads(__tstate);
15725 if (PyErr_Occurred()) SWIG_fail;
15726 }
15727 resultobj = SWIG_From_int(static_cast< int >(result));
15728 return resultobj;
15729 fail:
15730 return NULL;
15731 }
15732
15733
15734 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15735 PyObject *resultobj = 0;
15736 wxJoystick *arg1 = (wxJoystick *) 0 ;
15737 int result;
15738 void *argp1 = 0 ;
15739 int res1 = 0 ;
15740 PyObject *swig_obj[1] ;
15741
15742 if (!args) SWIG_fail;
15743 swig_obj[0] = args;
15744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15745 if (!SWIG_IsOK(res1)) {
15746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15747 }
15748 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15749 {
15750 PyThreadState* __tstate = wxPyBeginAllowThreads();
15751 result = (int)(arg1)->GetYMax();
15752 wxPyEndAllowThreads(__tstate);
15753 if (PyErr_Occurred()) SWIG_fail;
15754 }
15755 resultobj = SWIG_From_int(static_cast< int >(result));
15756 return resultobj;
15757 fail:
15758 return NULL;
15759 }
15760
15761
15762 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15763 PyObject *resultobj = 0;
15764 wxJoystick *arg1 = (wxJoystick *) 0 ;
15765 int result;
15766 void *argp1 = 0 ;
15767 int res1 = 0 ;
15768 PyObject *swig_obj[1] ;
15769
15770 if (!args) SWIG_fail;
15771 swig_obj[0] = args;
15772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15773 if (!SWIG_IsOK(res1)) {
15774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15775 }
15776 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15777 {
15778 PyThreadState* __tstate = wxPyBeginAllowThreads();
15779 result = (int)(arg1)->GetZMax();
15780 wxPyEndAllowThreads(__tstate);
15781 if (PyErr_Occurred()) SWIG_fail;
15782 }
15783 resultobj = SWIG_From_int(static_cast< int >(result));
15784 return resultobj;
15785 fail:
15786 return NULL;
15787 }
15788
15789
15790 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15791 PyObject *resultobj = 0;
15792 wxJoystick *arg1 = (wxJoystick *) 0 ;
15793 int result;
15794 void *argp1 = 0 ;
15795 int res1 = 0 ;
15796 PyObject *swig_obj[1] ;
15797
15798 if (!args) SWIG_fail;
15799 swig_obj[0] = args;
15800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15801 if (!SWIG_IsOK(res1)) {
15802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15803 }
15804 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15805 {
15806 PyThreadState* __tstate = wxPyBeginAllowThreads();
15807 result = (int)(arg1)->GetNumberButtons();
15808 wxPyEndAllowThreads(__tstate);
15809 if (PyErr_Occurred()) SWIG_fail;
15810 }
15811 resultobj = SWIG_From_int(static_cast< int >(result));
15812 return resultobj;
15813 fail:
15814 return NULL;
15815 }
15816
15817
15818 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15819 PyObject *resultobj = 0;
15820 wxJoystick *arg1 = (wxJoystick *) 0 ;
15821 int result;
15822 void *argp1 = 0 ;
15823 int res1 = 0 ;
15824 PyObject *swig_obj[1] ;
15825
15826 if (!args) SWIG_fail;
15827 swig_obj[0] = args;
15828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15829 if (!SWIG_IsOK(res1)) {
15830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15831 }
15832 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15833 {
15834 PyThreadState* __tstate = wxPyBeginAllowThreads();
15835 result = (int)(arg1)->GetNumberAxes();
15836 wxPyEndAllowThreads(__tstate);
15837 if (PyErr_Occurred()) SWIG_fail;
15838 }
15839 resultobj = SWIG_From_int(static_cast< int >(result));
15840 return resultobj;
15841 fail:
15842 return NULL;
15843 }
15844
15845
15846 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15847 PyObject *resultobj = 0;
15848 wxJoystick *arg1 = (wxJoystick *) 0 ;
15849 int result;
15850 void *argp1 = 0 ;
15851 int res1 = 0 ;
15852 PyObject *swig_obj[1] ;
15853
15854 if (!args) SWIG_fail;
15855 swig_obj[0] = args;
15856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15857 if (!SWIG_IsOK(res1)) {
15858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15859 }
15860 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15861 {
15862 PyThreadState* __tstate = wxPyBeginAllowThreads();
15863 result = (int)(arg1)->GetMaxButtons();
15864 wxPyEndAllowThreads(__tstate);
15865 if (PyErr_Occurred()) SWIG_fail;
15866 }
15867 resultobj = SWIG_From_int(static_cast< int >(result));
15868 return resultobj;
15869 fail:
15870 return NULL;
15871 }
15872
15873
15874 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15875 PyObject *resultobj = 0;
15876 wxJoystick *arg1 = (wxJoystick *) 0 ;
15877 int result;
15878 void *argp1 = 0 ;
15879 int res1 = 0 ;
15880 PyObject *swig_obj[1] ;
15881
15882 if (!args) SWIG_fail;
15883 swig_obj[0] = args;
15884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15885 if (!SWIG_IsOK(res1)) {
15886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15887 }
15888 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15889 {
15890 PyThreadState* __tstate = wxPyBeginAllowThreads();
15891 result = (int)(arg1)->GetMaxAxes();
15892 wxPyEndAllowThreads(__tstate);
15893 if (PyErr_Occurred()) SWIG_fail;
15894 }
15895 resultobj = SWIG_From_int(static_cast< int >(result));
15896 return resultobj;
15897 fail:
15898 return NULL;
15899 }
15900
15901
15902 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15903 PyObject *resultobj = 0;
15904 wxJoystick *arg1 = (wxJoystick *) 0 ;
15905 int result;
15906 void *argp1 = 0 ;
15907 int res1 = 0 ;
15908 PyObject *swig_obj[1] ;
15909
15910 if (!args) SWIG_fail;
15911 swig_obj[0] = args;
15912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15913 if (!SWIG_IsOK(res1)) {
15914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15915 }
15916 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15917 {
15918 PyThreadState* __tstate = wxPyBeginAllowThreads();
15919 result = (int)(arg1)->GetPollingMin();
15920 wxPyEndAllowThreads(__tstate);
15921 if (PyErr_Occurred()) SWIG_fail;
15922 }
15923 resultobj = SWIG_From_int(static_cast< int >(result));
15924 return resultobj;
15925 fail:
15926 return NULL;
15927 }
15928
15929
15930 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15931 PyObject *resultobj = 0;
15932 wxJoystick *arg1 = (wxJoystick *) 0 ;
15933 int result;
15934 void *argp1 = 0 ;
15935 int res1 = 0 ;
15936 PyObject *swig_obj[1] ;
15937
15938 if (!args) SWIG_fail;
15939 swig_obj[0] = args;
15940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15941 if (!SWIG_IsOK(res1)) {
15942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15943 }
15944 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15945 {
15946 PyThreadState* __tstate = wxPyBeginAllowThreads();
15947 result = (int)(arg1)->GetPollingMax();
15948 wxPyEndAllowThreads(__tstate);
15949 if (PyErr_Occurred()) SWIG_fail;
15950 }
15951 resultobj = SWIG_From_int(static_cast< int >(result));
15952 return resultobj;
15953 fail:
15954 return NULL;
15955 }
15956
15957
15958 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15959 PyObject *resultobj = 0;
15960 wxJoystick *arg1 = (wxJoystick *) 0 ;
15961 int result;
15962 void *argp1 = 0 ;
15963 int res1 = 0 ;
15964 PyObject *swig_obj[1] ;
15965
15966 if (!args) SWIG_fail;
15967 swig_obj[0] = args;
15968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15969 if (!SWIG_IsOK(res1)) {
15970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15971 }
15972 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15973 {
15974 PyThreadState* __tstate = wxPyBeginAllowThreads();
15975 result = (int)(arg1)->GetRudderMin();
15976 wxPyEndAllowThreads(__tstate);
15977 if (PyErr_Occurred()) SWIG_fail;
15978 }
15979 resultobj = SWIG_From_int(static_cast< int >(result));
15980 return resultobj;
15981 fail:
15982 return NULL;
15983 }
15984
15985
15986 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15987 PyObject *resultobj = 0;
15988 wxJoystick *arg1 = (wxJoystick *) 0 ;
15989 int result;
15990 void *argp1 = 0 ;
15991 int res1 = 0 ;
15992 PyObject *swig_obj[1] ;
15993
15994 if (!args) SWIG_fail;
15995 swig_obj[0] = args;
15996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15997 if (!SWIG_IsOK(res1)) {
15998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15999 }
16000 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16001 {
16002 PyThreadState* __tstate = wxPyBeginAllowThreads();
16003 result = (int)(arg1)->GetRudderMax();
16004 wxPyEndAllowThreads(__tstate);
16005 if (PyErr_Occurred()) SWIG_fail;
16006 }
16007 resultobj = SWIG_From_int(static_cast< int >(result));
16008 return resultobj;
16009 fail:
16010 return NULL;
16011 }
16012
16013
16014 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16015 PyObject *resultobj = 0;
16016 wxJoystick *arg1 = (wxJoystick *) 0 ;
16017 int result;
16018 void *argp1 = 0 ;
16019 int res1 = 0 ;
16020 PyObject *swig_obj[1] ;
16021
16022 if (!args) SWIG_fail;
16023 swig_obj[0] = args;
16024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16025 if (!SWIG_IsOK(res1)) {
16026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16027 }
16028 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16029 {
16030 PyThreadState* __tstate = wxPyBeginAllowThreads();
16031 result = (int)(arg1)->GetUMin();
16032 wxPyEndAllowThreads(__tstate);
16033 if (PyErr_Occurred()) SWIG_fail;
16034 }
16035 resultobj = SWIG_From_int(static_cast< int >(result));
16036 return resultobj;
16037 fail:
16038 return NULL;
16039 }
16040
16041
16042 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16043 PyObject *resultobj = 0;
16044 wxJoystick *arg1 = (wxJoystick *) 0 ;
16045 int result;
16046 void *argp1 = 0 ;
16047 int res1 = 0 ;
16048 PyObject *swig_obj[1] ;
16049
16050 if (!args) SWIG_fail;
16051 swig_obj[0] = args;
16052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16053 if (!SWIG_IsOK(res1)) {
16054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16055 }
16056 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16057 {
16058 PyThreadState* __tstate = wxPyBeginAllowThreads();
16059 result = (int)(arg1)->GetUMax();
16060 wxPyEndAllowThreads(__tstate);
16061 if (PyErr_Occurred()) SWIG_fail;
16062 }
16063 resultobj = SWIG_From_int(static_cast< int >(result));
16064 return resultobj;
16065 fail:
16066 return NULL;
16067 }
16068
16069
16070 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16071 PyObject *resultobj = 0;
16072 wxJoystick *arg1 = (wxJoystick *) 0 ;
16073 int result;
16074 void *argp1 = 0 ;
16075 int res1 = 0 ;
16076 PyObject *swig_obj[1] ;
16077
16078 if (!args) SWIG_fail;
16079 swig_obj[0] = args;
16080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16081 if (!SWIG_IsOK(res1)) {
16082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16083 }
16084 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16085 {
16086 PyThreadState* __tstate = wxPyBeginAllowThreads();
16087 result = (int)(arg1)->GetVMin();
16088 wxPyEndAllowThreads(__tstate);
16089 if (PyErr_Occurred()) SWIG_fail;
16090 }
16091 resultobj = SWIG_From_int(static_cast< int >(result));
16092 return resultobj;
16093 fail:
16094 return NULL;
16095 }
16096
16097
16098 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16099 PyObject *resultobj = 0;
16100 wxJoystick *arg1 = (wxJoystick *) 0 ;
16101 int result;
16102 void *argp1 = 0 ;
16103 int res1 = 0 ;
16104 PyObject *swig_obj[1] ;
16105
16106 if (!args) SWIG_fail;
16107 swig_obj[0] = args;
16108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16109 if (!SWIG_IsOK(res1)) {
16110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16111 }
16112 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16113 {
16114 PyThreadState* __tstate = wxPyBeginAllowThreads();
16115 result = (int)(arg1)->GetVMax();
16116 wxPyEndAllowThreads(__tstate);
16117 if (PyErr_Occurred()) SWIG_fail;
16118 }
16119 resultobj = SWIG_From_int(static_cast< int >(result));
16120 return resultobj;
16121 fail:
16122 return NULL;
16123 }
16124
16125
16126 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16127 PyObject *resultobj = 0;
16128 wxJoystick *arg1 = (wxJoystick *) 0 ;
16129 bool result;
16130 void *argp1 = 0 ;
16131 int res1 = 0 ;
16132 PyObject *swig_obj[1] ;
16133
16134 if (!args) SWIG_fail;
16135 swig_obj[0] = args;
16136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16137 if (!SWIG_IsOK(res1)) {
16138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16139 }
16140 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16141 {
16142 PyThreadState* __tstate = wxPyBeginAllowThreads();
16143 result = (bool)(arg1)->HasRudder();
16144 wxPyEndAllowThreads(__tstate);
16145 if (PyErr_Occurred()) SWIG_fail;
16146 }
16147 {
16148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16149 }
16150 return resultobj;
16151 fail:
16152 return NULL;
16153 }
16154
16155
16156 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16157 PyObject *resultobj = 0;
16158 wxJoystick *arg1 = (wxJoystick *) 0 ;
16159 bool result;
16160 void *argp1 = 0 ;
16161 int res1 = 0 ;
16162 PyObject *swig_obj[1] ;
16163
16164 if (!args) SWIG_fail;
16165 swig_obj[0] = args;
16166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16167 if (!SWIG_IsOK(res1)) {
16168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16169 }
16170 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16171 {
16172 PyThreadState* __tstate = wxPyBeginAllowThreads();
16173 result = (bool)(arg1)->HasZ();
16174 wxPyEndAllowThreads(__tstate);
16175 if (PyErr_Occurred()) SWIG_fail;
16176 }
16177 {
16178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16179 }
16180 return resultobj;
16181 fail:
16182 return NULL;
16183 }
16184
16185
16186 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16187 PyObject *resultobj = 0;
16188 wxJoystick *arg1 = (wxJoystick *) 0 ;
16189 bool result;
16190 void *argp1 = 0 ;
16191 int res1 = 0 ;
16192 PyObject *swig_obj[1] ;
16193
16194 if (!args) SWIG_fail;
16195 swig_obj[0] = args;
16196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16197 if (!SWIG_IsOK(res1)) {
16198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16199 }
16200 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16201 {
16202 PyThreadState* __tstate = wxPyBeginAllowThreads();
16203 result = (bool)(arg1)->HasU();
16204 wxPyEndAllowThreads(__tstate);
16205 if (PyErr_Occurred()) SWIG_fail;
16206 }
16207 {
16208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16209 }
16210 return resultobj;
16211 fail:
16212 return NULL;
16213 }
16214
16215
16216 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16217 PyObject *resultobj = 0;
16218 wxJoystick *arg1 = (wxJoystick *) 0 ;
16219 bool result;
16220 void *argp1 = 0 ;
16221 int res1 = 0 ;
16222 PyObject *swig_obj[1] ;
16223
16224 if (!args) SWIG_fail;
16225 swig_obj[0] = args;
16226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16227 if (!SWIG_IsOK(res1)) {
16228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16229 }
16230 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16231 {
16232 PyThreadState* __tstate = wxPyBeginAllowThreads();
16233 result = (bool)(arg1)->HasV();
16234 wxPyEndAllowThreads(__tstate);
16235 if (PyErr_Occurred()) SWIG_fail;
16236 }
16237 {
16238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16239 }
16240 return resultobj;
16241 fail:
16242 return NULL;
16243 }
16244
16245
16246 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16247 PyObject *resultobj = 0;
16248 wxJoystick *arg1 = (wxJoystick *) 0 ;
16249 bool result;
16250 void *argp1 = 0 ;
16251 int res1 = 0 ;
16252 PyObject *swig_obj[1] ;
16253
16254 if (!args) SWIG_fail;
16255 swig_obj[0] = args;
16256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16257 if (!SWIG_IsOK(res1)) {
16258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16259 }
16260 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16261 {
16262 PyThreadState* __tstate = wxPyBeginAllowThreads();
16263 result = (bool)(arg1)->HasPOV();
16264 wxPyEndAllowThreads(__tstate);
16265 if (PyErr_Occurred()) SWIG_fail;
16266 }
16267 {
16268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16269 }
16270 return resultobj;
16271 fail:
16272 return NULL;
16273 }
16274
16275
16276 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16277 PyObject *resultobj = 0;
16278 wxJoystick *arg1 = (wxJoystick *) 0 ;
16279 bool result;
16280 void *argp1 = 0 ;
16281 int res1 = 0 ;
16282 PyObject *swig_obj[1] ;
16283
16284 if (!args) SWIG_fail;
16285 swig_obj[0] = args;
16286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16287 if (!SWIG_IsOK(res1)) {
16288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16289 }
16290 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16291 {
16292 PyThreadState* __tstate = wxPyBeginAllowThreads();
16293 result = (bool)(arg1)->HasPOV4Dir();
16294 wxPyEndAllowThreads(__tstate);
16295 if (PyErr_Occurred()) SWIG_fail;
16296 }
16297 {
16298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16299 }
16300 return resultobj;
16301 fail:
16302 return NULL;
16303 }
16304
16305
16306 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16307 PyObject *resultobj = 0;
16308 wxJoystick *arg1 = (wxJoystick *) 0 ;
16309 bool result;
16310 void *argp1 = 0 ;
16311 int res1 = 0 ;
16312 PyObject *swig_obj[1] ;
16313
16314 if (!args) SWIG_fail;
16315 swig_obj[0] = args;
16316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16317 if (!SWIG_IsOK(res1)) {
16318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16319 }
16320 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16321 {
16322 PyThreadState* __tstate = wxPyBeginAllowThreads();
16323 result = (bool)(arg1)->HasPOVCTS();
16324 wxPyEndAllowThreads(__tstate);
16325 if (PyErr_Occurred()) SWIG_fail;
16326 }
16327 {
16328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16329 }
16330 return resultobj;
16331 fail:
16332 return NULL;
16333 }
16334
16335
16336 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16337 PyObject *resultobj = 0;
16338 wxJoystick *arg1 = (wxJoystick *) 0 ;
16339 wxWindow *arg2 = (wxWindow *) 0 ;
16340 int arg3 = (int) 0 ;
16341 bool result;
16342 void *argp1 = 0 ;
16343 int res1 = 0 ;
16344 void *argp2 = 0 ;
16345 int res2 = 0 ;
16346 int val3 ;
16347 int ecode3 = 0 ;
16348 PyObject * obj0 = 0 ;
16349 PyObject * obj1 = 0 ;
16350 PyObject * obj2 = 0 ;
16351 char * kwnames[] = {
16352 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16353 };
16354
16355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16357 if (!SWIG_IsOK(res1)) {
16358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16359 }
16360 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16361 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16362 if (!SWIG_IsOK(res2)) {
16363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16364 }
16365 arg2 = reinterpret_cast< wxWindow * >(argp2);
16366 if (obj2) {
16367 ecode3 = SWIG_AsVal_int(obj2, &val3);
16368 if (!SWIG_IsOK(ecode3)) {
16369 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16370 }
16371 arg3 = static_cast< int >(val3);
16372 }
16373 {
16374 PyThreadState* __tstate = wxPyBeginAllowThreads();
16375 result = (bool)(arg1)->SetCapture(arg2,arg3);
16376 wxPyEndAllowThreads(__tstate);
16377 if (PyErr_Occurred()) SWIG_fail;
16378 }
16379 {
16380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16381 }
16382 return resultobj;
16383 fail:
16384 return NULL;
16385 }
16386
16387
16388 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16389 PyObject *resultobj = 0;
16390 wxJoystick *arg1 = (wxJoystick *) 0 ;
16391 bool result;
16392 void *argp1 = 0 ;
16393 int res1 = 0 ;
16394 PyObject *swig_obj[1] ;
16395
16396 if (!args) SWIG_fail;
16397 swig_obj[0] = args;
16398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16399 if (!SWIG_IsOK(res1)) {
16400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16401 }
16402 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16403 {
16404 PyThreadState* __tstate = wxPyBeginAllowThreads();
16405 result = (bool)(arg1)->ReleaseCapture();
16406 wxPyEndAllowThreads(__tstate);
16407 if (PyErr_Occurred()) SWIG_fail;
16408 }
16409 {
16410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16411 }
16412 return resultobj;
16413 fail:
16414 return NULL;
16415 }
16416
16417
16418 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16419 PyObject *obj;
16420 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16421 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16422 return SWIG_Py_Void();
16423 }
16424
16425 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16426 return SWIG_Python_InitShadowInstance(args);
16427 }
16428
16429 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16430 PyObject *resultobj = 0;
16431 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16432 int arg2 = (int) 0 ;
16433 int arg3 = (int) wxJOYSTICK1 ;
16434 int arg4 = (int) 0 ;
16435 wxJoystickEvent *result = 0 ;
16436 int val1 ;
16437 int ecode1 = 0 ;
16438 int val2 ;
16439 int ecode2 = 0 ;
16440 int val3 ;
16441 int ecode3 = 0 ;
16442 int val4 ;
16443 int ecode4 = 0 ;
16444 PyObject * obj0 = 0 ;
16445 PyObject * obj1 = 0 ;
16446 PyObject * obj2 = 0 ;
16447 PyObject * obj3 = 0 ;
16448 char * kwnames[] = {
16449 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16450 };
16451
16452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16453 if (obj0) {
16454 ecode1 = SWIG_AsVal_int(obj0, &val1);
16455 if (!SWIG_IsOK(ecode1)) {
16456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16457 }
16458 arg1 = static_cast< wxEventType >(val1);
16459 }
16460 if (obj1) {
16461 ecode2 = SWIG_AsVal_int(obj1, &val2);
16462 if (!SWIG_IsOK(ecode2)) {
16463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16464 }
16465 arg2 = static_cast< int >(val2);
16466 }
16467 if (obj2) {
16468 ecode3 = SWIG_AsVal_int(obj2, &val3);
16469 if (!SWIG_IsOK(ecode3)) {
16470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16471 }
16472 arg3 = static_cast< int >(val3);
16473 }
16474 if (obj3) {
16475 ecode4 = SWIG_AsVal_int(obj3, &val4);
16476 if (!SWIG_IsOK(ecode4)) {
16477 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16478 }
16479 arg4 = static_cast< int >(val4);
16480 }
16481 {
16482 PyThreadState* __tstate = wxPyBeginAllowThreads();
16483 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16484 wxPyEndAllowThreads(__tstate);
16485 if (PyErr_Occurred()) SWIG_fail;
16486 }
16487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16488 return resultobj;
16489 fail:
16490 return NULL;
16491 }
16492
16493
16494 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16495 PyObject *resultobj = 0;
16496 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16497 wxPoint result;
16498 void *argp1 = 0 ;
16499 int res1 = 0 ;
16500 PyObject *swig_obj[1] ;
16501
16502 if (!args) SWIG_fail;
16503 swig_obj[0] = args;
16504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16505 if (!SWIG_IsOK(res1)) {
16506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16507 }
16508 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16509 {
16510 PyThreadState* __tstate = wxPyBeginAllowThreads();
16511 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16512 wxPyEndAllowThreads(__tstate);
16513 if (PyErr_Occurred()) SWIG_fail;
16514 }
16515 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16516 return resultobj;
16517 fail:
16518 return NULL;
16519 }
16520
16521
16522 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16523 PyObject *resultobj = 0;
16524 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16525 int result;
16526 void *argp1 = 0 ;
16527 int res1 = 0 ;
16528 PyObject *swig_obj[1] ;
16529
16530 if (!args) SWIG_fail;
16531 swig_obj[0] = args;
16532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16533 if (!SWIG_IsOK(res1)) {
16534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16535 }
16536 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16537 {
16538 PyThreadState* __tstate = wxPyBeginAllowThreads();
16539 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16540 wxPyEndAllowThreads(__tstate);
16541 if (PyErr_Occurred()) SWIG_fail;
16542 }
16543 resultobj = SWIG_From_int(static_cast< int >(result));
16544 return resultobj;
16545 fail:
16546 return NULL;
16547 }
16548
16549
16550 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16551 PyObject *resultobj = 0;
16552 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16553 int result;
16554 void *argp1 = 0 ;
16555 int res1 = 0 ;
16556 PyObject *swig_obj[1] ;
16557
16558 if (!args) SWIG_fail;
16559 swig_obj[0] = args;
16560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16561 if (!SWIG_IsOK(res1)) {
16562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16563 }
16564 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16565 {
16566 PyThreadState* __tstate = wxPyBeginAllowThreads();
16567 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16568 wxPyEndAllowThreads(__tstate);
16569 if (PyErr_Occurred()) SWIG_fail;
16570 }
16571 resultobj = SWIG_From_int(static_cast< int >(result));
16572 return resultobj;
16573 fail:
16574 return NULL;
16575 }
16576
16577
16578 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16579 PyObject *resultobj = 0;
16580 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16581 int result;
16582 void *argp1 = 0 ;
16583 int res1 = 0 ;
16584 PyObject *swig_obj[1] ;
16585
16586 if (!args) SWIG_fail;
16587 swig_obj[0] = args;
16588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16589 if (!SWIG_IsOK(res1)) {
16590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16591 }
16592 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16593 {
16594 PyThreadState* __tstate = wxPyBeginAllowThreads();
16595 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16596 wxPyEndAllowThreads(__tstate);
16597 if (PyErr_Occurred()) SWIG_fail;
16598 }
16599 resultobj = SWIG_From_int(static_cast< int >(result));
16600 return resultobj;
16601 fail:
16602 return NULL;
16603 }
16604
16605
16606 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16607 PyObject *resultobj = 0;
16608 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16609 int result;
16610 void *argp1 = 0 ;
16611 int res1 = 0 ;
16612 PyObject *swig_obj[1] ;
16613
16614 if (!args) SWIG_fail;
16615 swig_obj[0] = args;
16616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16617 if (!SWIG_IsOK(res1)) {
16618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16619 }
16620 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16621 {
16622 PyThreadState* __tstate = wxPyBeginAllowThreads();
16623 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16624 wxPyEndAllowThreads(__tstate);
16625 if (PyErr_Occurred()) SWIG_fail;
16626 }
16627 resultobj = SWIG_From_int(static_cast< int >(result));
16628 return resultobj;
16629 fail:
16630 return NULL;
16631 }
16632
16633
16634 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16635 PyObject *resultobj = 0;
16636 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16637 int arg2 ;
16638 void *argp1 = 0 ;
16639 int res1 = 0 ;
16640 int val2 ;
16641 int ecode2 = 0 ;
16642 PyObject * obj0 = 0 ;
16643 PyObject * obj1 = 0 ;
16644 char * kwnames[] = {
16645 (char *) "self",(char *) "stick", NULL
16646 };
16647
16648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16650 if (!SWIG_IsOK(res1)) {
16651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16652 }
16653 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16654 ecode2 = SWIG_AsVal_int(obj1, &val2);
16655 if (!SWIG_IsOK(ecode2)) {
16656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16657 }
16658 arg2 = static_cast< int >(val2);
16659 {
16660 PyThreadState* __tstate = wxPyBeginAllowThreads();
16661 (arg1)->SetJoystick(arg2);
16662 wxPyEndAllowThreads(__tstate);
16663 if (PyErr_Occurred()) SWIG_fail;
16664 }
16665 resultobj = SWIG_Py_Void();
16666 return resultobj;
16667 fail:
16668 return NULL;
16669 }
16670
16671
16672 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16673 PyObject *resultobj = 0;
16674 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16675 int arg2 ;
16676 void *argp1 = 0 ;
16677 int res1 = 0 ;
16678 int val2 ;
16679 int ecode2 = 0 ;
16680 PyObject * obj0 = 0 ;
16681 PyObject * obj1 = 0 ;
16682 char * kwnames[] = {
16683 (char *) "self",(char *) "state", NULL
16684 };
16685
16686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16688 if (!SWIG_IsOK(res1)) {
16689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16690 }
16691 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16692 ecode2 = SWIG_AsVal_int(obj1, &val2);
16693 if (!SWIG_IsOK(ecode2)) {
16694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16695 }
16696 arg2 = static_cast< int >(val2);
16697 {
16698 PyThreadState* __tstate = wxPyBeginAllowThreads();
16699 (arg1)->SetButtonState(arg2);
16700 wxPyEndAllowThreads(__tstate);
16701 if (PyErr_Occurred()) SWIG_fail;
16702 }
16703 resultobj = SWIG_Py_Void();
16704 return resultobj;
16705 fail:
16706 return NULL;
16707 }
16708
16709
16710 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16711 PyObject *resultobj = 0;
16712 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16713 int arg2 ;
16714 void *argp1 = 0 ;
16715 int res1 = 0 ;
16716 int val2 ;
16717 int ecode2 = 0 ;
16718 PyObject * obj0 = 0 ;
16719 PyObject * obj1 = 0 ;
16720 char * kwnames[] = {
16721 (char *) "self",(char *) "change", NULL
16722 };
16723
16724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16726 if (!SWIG_IsOK(res1)) {
16727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16728 }
16729 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16730 ecode2 = SWIG_AsVal_int(obj1, &val2);
16731 if (!SWIG_IsOK(ecode2)) {
16732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16733 }
16734 arg2 = static_cast< int >(val2);
16735 {
16736 PyThreadState* __tstate = wxPyBeginAllowThreads();
16737 (arg1)->SetButtonChange(arg2);
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 resultobj = SWIG_Py_Void();
16742 return resultobj;
16743 fail:
16744 return NULL;
16745 }
16746
16747
16748 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16749 PyObject *resultobj = 0;
16750 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16751 wxPoint *arg2 = 0 ;
16752 void *argp1 = 0 ;
16753 int res1 = 0 ;
16754 wxPoint temp2 ;
16755 PyObject * obj0 = 0 ;
16756 PyObject * obj1 = 0 ;
16757 char * kwnames[] = {
16758 (char *) "self",(char *) "pos", NULL
16759 };
16760
16761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16763 if (!SWIG_IsOK(res1)) {
16764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16765 }
16766 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16767 {
16768 arg2 = &temp2;
16769 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16770 }
16771 {
16772 PyThreadState* __tstate = wxPyBeginAllowThreads();
16773 (arg1)->SetPosition((wxPoint const &)*arg2);
16774 wxPyEndAllowThreads(__tstate);
16775 if (PyErr_Occurred()) SWIG_fail;
16776 }
16777 resultobj = SWIG_Py_Void();
16778 return resultobj;
16779 fail:
16780 return NULL;
16781 }
16782
16783
16784 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16785 PyObject *resultobj = 0;
16786 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16787 int arg2 ;
16788 void *argp1 = 0 ;
16789 int res1 = 0 ;
16790 int val2 ;
16791 int ecode2 = 0 ;
16792 PyObject * obj0 = 0 ;
16793 PyObject * obj1 = 0 ;
16794 char * kwnames[] = {
16795 (char *) "self",(char *) "zPos", NULL
16796 };
16797
16798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16800 if (!SWIG_IsOK(res1)) {
16801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16802 }
16803 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16804 ecode2 = SWIG_AsVal_int(obj1, &val2);
16805 if (!SWIG_IsOK(ecode2)) {
16806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16807 }
16808 arg2 = static_cast< int >(val2);
16809 {
16810 PyThreadState* __tstate = wxPyBeginAllowThreads();
16811 (arg1)->SetZPosition(arg2);
16812 wxPyEndAllowThreads(__tstate);
16813 if (PyErr_Occurred()) SWIG_fail;
16814 }
16815 resultobj = SWIG_Py_Void();
16816 return resultobj;
16817 fail:
16818 return NULL;
16819 }
16820
16821
16822 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16823 PyObject *resultobj = 0;
16824 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16825 bool result;
16826 void *argp1 = 0 ;
16827 int res1 = 0 ;
16828 PyObject *swig_obj[1] ;
16829
16830 if (!args) SWIG_fail;
16831 swig_obj[0] = args;
16832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16833 if (!SWIG_IsOK(res1)) {
16834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16835 }
16836 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16837 {
16838 PyThreadState* __tstate = wxPyBeginAllowThreads();
16839 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16840 wxPyEndAllowThreads(__tstate);
16841 if (PyErr_Occurred()) SWIG_fail;
16842 }
16843 {
16844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16845 }
16846 return resultobj;
16847 fail:
16848 return NULL;
16849 }
16850
16851
16852 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16853 PyObject *resultobj = 0;
16854 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16855 bool result;
16856 void *argp1 = 0 ;
16857 int res1 = 0 ;
16858 PyObject *swig_obj[1] ;
16859
16860 if (!args) SWIG_fail;
16861 swig_obj[0] = args;
16862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16863 if (!SWIG_IsOK(res1)) {
16864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16865 }
16866 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16867 {
16868 PyThreadState* __tstate = wxPyBeginAllowThreads();
16869 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16870 wxPyEndAllowThreads(__tstate);
16871 if (PyErr_Occurred()) SWIG_fail;
16872 }
16873 {
16874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16875 }
16876 return resultobj;
16877 fail:
16878 return NULL;
16879 }
16880
16881
16882 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16883 PyObject *resultobj = 0;
16884 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16885 bool result;
16886 void *argp1 = 0 ;
16887 int res1 = 0 ;
16888 PyObject *swig_obj[1] ;
16889
16890 if (!args) SWIG_fail;
16891 swig_obj[0] = args;
16892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16893 if (!SWIG_IsOK(res1)) {
16894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16895 }
16896 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16897 {
16898 PyThreadState* __tstate = wxPyBeginAllowThreads();
16899 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16900 wxPyEndAllowThreads(__tstate);
16901 if (PyErr_Occurred()) SWIG_fail;
16902 }
16903 {
16904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16905 }
16906 return resultobj;
16907 fail:
16908 return NULL;
16909 }
16910
16911
16912 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16913 PyObject *resultobj = 0;
16914 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16915 int arg2 = (int) wxJOY_BUTTON_ANY ;
16916 bool result;
16917 void *argp1 = 0 ;
16918 int res1 = 0 ;
16919 int val2 ;
16920 int ecode2 = 0 ;
16921 PyObject * obj0 = 0 ;
16922 PyObject * obj1 = 0 ;
16923 char * kwnames[] = {
16924 (char *) "self",(char *) "but", NULL
16925 };
16926
16927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
16928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16929 if (!SWIG_IsOK(res1)) {
16930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16931 }
16932 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16933 if (obj1) {
16934 ecode2 = SWIG_AsVal_int(obj1, &val2);
16935 if (!SWIG_IsOK(ecode2)) {
16936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
16937 }
16938 arg2 = static_cast< int >(val2);
16939 }
16940 {
16941 PyThreadState* __tstate = wxPyBeginAllowThreads();
16942 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
16943 wxPyEndAllowThreads(__tstate);
16944 if (PyErr_Occurred()) SWIG_fail;
16945 }
16946 {
16947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16948 }
16949 return resultobj;
16950 fail:
16951 return NULL;
16952 }
16953
16954
16955 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16956 PyObject *resultobj = 0;
16957 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16958 int arg2 = (int) wxJOY_BUTTON_ANY ;
16959 bool result;
16960 void *argp1 = 0 ;
16961 int res1 = 0 ;
16962 int val2 ;
16963 int ecode2 = 0 ;
16964 PyObject * obj0 = 0 ;
16965 PyObject * obj1 = 0 ;
16966 char * kwnames[] = {
16967 (char *) "self",(char *) "but", NULL
16968 };
16969
16970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
16971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16972 if (!SWIG_IsOK(res1)) {
16973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16974 }
16975 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16976 if (obj1) {
16977 ecode2 = SWIG_AsVal_int(obj1, &val2);
16978 if (!SWIG_IsOK(ecode2)) {
16979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
16980 }
16981 arg2 = static_cast< int >(val2);
16982 }
16983 {
16984 PyThreadState* __tstate = wxPyBeginAllowThreads();
16985 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
16986 wxPyEndAllowThreads(__tstate);
16987 if (PyErr_Occurred()) SWIG_fail;
16988 }
16989 {
16990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16991 }
16992 return resultobj;
16993 fail:
16994 return NULL;
16995 }
16996
16997
16998 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16999 PyObject *resultobj = 0;
17000 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17001 int arg2 = (int) wxJOY_BUTTON_ANY ;
17002 bool result;
17003 void *argp1 = 0 ;
17004 int res1 = 0 ;
17005 int val2 ;
17006 int ecode2 = 0 ;
17007 PyObject * obj0 = 0 ;
17008 PyObject * obj1 = 0 ;
17009 char * kwnames[] = {
17010 (char *) "self",(char *) "but", NULL
17011 };
17012
17013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17015 if (!SWIG_IsOK(res1)) {
17016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17017 }
17018 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17019 if (obj1) {
17020 ecode2 = SWIG_AsVal_int(obj1, &val2);
17021 if (!SWIG_IsOK(ecode2)) {
17022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17023 }
17024 arg2 = static_cast< int >(val2);
17025 }
17026 {
17027 PyThreadState* __tstate = wxPyBeginAllowThreads();
17028 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17029 wxPyEndAllowThreads(__tstate);
17030 if (PyErr_Occurred()) SWIG_fail;
17031 }
17032 {
17033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17034 }
17035 return resultobj;
17036 fail:
17037 return NULL;
17038 }
17039
17040
17041 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17042 PyObject *obj;
17043 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17044 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17045 return SWIG_Py_Void();
17046 }
17047
17048 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17049 return SWIG_Python_InitShadowInstance(args);
17050 }
17051
17052 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17053 PyObject *resultobj = 0;
17054 wxString const &arg1_defvalue = wxPyEmptyString ;
17055 wxString *arg1 = (wxString *) &arg1_defvalue ;
17056 wxSound *result = 0 ;
17057 bool temp1 = false ;
17058 PyObject * obj0 = 0 ;
17059 char * kwnames[] = {
17060 (char *) "fileName", NULL
17061 };
17062
17063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17064 if (obj0) {
17065 {
17066 arg1 = wxString_in_helper(obj0);
17067 if (arg1 == NULL) SWIG_fail;
17068 temp1 = true;
17069 }
17070 }
17071 {
17072 if (!wxPyCheckForApp()) SWIG_fail;
17073 PyThreadState* __tstate = wxPyBeginAllowThreads();
17074 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17075 wxPyEndAllowThreads(__tstate);
17076 if (PyErr_Occurred()) SWIG_fail;
17077 }
17078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17079 {
17080 if (temp1)
17081 delete arg1;
17082 }
17083 return resultobj;
17084 fail:
17085 {
17086 if (temp1)
17087 delete arg1;
17088 }
17089 return NULL;
17090 }
17091
17092
17093 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17094 PyObject *resultobj = 0;
17095 PyObject *arg1 = (PyObject *) 0 ;
17096 wxSound *result = 0 ;
17097 PyObject * obj0 = 0 ;
17098 char * kwnames[] = {
17099 (char *) "data", NULL
17100 };
17101
17102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17103 arg1 = obj0;
17104 {
17105 if (!wxPyCheckForApp()) SWIG_fail;
17106 PyThreadState* __tstate = wxPyBeginAllowThreads();
17107 result = (wxSound *)new_wxSound(arg1);
17108 wxPyEndAllowThreads(__tstate);
17109 if (PyErr_Occurred()) SWIG_fail;
17110 }
17111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17112 return resultobj;
17113 fail:
17114 return NULL;
17115 }
17116
17117
17118 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17119 PyObject *resultobj = 0;
17120 wxSound *arg1 = (wxSound *) 0 ;
17121 void *argp1 = 0 ;
17122 int res1 = 0 ;
17123 PyObject *swig_obj[1] ;
17124
17125 if (!args) SWIG_fail;
17126 swig_obj[0] = args;
17127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17128 if (!SWIG_IsOK(res1)) {
17129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17130 }
17131 arg1 = reinterpret_cast< wxSound * >(argp1);
17132 {
17133 PyThreadState* __tstate = wxPyBeginAllowThreads();
17134 delete arg1;
17135
17136 wxPyEndAllowThreads(__tstate);
17137 if (PyErr_Occurred()) SWIG_fail;
17138 }
17139 resultobj = SWIG_Py_Void();
17140 return resultobj;
17141 fail:
17142 return NULL;
17143 }
17144
17145
17146 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17147 PyObject *resultobj = 0;
17148 wxSound *arg1 = (wxSound *) 0 ;
17149 wxString *arg2 = 0 ;
17150 bool result;
17151 void *argp1 = 0 ;
17152 int res1 = 0 ;
17153 bool temp2 = false ;
17154 PyObject * obj0 = 0 ;
17155 PyObject * obj1 = 0 ;
17156 char * kwnames[] = {
17157 (char *) "self",(char *) "fileName", NULL
17158 };
17159
17160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17162 if (!SWIG_IsOK(res1)) {
17163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17164 }
17165 arg1 = reinterpret_cast< wxSound * >(argp1);
17166 {
17167 arg2 = wxString_in_helper(obj1);
17168 if (arg2 == NULL) SWIG_fail;
17169 temp2 = true;
17170 }
17171 {
17172 PyThreadState* __tstate = wxPyBeginAllowThreads();
17173 result = (bool)(arg1)->Create((wxString const &)*arg2);
17174 wxPyEndAllowThreads(__tstate);
17175 if (PyErr_Occurred()) SWIG_fail;
17176 }
17177 {
17178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17179 }
17180 {
17181 if (temp2)
17182 delete arg2;
17183 }
17184 return resultobj;
17185 fail:
17186 {
17187 if (temp2)
17188 delete arg2;
17189 }
17190 return NULL;
17191 }
17192
17193
17194 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17195 PyObject *resultobj = 0;
17196 wxSound *arg1 = (wxSound *) 0 ;
17197 PyObject *arg2 = (PyObject *) 0 ;
17198 bool result;
17199 void *argp1 = 0 ;
17200 int res1 = 0 ;
17201 PyObject * obj0 = 0 ;
17202 PyObject * obj1 = 0 ;
17203 char * kwnames[] = {
17204 (char *) "self",(char *) "data", NULL
17205 };
17206
17207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17209 if (!SWIG_IsOK(res1)) {
17210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17211 }
17212 arg1 = reinterpret_cast< wxSound * >(argp1);
17213 arg2 = obj1;
17214 {
17215 PyThreadState* __tstate = wxPyBeginAllowThreads();
17216 result = (bool)wxSound_CreateFromData(arg1,arg2);
17217 wxPyEndAllowThreads(__tstate);
17218 if (PyErr_Occurred()) SWIG_fail;
17219 }
17220 {
17221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17222 }
17223 return resultobj;
17224 fail:
17225 return NULL;
17226 }
17227
17228
17229 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17230 PyObject *resultobj = 0;
17231 wxSound *arg1 = (wxSound *) 0 ;
17232 bool result;
17233 void *argp1 = 0 ;
17234 int res1 = 0 ;
17235 PyObject *swig_obj[1] ;
17236
17237 if (!args) SWIG_fail;
17238 swig_obj[0] = args;
17239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17240 if (!SWIG_IsOK(res1)) {
17241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17242 }
17243 arg1 = reinterpret_cast< wxSound * >(argp1);
17244 {
17245 PyThreadState* __tstate = wxPyBeginAllowThreads();
17246 result = (bool)(arg1)->IsOk();
17247 wxPyEndAllowThreads(__tstate);
17248 if (PyErr_Occurred()) SWIG_fail;
17249 }
17250 {
17251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17252 }
17253 return resultobj;
17254 fail:
17255 return NULL;
17256 }
17257
17258
17259 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17260 PyObject *resultobj = 0;
17261 wxSound *arg1 = (wxSound *) 0 ;
17262 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17263 bool result;
17264 void *argp1 = 0 ;
17265 int res1 = 0 ;
17266 unsigned int val2 ;
17267 int ecode2 = 0 ;
17268 PyObject * obj0 = 0 ;
17269 PyObject * obj1 = 0 ;
17270 char * kwnames[] = {
17271 (char *) "self",(char *) "flags", NULL
17272 };
17273
17274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17276 if (!SWIG_IsOK(res1)) {
17277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17278 }
17279 arg1 = reinterpret_cast< wxSound * >(argp1);
17280 if (obj1) {
17281 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17282 if (!SWIG_IsOK(ecode2)) {
17283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17284 }
17285 arg2 = static_cast< unsigned int >(val2);
17286 }
17287 {
17288 if (!wxPyCheckForApp()) SWIG_fail;
17289 PyThreadState* __tstate = wxPyBeginAllowThreads();
17290 result = (bool)((wxSound const *)arg1)->Play(arg2);
17291 wxPyEndAllowThreads(__tstate);
17292 if (PyErr_Occurred()) SWIG_fail;
17293 }
17294 {
17295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17296 }
17297 return resultobj;
17298 fail:
17299 return NULL;
17300 }
17301
17302
17303 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17304 PyObject *resultobj = 0;
17305 wxString *arg1 = 0 ;
17306 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17307 bool result;
17308 bool temp1 = false ;
17309 unsigned int val2 ;
17310 int ecode2 = 0 ;
17311 PyObject * obj0 = 0 ;
17312 PyObject * obj1 = 0 ;
17313 char * kwnames[] = {
17314 (char *) "filename",(char *) "flags", NULL
17315 };
17316
17317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17318 {
17319 arg1 = wxString_in_helper(obj0);
17320 if (arg1 == NULL) SWIG_fail;
17321 temp1 = true;
17322 }
17323 if (obj1) {
17324 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17325 if (!SWIG_IsOK(ecode2)) {
17326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17327 }
17328 arg2 = static_cast< unsigned int >(val2);
17329 }
17330 {
17331 if (!wxPyCheckForApp()) SWIG_fail;
17332 PyThreadState* __tstate = wxPyBeginAllowThreads();
17333 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17334 wxPyEndAllowThreads(__tstate);
17335 if (PyErr_Occurred()) SWIG_fail;
17336 }
17337 {
17338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17339 }
17340 {
17341 if (temp1)
17342 delete arg1;
17343 }
17344 return resultobj;
17345 fail:
17346 {
17347 if (temp1)
17348 delete arg1;
17349 }
17350 return NULL;
17351 }
17352
17353
17354 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17355 PyObject *resultobj = 0;
17356
17357 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17358 {
17359 if (!wxPyCheckForApp()) SWIG_fail;
17360 PyThreadState* __tstate = wxPyBeginAllowThreads();
17361 wxSound::Stop();
17362 wxPyEndAllowThreads(__tstate);
17363 if (PyErr_Occurred()) SWIG_fail;
17364 }
17365 resultobj = SWIG_Py_Void();
17366 return resultobj;
17367 fail:
17368 return NULL;
17369 }
17370
17371
17372 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17373 PyObject *obj;
17374 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17375 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17376 return SWIG_Py_Void();
17377 }
17378
17379 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17380 return SWIG_Python_InitShadowInstance(args);
17381 }
17382
17383 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17384 PyObject *resultobj = 0;
17385 wxString *arg1 = 0 ;
17386 wxString *arg2 = 0 ;
17387 wxString *arg3 = 0 ;
17388 wxString *arg4 = 0 ;
17389 wxFileTypeInfo *result = 0 ;
17390 bool temp1 = false ;
17391 bool temp2 = false ;
17392 bool temp3 = false ;
17393 bool temp4 = false ;
17394 PyObject * obj0 = 0 ;
17395 PyObject * obj1 = 0 ;
17396 PyObject * obj2 = 0 ;
17397 PyObject * obj3 = 0 ;
17398 char * kwnames[] = {
17399 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17400 };
17401
17402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17403 {
17404 arg1 = wxString_in_helper(obj0);
17405 if (arg1 == NULL) SWIG_fail;
17406 temp1 = true;
17407 }
17408 {
17409 arg2 = wxString_in_helper(obj1);
17410 if (arg2 == NULL) SWIG_fail;
17411 temp2 = true;
17412 }
17413 {
17414 arg3 = wxString_in_helper(obj2);
17415 if (arg3 == NULL) SWIG_fail;
17416 temp3 = true;
17417 }
17418 {
17419 arg4 = wxString_in_helper(obj3);
17420 if (arg4 == NULL) SWIG_fail;
17421 temp4 = true;
17422 }
17423 {
17424 PyThreadState* __tstate = wxPyBeginAllowThreads();
17425 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17426 wxPyEndAllowThreads(__tstate);
17427 if (PyErr_Occurred()) SWIG_fail;
17428 }
17429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17430 {
17431 if (temp1)
17432 delete arg1;
17433 }
17434 {
17435 if (temp2)
17436 delete arg2;
17437 }
17438 {
17439 if (temp3)
17440 delete arg3;
17441 }
17442 {
17443 if (temp4)
17444 delete arg4;
17445 }
17446 return resultobj;
17447 fail:
17448 {
17449 if (temp1)
17450 delete arg1;
17451 }
17452 {
17453 if (temp2)
17454 delete arg2;
17455 }
17456 {
17457 if (temp3)
17458 delete arg3;
17459 }
17460 {
17461 if (temp4)
17462 delete arg4;
17463 }
17464 return NULL;
17465 }
17466
17467
17468 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17469 PyObject *resultobj = 0;
17470 wxArrayString *arg1 = 0 ;
17471 wxFileTypeInfo *result = 0 ;
17472 bool temp1 = false ;
17473 PyObject * obj0 = 0 ;
17474 char * kwnames[] = {
17475 (char *) "sArray", NULL
17476 };
17477
17478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17479 {
17480 if (! PySequence_Check(obj0)) {
17481 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17482 SWIG_fail;
17483 }
17484 arg1 = new wxArrayString;
17485 temp1 = true;
17486 int i, len=PySequence_Length(obj0);
17487 for (i=0; i<len; i++) {
17488 PyObject* item = PySequence_GetItem(obj0, i);
17489 wxString* s = wxString_in_helper(item);
17490 if (PyErr_Occurred()) SWIG_fail;
17491 arg1->Add(*s);
17492 delete s;
17493 Py_DECREF(item);
17494 }
17495 }
17496 {
17497 PyThreadState* __tstate = wxPyBeginAllowThreads();
17498 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17499 wxPyEndAllowThreads(__tstate);
17500 if (PyErr_Occurred()) SWIG_fail;
17501 }
17502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17503 {
17504 if (temp1) delete arg1;
17505 }
17506 return resultobj;
17507 fail:
17508 {
17509 if (temp1) delete arg1;
17510 }
17511 return NULL;
17512 }
17513
17514
17515 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17516 PyObject *resultobj = 0;
17517 wxFileTypeInfo *result = 0 ;
17518
17519 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17520 {
17521 PyThreadState* __tstate = wxPyBeginAllowThreads();
17522 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17523 wxPyEndAllowThreads(__tstate);
17524 if (PyErr_Occurred()) SWIG_fail;
17525 }
17526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17527 return resultobj;
17528 fail:
17529 return NULL;
17530 }
17531
17532
17533 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17534 PyObject *resultobj = 0;
17535 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17536 bool result;
17537 void *argp1 = 0 ;
17538 int res1 = 0 ;
17539 PyObject *swig_obj[1] ;
17540
17541 if (!args) SWIG_fail;
17542 swig_obj[0] = args;
17543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17544 if (!SWIG_IsOK(res1)) {
17545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17546 }
17547 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17548 {
17549 PyThreadState* __tstate = wxPyBeginAllowThreads();
17550 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17551 wxPyEndAllowThreads(__tstate);
17552 if (PyErr_Occurred()) SWIG_fail;
17553 }
17554 {
17555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17556 }
17557 return resultobj;
17558 fail:
17559 return NULL;
17560 }
17561
17562
17563 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17564 PyObject *resultobj = 0;
17565 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17566 wxString *arg2 = 0 ;
17567 int arg3 = (int) 0 ;
17568 void *argp1 = 0 ;
17569 int res1 = 0 ;
17570 bool temp2 = false ;
17571 int val3 ;
17572 int ecode3 = 0 ;
17573 PyObject * obj0 = 0 ;
17574 PyObject * obj1 = 0 ;
17575 PyObject * obj2 = 0 ;
17576 char * kwnames[] = {
17577 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17578 };
17579
17580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17582 if (!SWIG_IsOK(res1)) {
17583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17584 }
17585 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17586 {
17587 arg2 = wxString_in_helper(obj1);
17588 if (arg2 == NULL) SWIG_fail;
17589 temp2 = true;
17590 }
17591 if (obj2) {
17592 ecode3 = SWIG_AsVal_int(obj2, &val3);
17593 if (!SWIG_IsOK(ecode3)) {
17594 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17595 }
17596 arg3 = static_cast< int >(val3);
17597 }
17598 {
17599 PyThreadState* __tstate = wxPyBeginAllowThreads();
17600 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17601 wxPyEndAllowThreads(__tstate);
17602 if (PyErr_Occurred()) SWIG_fail;
17603 }
17604 resultobj = SWIG_Py_Void();
17605 {
17606 if (temp2)
17607 delete arg2;
17608 }
17609 return resultobj;
17610 fail:
17611 {
17612 if (temp2)
17613 delete arg2;
17614 }
17615 return NULL;
17616 }
17617
17618
17619 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17620 PyObject *resultobj = 0;
17621 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17622 wxString *arg2 = 0 ;
17623 void *argp1 = 0 ;
17624 int res1 = 0 ;
17625 bool temp2 = false ;
17626 PyObject * obj0 = 0 ;
17627 PyObject * obj1 = 0 ;
17628 char * kwnames[] = {
17629 (char *) "self",(char *) "shortDesc", NULL
17630 };
17631
17632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17634 if (!SWIG_IsOK(res1)) {
17635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17636 }
17637 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17638 {
17639 arg2 = wxString_in_helper(obj1);
17640 if (arg2 == NULL) SWIG_fail;
17641 temp2 = true;
17642 }
17643 {
17644 PyThreadState* __tstate = wxPyBeginAllowThreads();
17645 (arg1)->SetShortDesc((wxString const &)*arg2);
17646 wxPyEndAllowThreads(__tstate);
17647 if (PyErr_Occurred()) SWIG_fail;
17648 }
17649 resultobj = SWIG_Py_Void();
17650 {
17651 if (temp2)
17652 delete arg2;
17653 }
17654 return resultobj;
17655 fail:
17656 {
17657 if (temp2)
17658 delete arg2;
17659 }
17660 return NULL;
17661 }
17662
17663
17664 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17665 PyObject *resultobj = 0;
17666 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17667 wxString *result = 0 ;
17668 void *argp1 = 0 ;
17669 int res1 = 0 ;
17670 PyObject *swig_obj[1] ;
17671
17672 if (!args) SWIG_fail;
17673 swig_obj[0] = args;
17674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17675 if (!SWIG_IsOK(res1)) {
17676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17677 }
17678 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17679 {
17680 PyThreadState* __tstate = wxPyBeginAllowThreads();
17681 {
17682 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17683 result = (wxString *) &_result_ref;
17684 }
17685 wxPyEndAllowThreads(__tstate);
17686 if (PyErr_Occurred()) SWIG_fail;
17687 }
17688 {
17689 #if wxUSE_UNICODE
17690 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17691 #else
17692 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17693 #endif
17694 }
17695 return resultobj;
17696 fail:
17697 return NULL;
17698 }
17699
17700
17701 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17702 PyObject *resultobj = 0;
17703 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17704 wxString *result = 0 ;
17705 void *argp1 = 0 ;
17706 int res1 = 0 ;
17707 PyObject *swig_obj[1] ;
17708
17709 if (!args) SWIG_fail;
17710 swig_obj[0] = args;
17711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17712 if (!SWIG_IsOK(res1)) {
17713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17714 }
17715 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17716 {
17717 PyThreadState* __tstate = wxPyBeginAllowThreads();
17718 {
17719 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17720 result = (wxString *) &_result_ref;
17721 }
17722 wxPyEndAllowThreads(__tstate);
17723 if (PyErr_Occurred()) SWIG_fail;
17724 }
17725 {
17726 #if wxUSE_UNICODE
17727 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17728 #else
17729 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17730 #endif
17731 }
17732 return resultobj;
17733 fail:
17734 return NULL;
17735 }
17736
17737
17738 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17739 PyObject *resultobj = 0;
17740 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17741 wxString *result = 0 ;
17742 void *argp1 = 0 ;
17743 int res1 = 0 ;
17744 PyObject *swig_obj[1] ;
17745
17746 if (!args) SWIG_fail;
17747 swig_obj[0] = args;
17748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17749 if (!SWIG_IsOK(res1)) {
17750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17751 }
17752 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17753 {
17754 PyThreadState* __tstate = wxPyBeginAllowThreads();
17755 {
17756 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17757 result = (wxString *) &_result_ref;
17758 }
17759 wxPyEndAllowThreads(__tstate);
17760 if (PyErr_Occurred()) SWIG_fail;
17761 }
17762 {
17763 #if wxUSE_UNICODE
17764 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17765 #else
17766 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17767 #endif
17768 }
17769 return resultobj;
17770 fail:
17771 return NULL;
17772 }
17773
17774
17775 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17776 PyObject *resultobj = 0;
17777 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17778 wxString *result = 0 ;
17779 void *argp1 = 0 ;
17780 int res1 = 0 ;
17781 PyObject *swig_obj[1] ;
17782
17783 if (!args) SWIG_fail;
17784 swig_obj[0] = args;
17785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17786 if (!SWIG_IsOK(res1)) {
17787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17788 }
17789 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17790 {
17791 PyThreadState* __tstate = wxPyBeginAllowThreads();
17792 {
17793 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17794 result = (wxString *) &_result_ref;
17795 }
17796 wxPyEndAllowThreads(__tstate);
17797 if (PyErr_Occurred()) SWIG_fail;
17798 }
17799 {
17800 #if wxUSE_UNICODE
17801 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17802 #else
17803 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17804 #endif
17805 }
17806 return resultobj;
17807 fail:
17808 return NULL;
17809 }
17810
17811
17812 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17813 PyObject *resultobj = 0;
17814 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17815 wxString *result = 0 ;
17816 void *argp1 = 0 ;
17817 int res1 = 0 ;
17818 PyObject *swig_obj[1] ;
17819
17820 if (!args) SWIG_fail;
17821 swig_obj[0] = args;
17822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17823 if (!SWIG_IsOK(res1)) {
17824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17825 }
17826 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17827 {
17828 PyThreadState* __tstate = wxPyBeginAllowThreads();
17829 {
17830 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17831 result = (wxString *) &_result_ref;
17832 }
17833 wxPyEndAllowThreads(__tstate);
17834 if (PyErr_Occurred()) SWIG_fail;
17835 }
17836 {
17837 #if wxUSE_UNICODE
17838 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17839 #else
17840 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17841 #endif
17842 }
17843 return resultobj;
17844 fail:
17845 return NULL;
17846 }
17847
17848
17849 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17850 PyObject *resultobj = 0;
17851 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17852 wxArrayString *result = 0 ;
17853 void *argp1 = 0 ;
17854 int res1 = 0 ;
17855 PyObject *swig_obj[1] ;
17856
17857 if (!args) SWIG_fail;
17858 swig_obj[0] = args;
17859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17860 if (!SWIG_IsOK(res1)) {
17861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17862 }
17863 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17864 {
17865 PyThreadState* __tstate = wxPyBeginAllowThreads();
17866 {
17867 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17868 result = (wxArrayString *) &_result_ref;
17869 }
17870 wxPyEndAllowThreads(__tstate);
17871 if (PyErr_Occurred()) SWIG_fail;
17872 }
17873 {
17874 resultobj = wxArrayString2PyList_helper(*result);
17875 }
17876 return resultobj;
17877 fail:
17878 return NULL;
17879 }
17880
17881
17882 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17883 PyObject *resultobj = 0;
17884 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17885 size_t result;
17886 void *argp1 = 0 ;
17887 int res1 = 0 ;
17888 PyObject *swig_obj[1] ;
17889
17890 if (!args) SWIG_fail;
17891 swig_obj[0] = args;
17892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17893 if (!SWIG_IsOK(res1)) {
17894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17895 }
17896 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17897 {
17898 PyThreadState* __tstate = wxPyBeginAllowThreads();
17899 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17900 wxPyEndAllowThreads(__tstate);
17901 if (PyErr_Occurred()) SWIG_fail;
17902 }
17903 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17904 return resultobj;
17905 fail:
17906 return NULL;
17907 }
17908
17909
17910 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17911 PyObject *resultobj = 0;
17912 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17913 wxString *result = 0 ;
17914 void *argp1 = 0 ;
17915 int res1 = 0 ;
17916 PyObject *swig_obj[1] ;
17917
17918 if (!args) SWIG_fail;
17919 swig_obj[0] = args;
17920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17921 if (!SWIG_IsOK(res1)) {
17922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17923 }
17924 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17925 {
17926 PyThreadState* __tstate = wxPyBeginAllowThreads();
17927 {
17928 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
17929 result = (wxString *) &_result_ref;
17930 }
17931 wxPyEndAllowThreads(__tstate);
17932 if (PyErr_Occurred()) SWIG_fail;
17933 }
17934 {
17935 #if wxUSE_UNICODE
17936 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17937 #else
17938 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17939 #endif
17940 }
17941 return resultobj;
17942 fail:
17943 return NULL;
17944 }
17945
17946
17947 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17948 PyObject *resultobj = 0;
17949 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17950 int result;
17951 void *argp1 = 0 ;
17952 int res1 = 0 ;
17953 PyObject *swig_obj[1] ;
17954
17955 if (!args) SWIG_fail;
17956 swig_obj[0] = args;
17957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17958 if (!SWIG_IsOK(res1)) {
17959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17960 }
17961 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17962 {
17963 PyThreadState* __tstate = wxPyBeginAllowThreads();
17964 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
17965 wxPyEndAllowThreads(__tstate);
17966 if (PyErr_Occurred()) SWIG_fail;
17967 }
17968 resultobj = SWIG_From_int(static_cast< int >(result));
17969 return resultobj;
17970 fail:
17971 return NULL;
17972 }
17973
17974
17975 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17976 PyObject *obj;
17977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17978 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
17979 return SWIG_Py_Void();
17980 }
17981
17982 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17983 return SWIG_Python_InitShadowInstance(args);
17984 }
17985
17986 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17987 PyObject *resultobj = 0;
17988 wxFileTypeInfo *arg1 = 0 ;
17989 wxFileType *result = 0 ;
17990 void *argp1 = 0 ;
17991 int res1 = 0 ;
17992 PyObject * obj0 = 0 ;
17993 char * kwnames[] = {
17994 (char *) "ftInfo", NULL
17995 };
17996
17997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
17998 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17999 if (!SWIG_IsOK(res1)) {
18000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18001 }
18002 if (!argp1) {
18003 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18004 }
18005 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18006 {
18007 PyThreadState* __tstate = wxPyBeginAllowThreads();
18008 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18009 wxPyEndAllowThreads(__tstate);
18010 if (PyErr_Occurred()) SWIG_fail;
18011 }
18012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18013 return resultobj;
18014 fail:
18015 return NULL;
18016 }
18017
18018
18019 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18020 PyObject *resultobj = 0;
18021 wxFileType *arg1 = (wxFileType *) 0 ;
18022 void *argp1 = 0 ;
18023 int res1 = 0 ;
18024 PyObject *swig_obj[1] ;
18025
18026 if (!args) SWIG_fail;
18027 swig_obj[0] = args;
18028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18029 if (!SWIG_IsOK(res1)) {
18030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18031 }
18032 arg1 = reinterpret_cast< wxFileType * >(argp1);
18033 {
18034 PyThreadState* __tstate = wxPyBeginAllowThreads();
18035 delete arg1;
18036
18037 wxPyEndAllowThreads(__tstate);
18038 if (PyErr_Occurred()) SWIG_fail;
18039 }
18040 resultobj = SWIG_Py_Void();
18041 return resultobj;
18042 fail:
18043 return NULL;
18044 }
18045
18046
18047 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18048 PyObject *resultobj = 0;
18049 wxFileType *arg1 = (wxFileType *) 0 ;
18050 PyObject *result = 0 ;
18051 void *argp1 = 0 ;
18052 int res1 = 0 ;
18053 PyObject *swig_obj[1] ;
18054
18055 if (!args) SWIG_fail;
18056 swig_obj[0] = args;
18057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18058 if (!SWIG_IsOK(res1)) {
18059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18060 }
18061 arg1 = reinterpret_cast< wxFileType * >(argp1);
18062 {
18063 PyThreadState* __tstate = wxPyBeginAllowThreads();
18064 result = (PyObject *)wxFileType_GetMimeType(arg1);
18065 wxPyEndAllowThreads(__tstate);
18066 if (PyErr_Occurred()) SWIG_fail;
18067 }
18068 resultobj = result;
18069 return resultobj;
18070 fail:
18071 return NULL;
18072 }
18073
18074
18075 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18076 PyObject *resultobj = 0;
18077 wxFileType *arg1 = (wxFileType *) 0 ;
18078 PyObject *result = 0 ;
18079 void *argp1 = 0 ;
18080 int res1 = 0 ;
18081 PyObject *swig_obj[1] ;
18082
18083 if (!args) SWIG_fail;
18084 swig_obj[0] = args;
18085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18086 if (!SWIG_IsOK(res1)) {
18087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18088 }
18089 arg1 = reinterpret_cast< wxFileType * >(argp1);
18090 {
18091 PyThreadState* __tstate = wxPyBeginAllowThreads();
18092 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18093 wxPyEndAllowThreads(__tstate);
18094 if (PyErr_Occurred()) SWIG_fail;
18095 }
18096 resultobj = result;
18097 return resultobj;
18098 fail:
18099 return NULL;
18100 }
18101
18102
18103 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18104 PyObject *resultobj = 0;
18105 wxFileType *arg1 = (wxFileType *) 0 ;
18106 PyObject *result = 0 ;
18107 void *argp1 = 0 ;
18108 int res1 = 0 ;
18109 PyObject *swig_obj[1] ;
18110
18111 if (!args) SWIG_fail;
18112 swig_obj[0] = args;
18113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18114 if (!SWIG_IsOK(res1)) {
18115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18116 }
18117 arg1 = reinterpret_cast< wxFileType * >(argp1);
18118 {
18119 PyThreadState* __tstate = wxPyBeginAllowThreads();
18120 result = (PyObject *)wxFileType_GetExtensions(arg1);
18121 wxPyEndAllowThreads(__tstate);
18122 if (PyErr_Occurred()) SWIG_fail;
18123 }
18124 resultobj = result;
18125 return resultobj;
18126 fail:
18127 return NULL;
18128 }
18129
18130
18131 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18132 PyObject *resultobj = 0;
18133 wxFileType *arg1 = (wxFileType *) 0 ;
18134 wxIcon *result = 0 ;
18135 void *argp1 = 0 ;
18136 int res1 = 0 ;
18137 PyObject *swig_obj[1] ;
18138
18139 if (!args) SWIG_fail;
18140 swig_obj[0] = args;
18141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18142 if (!SWIG_IsOK(res1)) {
18143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18144 }
18145 arg1 = reinterpret_cast< wxFileType * >(argp1);
18146 {
18147 PyThreadState* __tstate = wxPyBeginAllowThreads();
18148 result = (wxIcon *)wxFileType_GetIcon(arg1);
18149 wxPyEndAllowThreads(__tstate);
18150 if (PyErr_Occurred()) SWIG_fail;
18151 }
18152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18153 return resultobj;
18154 fail:
18155 return NULL;
18156 }
18157
18158
18159 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18160 PyObject *resultobj = 0;
18161 wxFileType *arg1 = (wxFileType *) 0 ;
18162 PyObject *result = 0 ;
18163 void *argp1 = 0 ;
18164 int res1 = 0 ;
18165 PyObject *swig_obj[1] ;
18166
18167 if (!args) SWIG_fail;
18168 swig_obj[0] = args;
18169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18170 if (!SWIG_IsOK(res1)) {
18171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18172 }
18173 arg1 = reinterpret_cast< wxFileType * >(argp1);
18174 {
18175 PyThreadState* __tstate = wxPyBeginAllowThreads();
18176 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18177 wxPyEndAllowThreads(__tstate);
18178 if (PyErr_Occurred()) SWIG_fail;
18179 }
18180 resultobj = result;
18181 return resultobj;
18182 fail:
18183 return NULL;
18184 }
18185
18186
18187 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18188 PyObject *resultobj = 0;
18189 wxFileType *arg1 = (wxFileType *) 0 ;
18190 PyObject *result = 0 ;
18191 void *argp1 = 0 ;
18192 int res1 = 0 ;
18193 PyObject *swig_obj[1] ;
18194
18195 if (!args) SWIG_fail;
18196 swig_obj[0] = args;
18197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18198 if (!SWIG_IsOK(res1)) {
18199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18200 }
18201 arg1 = reinterpret_cast< wxFileType * >(argp1);
18202 {
18203 PyThreadState* __tstate = wxPyBeginAllowThreads();
18204 result = (PyObject *)wxFileType_GetDescription(arg1);
18205 wxPyEndAllowThreads(__tstate);
18206 if (PyErr_Occurred()) SWIG_fail;
18207 }
18208 resultobj = result;
18209 return resultobj;
18210 fail:
18211 return NULL;
18212 }
18213
18214
18215 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18216 PyObject *resultobj = 0;
18217 wxFileType *arg1 = (wxFileType *) 0 ;
18218 wxString *arg2 = 0 ;
18219 wxString const &arg3_defvalue = wxPyEmptyString ;
18220 wxString *arg3 = (wxString *) &arg3_defvalue ;
18221 PyObject *result = 0 ;
18222 void *argp1 = 0 ;
18223 int res1 = 0 ;
18224 bool temp2 = false ;
18225 bool temp3 = false ;
18226 PyObject * obj0 = 0 ;
18227 PyObject * obj1 = 0 ;
18228 PyObject * obj2 = 0 ;
18229 char * kwnames[] = {
18230 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18231 };
18232
18233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18235 if (!SWIG_IsOK(res1)) {
18236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18237 }
18238 arg1 = reinterpret_cast< wxFileType * >(argp1);
18239 {
18240 arg2 = wxString_in_helper(obj1);
18241 if (arg2 == NULL) SWIG_fail;
18242 temp2 = true;
18243 }
18244 if (obj2) {
18245 {
18246 arg3 = wxString_in_helper(obj2);
18247 if (arg3 == NULL) SWIG_fail;
18248 temp3 = true;
18249 }
18250 }
18251 {
18252 PyThreadState* __tstate = wxPyBeginAllowThreads();
18253 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18254 wxPyEndAllowThreads(__tstate);
18255 if (PyErr_Occurred()) SWIG_fail;
18256 }
18257 resultobj = result;
18258 {
18259 if (temp2)
18260 delete arg2;
18261 }
18262 {
18263 if (temp3)
18264 delete arg3;
18265 }
18266 return resultobj;
18267 fail:
18268 {
18269 if (temp2)
18270 delete arg2;
18271 }
18272 {
18273 if (temp3)
18274 delete arg3;
18275 }
18276 return NULL;
18277 }
18278
18279
18280 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18281 PyObject *resultobj = 0;
18282 wxFileType *arg1 = (wxFileType *) 0 ;
18283 wxString *arg2 = 0 ;
18284 wxString const &arg3_defvalue = wxPyEmptyString ;
18285 wxString *arg3 = (wxString *) &arg3_defvalue ;
18286 PyObject *result = 0 ;
18287 void *argp1 = 0 ;
18288 int res1 = 0 ;
18289 bool temp2 = false ;
18290 bool temp3 = false ;
18291 PyObject * obj0 = 0 ;
18292 PyObject * obj1 = 0 ;
18293 PyObject * obj2 = 0 ;
18294 char * kwnames[] = {
18295 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18296 };
18297
18298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18300 if (!SWIG_IsOK(res1)) {
18301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18302 }
18303 arg1 = reinterpret_cast< wxFileType * >(argp1);
18304 {
18305 arg2 = wxString_in_helper(obj1);
18306 if (arg2 == NULL) SWIG_fail;
18307 temp2 = true;
18308 }
18309 if (obj2) {
18310 {
18311 arg3 = wxString_in_helper(obj2);
18312 if (arg3 == NULL) SWIG_fail;
18313 temp3 = true;
18314 }
18315 }
18316 {
18317 PyThreadState* __tstate = wxPyBeginAllowThreads();
18318 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18319 wxPyEndAllowThreads(__tstate);
18320 if (PyErr_Occurred()) SWIG_fail;
18321 }
18322 resultobj = result;
18323 {
18324 if (temp2)
18325 delete arg2;
18326 }
18327 {
18328 if (temp3)
18329 delete arg3;
18330 }
18331 return resultobj;
18332 fail:
18333 {
18334 if (temp2)
18335 delete arg2;
18336 }
18337 {
18338 if (temp3)
18339 delete arg3;
18340 }
18341 return NULL;
18342 }
18343
18344
18345 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18346 PyObject *resultobj = 0;
18347 wxFileType *arg1 = (wxFileType *) 0 ;
18348 wxString *arg2 = 0 ;
18349 wxString const &arg3_defvalue = wxPyEmptyString ;
18350 wxString *arg3 = (wxString *) &arg3_defvalue ;
18351 PyObject *result = 0 ;
18352 void *argp1 = 0 ;
18353 int res1 = 0 ;
18354 bool temp2 = false ;
18355 bool temp3 = false ;
18356 PyObject * obj0 = 0 ;
18357 PyObject * obj1 = 0 ;
18358 PyObject * obj2 = 0 ;
18359 char * kwnames[] = {
18360 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18361 };
18362
18363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18365 if (!SWIG_IsOK(res1)) {
18366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18367 }
18368 arg1 = reinterpret_cast< wxFileType * >(argp1);
18369 {
18370 arg2 = wxString_in_helper(obj1);
18371 if (arg2 == NULL) SWIG_fail;
18372 temp2 = true;
18373 }
18374 if (obj2) {
18375 {
18376 arg3 = wxString_in_helper(obj2);
18377 if (arg3 == NULL) SWIG_fail;
18378 temp3 = true;
18379 }
18380 }
18381 {
18382 PyThreadState* __tstate = wxPyBeginAllowThreads();
18383 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18384 wxPyEndAllowThreads(__tstate);
18385 if (PyErr_Occurred()) SWIG_fail;
18386 }
18387 resultobj = result;
18388 {
18389 if (temp2)
18390 delete arg2;
18391 }
18392 {
18393 if (temp3)
18394 delete arg3;
18395 }
18396 return resultobj;
18397 fail:
18398 {
18399 if (temp2)
18400 delete arg2;
18401 }
18402 {
18403 if (temp3)
18404 delete arg3;
18405 }
18406 return NULL;
18407 }
18408
18409
18410 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18411 PyObject *resultobj = 0;
18412 wxFileType *arg1 = (wxFileType *) 0 ;
18413 wxString *arg2 = 0 ;
18414 wxString *arg3 = 0 ;
18415 bool arg4 = (bool) true ;
18416 bool result;
18417 void *argp1 = 0 ;
18418 int res1 = 0 ;
18419 bool temp2 = false ;
18420 bool temp3 = false ;
18421 bool val4 ;
18422 int ecode4 = 0 ;
18423 PyObject * obj0 = 0 ;
18424 PyObject * obj1 = 0 ;
18425 PyObject * obj2 = 0 ;
18426 PyObject * obj3 = 0 ;
18427 char * kwnames[] = {
18428 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18429 };
18430
18431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18433 if (!SWIG_IsOK(res1)) {
18434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18435 }
18436 arg1 = reinterpret_cast< wxFileType * >(argp1);
18437 {
18438 arg2 = wxString_in_helper(obj1);
18439 if (arg2 == NULL) SWIG_fail;
18440 temp2 = true;
18441 }
18442 {
18443 arg3 = wxString_in_helper(obj2);
18444 if (arg3 == NULL) SWIG_fail;
18445 temp3 = true;
18446 }
18447 if (obj3) {
18448 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18449 if (!SWIG_IsOK(ecode4)) {
18450 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18451 }
18452 arg4 = static_cast< bool >(val4);
18453 }
18454 {
18455 PyThreadState* __tstate = wxPyBeginAllowThreads();
18456 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18457 wxPyEndAllowThreads(__tstate);
18458 if (PyErr_Occurred()) SWIG_fail;
18459 }
18460 {
18461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18462 }
18463 {
18464 if (temp2)
18465 delete arg2;
18466 }
18467 {
18468 if (temp3)
18469 delete arg3;
18470 }
18471 return resultobj;
18472 fail:
18473 {
18474 if (temp2)
18475 delete arg2;
18476 }
18477 {
18478 if (temp3)
18479 delete arg3;
18480 }
18481 return NULL;
18482 }
18483
18484
18485 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18486 PyObject *resultobj = 0;
18487 wxFileType *arg1 = (wxFileType *) 0 ;
18488 wxString const &arg2_defvalue = wxPyEmptyString ;
18489 wxString *arg2 = (wxString *) &arg2_defvalue ;
18490 int arg3 = (int) 0 ;
18491 bool result;
18492 void *argp1 = 0 ;
18493 int res1 = 0 ;
18494 bool temp2 = false ;
18495 int val3 ;
18496 int ecode3 = 0 ;
18497 PyObject * obj0 = 0 ;
18498 PyObject * obj1 = 0 ;
18499 PyObject * obj2 = 0 ;
18500 char * kwnames[] = {
18501 (char *) "self",(char *) "cmd",(char *) "index", NULL
18502 };
18503
18504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18506 if (!SWIG_IsOK(res1)) {
18507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18508 }
18509 arg1 = reinterpret_cast< wxFileType * >(argp1);
18510 if (obj1) {
18511 {
18512 arg2 = wxString_in_helper(obj1);
18513 if (arg2 == NULL) SWIG_fail;
18514 temp2 = true;
18515 }
18516 }
18517 if (obj2) {
18518 ecode3 = SWIG_AsVal_int(obj2, &val3);
18519 if (!SWIG_IsOK(ecode3)) {
18520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18521 }
18522 arg3 = static_cast< int >(val3);
18523 }
18524 {
18525 PyThreadState* __tstate = wxPyBeginAllowThreads();
18526 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18527 wxPyEndAllowThreads(__tstate);
18528 if (PyErr_Occurred()) SWIG_fail;
18529 }
18530 {
18531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18532 }
18533 {
18534 if (temp2)
18535 delete arg2;
18536 }
18537 return resultobj;
18538 fail:
18539 {
18540 if (temp2)
18541 delete arg2;
18542 }
18543 return NULL;
18544 }
18545
18546
18547 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18548 PyObject *resultobj = 0;
18549 wxFileType *arg1 = (wxFileType *) 0 ;
18550 bool result;
18551 void *argp1 = 0 ;
18552 int res1 = 0 ;
18553 PyObject *swig_obj[1] ;
18554
18555 if (!args) SWIG_fail;
18556 swig_obj[0] = args;
18557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18558 if (!SWIG_IsOK(res1)) {
18559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18560 }
18561 arg1 = reinterpret_cast< wxFileType * >(argp1);
18562 {
18563 PyThreadState* __tstate = wxPyBeginAllowThreads();
18564 result = (bool)(arg1)->Unassociate();
18565 wxPyEndAllowThreads(__tstate);
18566 if (PyErr_Occurred()) SWIG_fail;
18567 }
18568 {
18569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18570 }
18571 return resultobj;
18572 fail:
18573 return NULL;
18574 }
18575
18576
18577 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18578 PyObject *resultobj = 0;
18579 wxString *arg1 = 0 ;
18580 wxString *arg2 = 0 ;
18581 wxString const &arg3_defvalue = wxPyEmptyString ;
18582 wxString *arg3 = (wxString *) &arg3_defvalue ;
18583 wxString result;
18584 bool temp1 = false ;
18585 bool temp2 = false ;
18586 bool temp3 = false ;
18587 PyObject * obj0 = 0 ;
18588 PyObject * obj1 = 0 ;
18589 PyObject * obj2 = 0 ;
18590 char * kwnames[] = {
18591 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18592 };
18593
18594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18595 {
18596 arg1 = wxString_in_helper(obj0);
18597 if (arg1 == NULL) SWIG_fail;
18598 temp1 = true;
18599 }
18600 {
18601 arg2 = wxString_in_helper(obj1);
18602 if (arg2 == NULL) SWIG_fail;
18603 temp2 = true;
18604 }
18605 if (obj2) {
18606 {
18607 arg3 = wxString_in_helper(obj2);
18608 if (arg3 == NULL) SWIG_fail;
18609 temp3 = true;
18610 }
18611 }
18612 {
18613 PyThreadState* __tstate = wxPyBeginAllowThreads();
18614 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18615 wxPyEndAllowThreads(__tstate);
18616 if (PyErr_Occurred()) SWIG_fail;
18617 }
18618 {
18619 #if wxUSE_UNICODE
18620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18621 #else
18622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18623 #endif
18624 }
18625 {
18626 if (temp1)
18627 delete arg1;
18628 }
18629 {
18630 if (temp2)
18631 delete arg2;
18632 }
18633 {
18634 if (temp3)
18635 delete arg3;
18636 }
18637 return resultobj;
18638 fail:
18639 {
18640 if (temp1)
18641 delete arg1;
18642 }
18643 {
18644 if (temp2)
18645 delete arg2;
18646 }
18647 {
18648 if (temp3)
18649 delete arg3;
18650 }
18651 return NULL;
18652 }
18653
18654
18655 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18656 PyObject *obj;
18657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18658 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18659 return SWIG_Py_Void();
18660 }
18661
18662 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18663 return SWIG_Python_InitShadowInstance(args);
18664 }
18665
18666 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18667 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18668 return 1;
18669 }
18670
18671
18672 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18673 PyObject *pyobj = 0;
18674
18675 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18676 return pyobj;
18677 }
18678
18679
18680 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18681 PyObject *resultobj = 0;
18682 wxString *arg1 = 0 ;
18683 wxString *arg2 = 0 ;
18684 bool result;
18685 bool temp1 = false ;
18686 bool temp2 = false ;
18687 PyObject * obj0 = 0 ;
18688 PyObject * obj1 = 0 ;
18689 char * kwnames[] = {
18690 (char *) "mimeType",(char *) "wildcard", NULL
18691 };
18692
18693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18694 {
18695 arg1 = wxString_in_helper(obj0);
18696 if (arg1 == NULL) SWIG_fail;
18697 temp1 = true;
18698 }
18699 {
18700 arg2 = wxString_in_helper(obj1);
18701 if (arg2 == NULL) SWIG_fail;
18702 temp2 = true;
18703 }
18704 {
18705 PyThreadState* __tstate = wxPyBeginAllowThreads();
18706 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18707 wxPyEndAllowThreads(__tstate);
18708 if (PyErr_Occurred()) SWIG_fail;
18709 }
18710 {
18711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18712 }
18713 {
18714 if (temp1)
18715 delete arg1;
18716 }
18717 {
18718 if (temp2)
18719 delete arg2;
18720 }
18721 return resultobj;
18722 fail:
18723 {
18724 if (temp1)
18725 delete arg1;
18726 }
18727 {
18728 if (temp2)
18729 delete arg2;
18730 }
18731 return NULL;
18732 }
18733
18734
18735 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18736 PyObject *resultobj = 0;
18737 wxMimeTypesManager *result = 0 ;
18738
18739 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18740 {
18741 PyThreadState* __tstate = wxPyBeginAllowThreads();
18742 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18743 wxPyEndAllowThreads(__tstate);
18744 if (PyErr_Occurred()) SWIG_fail;
18745 }
18746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18747 return resultobj;
18748 fail:
18749 return NULL;
18750 }
18751
18752
18753 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18754 PyObject *resultobj = 0;
18755 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18756 int arg2 = (int) wxMAILCAP_ALL ;
18757 wxString const &arg3_defvalue = wxPyEmptyString ;
18758 wxString *arg3 = (wxString *) &arg3_defvalue ;
18759 void *argp1 = 0 ;
18760 int res1 = 0 ;
18761 int val2 ;
18762 int ecode2 = 0 ;
18763 bool temp3 = false ;
18764 PyObject * obj0 = 0 ;
18765 PyObject * obj1 = 0 ;
18766 PyObject * obj2 = 0 ;
18767 char * kwnames[] = {
18768 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18769 };
18770
18771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18773 if (!SWIG_IsOK(res1)) {
18774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18775 }
18776 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18777 if (obj1) {
18778 ecode2 = SWIG_AsVal_int(obj1, &val2);
18779 if (!SWIG_IsOK(ecode2)) {
18780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18781 }
18782 arg2 = static_cast< int >(val2);
18783 }
18784 if (obj2) {
18785 {
18786 arg3 = wxString_in_helper(obj2);
18787 if (arg3 == NULL) SWIG_fail;
18788 temp3 = true;
18789 }
18790 }
18791 {
18792 PyThreadState* __tstate = wxPyBeginAllowThreads();
18793 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18794 wxPyEndAllowThreads(__tstate);
18795 if (PyErr_Occurred()) SWIG_fail;
18796 }
18797 resultobj = SWIG_Py_Void();
18798 {
18799 if (temp3)
18800 delete arg3;
18801 }
18802 return resultobj;
18803 fail:
18804 {
18805 if (temp3)
18806 delete arg3;
18807 }
18808 return NULL;
18809 }
18810
18811
18812 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18813 PyObject *resultobj = 0;
18814 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18815 void *argp1 = 0 ;
18816 int res1 = 0 ;
18817 PyObject *swig_obj[1] ;
18818
18819 if (!args) SWIG_fail;
18820 swig_obj[0] = args;
18821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18822 if (!SWIG_IsOK(res1)) {
18823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18824 }
18825 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18826 {
18827 PyThreadState* __tstate = wxPyBeginAllowThreads();
18828 (arg1)->ClearData();
18829 wxPyEndAllowThreads(__tstate);
18830 if (PyErr_Occurred()) SWIG_fail;
18831 }
18832 resultobj = SWIG_Py_Void();
18833 return resultobj;
18834 fail:
18835 return NULL;
18836 }
18837
18838
18839 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18840 PyObject *resultobj = 0;
18841 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18842 wxString *arg2 = 0 ;
18843 wxFileType *result = 0 ;
18844 void *argp1 = 0 ;
18845 int res1 = 0 ;
18846 bool temp2 = false ;
18847 PyObject * obj0 = 0 ;
18848 PyObject * obj1 = 0 ;
18849 char * kwnames[] = {
18850 (char *) "self",(char *) "ext", NULL
18851 };
18852
18853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18855 if (!SWIG_IsOK(res1)) {
18856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18857 }
18858 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18859 {
18860 arg2 = wxString_in_helper(obj1);
18861 if (arg2 == NULL) SWIG_fail;
18862 temp2 = true;
18863 }
18864 {
18865 PyThreadState* __tstate = wxPyBeginAllowThreads();
18866 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18867 wxPyEndAllowThreads(__tstate);
18868 if (PyErr_Occurred()) SWIG_fail;
18869 }
18870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18871 {
18872 if (temp2)
18873 delete arg2;
18874 }
18875 return resultobj;
18876 fail:
18877 {
18878 if (temp2)
18879 delete arg2;
18880 }
18881 return NULL;
18882 }
18883
18884
18885 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18886 PyObject *resultobj = 0;
18887 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18888 wxString *arg2 = 0 ;
18889 wxFileType *result = 0 ;
18890 void *argp1 = 0 ;
18891 int res1 = 0 ;
18892 bool temp2 = false ;
18893 PyObject * obj0 = 0 ;
18894 PyObject * obj1 = 0 ;
18895 char * kwnames[] = {
18896 (char *) "self",(char *) "mimeType", NULL
18897 };
18898
18899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18901 if (!SWIG_IsOK(res1)) {
18902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18903 }
18904 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18905 {
18906 arg2 = wxString_in_helper(obj1);
18907 if (arg2 == NULL) SWIG_fail;
18908 temp2 = true;
18909 }
18910 {
18911 PyThreadState* __tstate = wxPyBeginAllowThreads();
18912 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
18913 wxPyEndAllowThreads(__tstate);
18914 if (PyErr_Occurred()) SWIG_fail;
18915 }
18916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18917 {
18918 if (temp2)
18919 delete arg2;
18920 }
18921 return resultobj;
18922 fail:
18923 {
18924 if (temp2)
18925 delete arg2;
18926 }
18927 return NULL;
18928 }
18929
18930
18931 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18932 PyObject *resultobj = 0;
18933 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18934 wxString *arg2 = 0 ;
18935 bool arg3 = (bool) false ;
18936 bool result;
18937 void *argp1 = 0 ;
18938 int res1 = 0 ;
18939 bool temp2 = false ;
18940 bool val3 ;
18941 int ecode3 = 0 ;
18942 PyObject * obj0 = 0 ;
18943 PyObject * obj1 = 0 ;
18944 PyObject * obj2 = 0 ;
18945 char * kwnames[] = {
18946 (char *) "self",(char *) "filename",(char *) "fallback", NULL
18947 };
18948
18949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18951 if (!SWIG_IsOK(res1)) {
18952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18953 }
18954 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18955 {
18956 arg2 = wxString_in_helper(obj1);
18957 if (arg2 == NULL) SWIG_fail;
18958 temp2 = true;
18959 }
18960 if (obj2) {
18961 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18962 if (!SWIG_IsOK(ecode3)) {
18963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
18964 }
18965 arg3 = static_cast< bool >(val3);
18966 }
18967 {
18968 PyThreadState* __tstate = wxPyBeginAllowThreads();
18969 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
18970 wxPyEndAllowThreads(__tstate);
18971 if (PyErr_Occurred()) SWIG_fail;
18972 }
18973 {
18974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18975 }
18976 {
18977 if (temp2)
18978 delete arg2;
18979 }
18980 return resultobj;
18981 fail:
18982 {
18983 if (temp2)
18984 delete arg2;
18985 }
18986 return NULL;
18987 }
18988
18989
18990 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18991 PyObject *resultobj = 0;
18992 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18993 wxString *arg2 = 0 ;
18994 bool result;
18995 void *argp1 = 0 ;
18996 int res1 = 0 ;
18997 bool temp2 = false ;
18998 PyObject * obj0 = 0 ;
18999 PyObject * obj1 = 0 ;
19000 char * kwnames[] = {
19001 (char *) "self",(char *) "filename", NULL
19002 };
19003
19004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19006 if (!SWIG_IsOK(res1)) {
19007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19008 }
19009 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19010 {
19011 arg2 = wxString_in_helper(obj1);
19012 if (arg2 == NULL) SWIG_fail;
19013 temp2 = true;
19014 }
19015 {
19016 PyThreadState* __tstate = wxPyBeginAllowThreads();
19017 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19018 wxPyEndAllowThreads(__tstate);
19019 if (PyErr_Occurred()) SWIG_fail;
19020 }
19021 {
19022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19023 }
19024 {
19025 if (temp2)
19026 delete arg2;
19027 }
19028 return resultobj;
19029 fail:
19030 {
19031 if (temp2)
19032 delete arg2;
19033 }
19034 return NULL;
19035 }
19036
19037
19038 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19039 PyObject *resultobj = 0;
19040 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19041 PyObject *result = 0 ;
19042 void *argp1 = 0 ;
19043 int res1 = 0 ;
19044 PyObject *swig_obj[1] ;
19045
19046 if (!args) SWIG_fail;
19047 swig_obj[0] = args;
19048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19049 if (!SWIG_IsOK(res1)) {
19050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19051 }
19052 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19053 {
19054 PyThreadState* __tstate = wxPyBeginAllowThreads();
19055 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19056 wxPyEndAllowThreads(__tstate);
19057 if (PyErr_Occurred()) SWIG_fail;
19058 }
19059 resultobj = result;
19060 return resultobj;
19061 fail:
19062 return NULL;
19063 }
19064
19065
19066 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19067 PyObject *resultobj = 0;
19068 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19069 wxFileTypeInfo *arg2 = 0 ;
19070 void *argp1 = 0 ;
19071 int res1 = 0 ;
19072 void *argp2 = 0 ;
19073 int res2 = 0 ;
19074 PyObject * obj0 = 0 ;
19075 PyObject * obj1 = 0 ;
19076 char * kwnames[] = {
19077 (char *) "self",(char *) "ft", NULL
19078 };
19079
19080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19082 if (!SWIG_IsOK(res1)) {
19083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19084 }
19085 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19086 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19087 if (!SWIG_IsOK(res2)) {
19088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19089 }
19090 if (!argp2) {
19091 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19092 }
19093 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19094 {
19095 PyThreadState* __tstate = wxPyBeginAllowThreads();
19096 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19097 wxPyEndAllowThreads(__tstate);
19098 if (PyErr_Occurred()) SWIG_fail;
19099 }
19100 resultobj = SWIG_Py_Void();
19101 return resultobj;
19102 fail:
19103 return NULL;
19104 }
19105
19106
19107 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19108 PyObject *resultobj = 0;
19109 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19110 wxFileTypeInfo *arg2 = 0 ;
19111 wxFileType *result = 0 ;
19112 void *argp1 = 0 ;
19113 int res1 = 0 ;
19114 void *argp2 = 0 ;
19115 int res2 = 0 ;
19116 PyObject * obj0 = 0 ;
19117 PyObject * obj1 = 0 ;
19118 char * kwnames[] = {
19119 (char *) "self",(char *) "ftInfo", NULL
19120 };
19121
19122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19124 if (!SWIG_IsOK(res1)) {
19125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19126 }
19127 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19128 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19129 if (!SWIG_IsOK(res2)) {
19130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19131 }
19132 if (!argp2) {
19133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19134 }
19135 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19136 {
19137 PyThreadState* __tstate = wxPyBeginAllowThreads();
19138 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19139 wxPyEndAllowThreads(__tstate);
19140 if (PyErr_Occurred()) SWIG_fail;
19141 }
19142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19143 return resultobj;
19144 fail:
19145 return NULL;
19146 }
19147
19148
19149 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19150 PyObject *resultobj = 0;
19151 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19152 wxFileType *arg2 = (wxFileType *) 0 ;
19153 bool result;
19154 void *argp1 = 0 ;
19155 int res1 = 0 ;
19156 void *argp2 = 0 ;
19157 int res2 = 0 ;
19158 PyObject * obj0 = 0 ;
19159 PyObject * obj1 = 0 ;
19160 char * kwnames[] = {
19161 (char *) "self",(char *) "ft", NULL
19162 };
19163
19164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19166 if (!SWIG_IsOK(res1)) {
19167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19168 }
19169 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19170 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19171 if (!SWIG_IsOK(res2)) {
19172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19173 }
19174 arg2 = reinterpret_cast< wxFileType * >(argp2);
19175 {
19176 PyThreadState* __tstate = wxPyBeginAllowThreads();
19177 result = (bool)(arg1)->Unassociate(arg2);
19178 wxPyEndAllowThreads(__tstate);
19179 if (PyErr_Occurred()) SWIG_fail;
19180 }
19181 {
19182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19183 }
19184 return resultobj;
19185 fail:
19186 return NULL;
19187 }
19188
19189
19190 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19191 PyObject *resultobj = 0;
19192 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19193 void *argp1 = 0 ;
19194 int res1 = 0 ;
19195 PyObject *swig_obj[1] ;
19196
19197 if (!args) SWIG_fail;
19198 swig_obj[0] = args;
19199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19200 if (!SWIG_IsOK(res1)) {
19201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19202 }
19203 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19204 {
19205 PyThreadState* __tstate = wxPyBeginAllowThreads();
19206 delete arg1;
19207
19208 wxPyEndAllowThreads(__tstate);
19209 if (PyErr_Occurred()) SWIG_fail;
19210 }
19211 resultobj = SWIG_Py_Void();
19212 return resultobj;
19213 fail:
19214 return NULL;
19215 }
19216
19217
19218 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19219 PyObject *obj;
19220 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19221 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19222 return SWIG_Py_Void();
19223 }
19224
19225 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19226 return SWIG_Python_InitShadowInstance(args);
19227 }
19228
19229 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19230 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19231 return 1;
19232 }
19233
19234
19235 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19236 PyObject *pyobj = 0;
19237
19238 {
19239 #if wxUSE_UNICODE
19240 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19241 #else
19242 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19243 #endif
19244 }
19245 return pyobj;
19246 }
19247
19248
19249 SWIGINTERN int ART_MENU_set(PyObject *) {
19250 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19251 return 1;
19252 }
19253
19254
19255 SWIGINTERN PyObject *ART_MENU_get(void) {
19256 PyObject *pyobj = 0;
19257
19258 {
19259 #if wxUSE_UNICODE
19260 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19261 #else
19262 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19263 #endif
19264 }
19265 return pyobj;
19266 }
19267
19268
19269 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19270 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19271 return 1;
19272 }
19273
19274
19275 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19276 PyObject *pyobj = 0;
19277
19278 {
19279 #if wxUSE_UNICODE
19280 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19281 #else
19282 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19283 #endif
19284 }
19285 return pyobj;
19286 }
19287
19288
19289 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19290 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19291 return 1;
19292 }
19293
19294
19295 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19296 PyObject *pyobj = 0;
19297
19298 {
19299 #if wxUSE_UNICODE
19300 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19301 #else
19302 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19303 #endif
19304 }
19305 return pyobj;
19306 }
19307
19308
19309 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19310 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19311 return 1;
19312 }
19313
19314
19315 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19316 PyObject *pyobj = 0;
19317
19318 {
19319 #if wxUSE_UNICODE
19320 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19321 #else
19322 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19323 #endif
19324 }
19325 return pyobj;
19326 }
19327
19328
19329 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19330 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19331 return 1;
19332 }
19333
19334
19335 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19336 PyObject *pyobj = 0;
19337
19338 {
19339 #if wxUSE_UNICODE
19340 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19341 #else
19342 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19343 #endif
19344 }
19345 return pyobj;
19346 }
19347
19348
19349 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19350 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19351 return 1;
19352 }
19353
19354
19355 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19356 PyObject *pyobj = 0;
19357
19358 {
19359 #if wxUSE_UNICODE
19360 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19361 #else
19362 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19363 #endif
19364 }
19365 return pyobj;
19366 }
19367
19368
19369 SWIGINTERN int ART_OTHER_set(PyObject *) {
19370 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19371 return 1;
19372 }
19373
19374
19375 SWIGINTERN PyObject *ART_OTHER_get(void) {
19376 PyObject *pyobj = 0;
19377
19378 {
19379 #if wxUSE_UNICODE
19380 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19381 #else
19382 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19383 #endif
19384 }
19385 return pyobj;
19386 }
19387
19388
19389 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19390 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19391 return 1;
19392 }
19393
19394
19395 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19396 PyObject *pyobj = 0;
19397
19398 {
19399 #if wxUSE_UNICODE
19400 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19401 #else
19402 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19403 #endif
19404 }
19405 return pyobj;
19406 }
19407
19408
19409 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19410 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19411 return 1;
19412 }
19413
19414
19415 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19416 PyObject *pyobj = 0;
19417
19418 {
19419 #if wxUSE_UNICODE
19420 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19421 #else
19422 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19423 #endif
19424 }
19425 return pyobj;
19426 }
19427
19428
19429 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19430 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19431 return 1;
19432 }
19433
19434
19435 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19436 PyObject *pyobj = 0;
19437
19438 {
19439 #if wxUSE_UNICODE
19440 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19441 #else
19442 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19443 #endif
19444 }
19445 return pyobj;
19446 }
19447
19448
19449 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19450 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19451 return 1;
19452 }
19453
19454
19455 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19456 PyObject *pyobj = 0;
19457
19458 {
19459 #if wxUSE_UNICODE
19460 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19461 #else
19462 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19463 #endif
19464 }
19465 return pyobj;
19466 }
19467
19468
19469 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19470 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19471 return 1;
19472 }
19473
19474
19475 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19476 PyObject *pyobj = 0;
19477
19478 {
19479 #if wxUSE_UNICODE
19480 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19481 #else
19482 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19483 #endif
19484 }
19485 return pyobj;
19486 }
19487
19488
19489 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19490 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19491 return 1;
19492 }
19493
19494
19495 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19496 PyObject *pyobj = 0;
19497
19498 {
19499 #if wxUSE_UNICODE
19500 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19501 #else
19502 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19503 #endif
19504 }
19505 return pyobj;
19506 }
19507
19508
19509 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19510 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19511 return 1;
19512 }
19513
19514
19515 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19516 PyObject *pyobj = 0;
19517
19518 {
19519 #if wxUSE_UNICODE
19520 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19521 #else
19522 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19523 #endif
19524 }
19525 return pyobj;
19526 }
19527
19528
19529 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19530 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19531 return 1;
19532 }
19533
19534
19535 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19536 PyObject *pyobj = 0;
19537
19538 {
19539 #if wxUSE_UNICODE
19540 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19541 #else
19542 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19543 #endif
19544 }
19545 return pyobj;
19546 }
19547
19548
19549 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19550 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19551 return 1;
19552 }
19553
19554
19555 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19556 PyObject *pyobj = 0;
19557
19558 {
19559 #if wxUSE_UNICODE
19560 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19561 #else
19562 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19563 #endif
19564 }
19565 return pyobj;
19566 }
19567
19568
19569 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19570 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19571 return 1;
19572 }
19573
19574
19575 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19576 PyObject *pyobj = 0;
19577
19578 {
19579 #if wxUSE_UNICODE
19580 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19581 #else
19582 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19583 #endif
19584 }
19585 return pyobj;
19586 }
19587
19588
19589 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19590 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19591 return 1;
19592 }
19593
19594
19595 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19596 PyObject *pyobj = 0;
19597
19598 {
19599 #if wxUSE_UNICODE
19600 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19601 #else
19602 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19603 #endif
19604 }
19605 return pyobj;
19606 }
19607
19608
19609 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19610 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19611 return 1;
19612 }
19613
19614
19615 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19616 PyObject *pyobj = 0;
19617
19618 {
19619 #if wxUSE_UNICODE
19620 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19621 #else
19622 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19623 #endif
19624 }
19625 return pyobj;
19626 }
19627
19628
19629 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19630 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19631 return 1;
19632 }
19633
19634
19635 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19636 PyObject *pyobj = 0;
19637
19638 {
19639 #if wxUSE_UNICODE
19640 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19641 #else
19642 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19643 #endif
19644 }
19645 return pyobj;
19646 }
19647
19648
19649 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19650 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19651 return 1;
19652 }
19653
19654
19655 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19656 PyObject *pyobj = 0;
19657
19658 {
19659 #if wxUSE_UNICODE
19660 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19661 #else
19662 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19663 #endif
19664 }
19665 return pyobj;
19666 }
19667
19668
19669 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19670 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19671 return 1;
19672 }
19673
19674
19675 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19676 PyObject *pyobj = 0;
19677
19678 {
19679 #if wxUSE_UNICODE
19680 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19681 #else
19682 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19683 #endif
19684 }
19685 return pyobj;
19686 }
19687
19688
19689 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19690 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19691 return 1;
19692 }
19693
19694
19695 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19696 PyObject *pyobj = 0;
19697
19698 {
19699 #if wxUSE_UNICODE
19700 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19701 #else
19702 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19703 #endif
19704 }
19705 return pyobj;
19706 }
19707
19708
19709 SWIGINTERN int ART_PRINT_set(PyObject *) {
19710 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19711 return 1;
19712 }
19713
19714
19715 SWIGINTERN PyObject *ART_PRINT_get(void) {
19716 PyObject *pyobj = 0;
19717
19718 {
19719 #if wxUSE_UNICODE
19720 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19721 #else
19722 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19723 #endif
19724 }
19725 return pyobj;
19726 }
19727
19728
19729 SWIGINTERN int ART_HELP_set(PyObject *) {
19730 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19731 return 1;
19732 }
19733
19734
19735 SWIGINTERN PyObject *ART_HELP_get(void) {
19736 PyObject *pyobj = 0;
19737
19738 {
19739 #if wxUSE_UNICODE
19740 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19741 #else
19742 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19743 #endif
19744 }
19745 return pyobj;
19746 }
19747
19748
19749 SWIGINTERN int ART_TIP_set(PyObject *) {
19750 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19751 return 1;
19752 }
19753
19754
19755 SWIGINTERN PyObject *ART_TIP_get(void) {
19756 PyObject *pyobj = 0;
19757
19758 {
19759 #if wxUSE_UNICODE
19760 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19761 #else
19762 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19763 #endif
19764 }
19765 return pyobj;
19766 }
19767
19768
19769 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19770 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19771 return 1;
19772 }
19773
19774
19775 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19776 PyObject *pyobj = 0;
19777
19778 {
19779 #if wxUSE_UNICODE
19780 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19781 #else
19782 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19783 #endif
19784 }
19785 return pyobj;
19786 }
19787
19788
19789 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19790 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19791 return 1;
19792 }
19793
19794
19795 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19796 PyObject *pyobj = 0;
19797
19798 {
19799 #if wxUSE_UNICODE
19800 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19801 #else
19802 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19803 #endif
19804 }
19805 return pyobj;
19806 }
19807
19808
19809 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19810 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19811 return 1;
19812 }
19813
19814
19815 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19816 PyObject *pyobj = 0;
19817
19818 {
19819 #if wxUSE_UNICODE
19820 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19821 #else
19822 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19823 #endif
19824 }
19825 return pyobj;
19826 }
19827
19828
19829 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19830 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19831 return 1;
19832 }
19833
19834
19835 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19836 PyObject *pyobj = 0;
19837
19838 {
19839 #if wxUSE_UNICODE
19840 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19841 #else
19842 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19843 #endif
19844 }
19845 return pyobj;
19846 }
19847
19848
19849 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19850 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19851 return 1;
19852 }
19853
19854
19855 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19856 PyObject *pyobj = 0;
19857
19858 {
19859 #if wxUSE_UNICODE
19860 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19861 #else
19862 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19863 #endif
19864 }
19865 return pyobj;
19866 }
19867
19868
19869 SWIGINTERN int ART_CDROM_set(PyObject *) {
19870 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19871 return 1;
19872 }
19873
19874
19875 SWIGINTERN PyObject *ART_CDROM_get(void) {
19876 PyObject *pyobj = 0;
19877
19878 {
19879 #if wxUSE_UNICODE
19880 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19881 #else
19882 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19883 #endif
19884 }
19885 return pyobj;
19886 }
19887
19888
19889 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19890 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19891 return 1;
19892 }
19893
19894
19895 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19896 PyObject *pyobj = 0;
19897
19898 {
19899 #if wxUSE_UNICODE
19900 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19901 #else
19902 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19903 #endif
19904 }
19905 return pyobj;
19906 }
19907
19908
19909 SWIGINTERN int ART_FOLDER_set(PyObject *) {
19910 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
19911 return 1;
19912 }
19913
19914
19915 SWIGINTERN PyObject *ART_FOLDER_get(void) {
19916 PyObject *pyobj = 0;
19917
19918 {
19919 #if wxUSE_UNICODE
19920 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19921 #else
19922 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19923 #endif
19924 }
19925 return pyobj;
19926 }
19927
19928
19929 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
19930 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
19931 return 1;
19932 }
19933
19934
19935 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
19936 PyObject *pyobj = 0;
19937
19938 {
19939 #if wxUSE_UNICODE
19940 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19941 #else
19942 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19943 #endif
19944 }
19945 return pyobj;
19946 }
19947
19948
19949 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
19950 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
19951 return 1;
19952 }
19953
19954
19955 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
19956 PyObject *pyobj = 0;
19957
19958 {
19959 #if wxUSE_UNICODE
19960 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19961 #else
19962 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19963 #endif
19964 }
19965 return pyobj;
19966 }
19967
19968
19969 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
19970 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
19971 return 1;
19972 }
19973
19974
19975 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
19976 PyObject *pyobj = 0;
19977
19978 {
19979 #if wxUSE_UNICODE
19980 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19981 #else
19982 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19983 #endif
19984 }
19985 return pyobj;
19986 }
19987
19988
19989 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
19990 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
19991 return 1;
19992 }
19993
19994
19995 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
19996 PyObject *pyobj = 0;
19997
19998 {
19999 #if wxUSE_UNICODE
20000 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20001 #else
20002 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20003 #endif
20004 }
20005 return pyobj;
20006 }
20007
20008
20009 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20010 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20011 return 1;
20012 }
20013
20014
20015 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20016 PyObject *pyobj = 0;
20017
20018 {
20019 #if wxUSE_UNICODE
20020 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20021 #else
20022 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20023 #endif
20024 }
20025 return pyobj;
20026 }
20027
20028
20029 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20030 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20031 return 1;
20032 }
20033
20034
20035 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20036 PyObject *pyobj = 0;
20037
20038 {
20039 #if wxUSE_UNICODE
20040 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20041 #else
20042 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20043 #endif
20044 }
20045 return pyobj;
20046 }
20047
20048
20049 SWIGINTERN int ART_ERROR_set(PyObject *) {
20050 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20051 return 1;
20052 }
20053
20054
20055 SWIGINTERN PyObject *ART_ERROR_get(void) {
20056 PyObject *pyobj = 0;
20057
20058 {
20059 #if wxUSE_UNICODE
20060 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20061 #else
20062 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20063 #endif
20064 }
20065 return pyobj;
20066 }
20067
20068
20069 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20070 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20071 return 1;
20072 }
20073
20074
20075 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20076 PyObject *pyobj = 0;
20077
20078 {
20079 #if wxUSE_UNICODE
20080 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20081 #else
20082 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20083 #endif
20084 }
20085 return pyobj;
20086 }
20087
20088
20089 SWIGINTERN int ART_WARNING_set(PyObject *) {
20090 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20091 return 1;
20092 }
20093
20094
20095 SWIGINTERN PyObject *ART_WARNING_get(void) {
20096 PyObject *pyobj = 0;
20097
20098 {
20099 #if wxUSE_UNICODE
20100 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20101 #else
20102 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20103 #endif
20104 }
20105 return pyobj;
20106 }
20107
20108
20109 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20110 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20111 return 1;
20112 }
20113
20114
20115 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20116 PyObject *pyobj = 0;
20117
20118 {
20119 #if wxUSE_UNICODE
20120 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20121 #else
20122 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20123 #endif
20124 }
20125 return pyobj;
20126 }
20127
20128
20129 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20130 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20131 return 1;
20132 }
20133
20134
20135 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20136 PyObject *pyobj = 0;
20137
20138 {
20139 #if wxUSE_UNICODE
20140 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20141 #else
20142 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20143 #endif
20144 }
20145 return pyobj;
20146 }
20147
20148
20149 SWIGINTERN int ART_COPY_set(PyObject *) {
20150 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20151 return 1;
20152 }
20153
20154
20155 SWIGINTERN PyObject *ART_COPY_get(void) {
20156 PyObject *pyobj = 0;
20157
20158 {
20159 #if wxUSE_UNICODE
20160 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20161 #else
20162 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20163 #endif
20164 }
20165 return pyobj;
20166 }
20167
20168
20169 SWIGINTERN int ART_CUT_set(PyObject *) {
20170 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20171 return 1;
20172 }
20173
20174
20175 SWIGINTERN PyObject *ART_CUT_get(void) {
20176 PyObject *pyobj = 0;
20177
20178 {
20179 #if wxUSE_UNICODE
20180 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20181 #else
20182 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20183 #endif
20184 }
20185 return pyobj;
20186 }
20187
20188
20189 SWIGINTERN int ART_PASTE_set(PyObject *) {
20190 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20191 return 1;
20192 }
20193
20194
20195 SWIGINTERN PyObject *ART_PASTE_get(void) {
20196 PyObject *pyobj = 0;
20197
20198 {
20199 #if wxUSE_UNICODE
20200 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20201 #else
20202 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20203 #endif
20204 }
20205 return pyobj;
20206 }
20207
20208
20209 SWIGINTERN int ART_DELETE_set(PyObject *) {
20210 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20211 return 1;
20212 }
20213
20214
20215 SWIGINTERN PyObject *ART_DELETE_get(void) {
20216 PyObject *pyobj = 0;
20217
20218 {
20219 #if wxUSE_UNICODE
20220 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20221 #else
20222 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20223 #endif
20224 }
20225 return pyobj;
20226 }
20227
20228
20229 SWIGINTERN int ART_NEW_set(PyObject *) {
20230 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20231 return 1;
20232 }
20233
20234
20235 SWIGINTERN PyObject *ART_NEW_get(void) {
20236 PyObject *pyobj = 0;
20237
20238 {
20239 #if wxUSE_UNICODE
20240 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20241 #else
20242 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20243 #endif
20244 }
20245 return pyobj;
20246 }
20247
20248
20249 SWIGINTERN int ART_UNDO_set(PyObject *) {
20250 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20251 return 1;
20252 }
20253
20254
20255 SWIGINTERN PyObject *ART_UNDO_get(void) {
20256 PyObject *pyobj = 0;
20257
20258 {
20259 #if wxUSE_UNICODE
20260 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20261 #else
20262 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20263 #endif
20264 }
20265 return pyobj;
20266 }
20267
20268
20269 SWIGINTERN int ART_REDO_set(PyObject *) {
20270 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20271 return 1;
20272 }
20273
20274
20275 SWIGINTERN PyObject *ART_REDO_get(void) {
20276 PyObject *pyobj = 0;
20277
20278 {
20279 #if wxUSE_UNICODE
20280 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20281 #else
20282 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20283 #endif
20284 }
20285 return pyobj;
20286 }
20287
20288
20289 SWIGINTERN int ART_QUIT_set(PyObject *) {
20290 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20291 return 1;
20292 }
20293
20294
20295 SWIGINTERN PyObject *ART_QUIT_get(void) {
20296 PyObject *pyobj = 0;
20297
20298 {
20299 #if wxUSE_UNICODE
20300 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20301 #else
20302 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20303 #endif
20304 }
20305 return pyobj;
20306 }
20307
20308
20309 SWIGINTERN int ART_FIND_set(PyObject *) {
20310 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20311 return 1;
20312 }
20313
20314
20315 SWIGINTERN PyObject *ART_FIND_get(void) {
20316 PyObject *pyobj = 0;
20317
20318 {
20319 #if wxUSE_UNICODE
20320 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20321 #else
20322 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20323 #endif
20324 }
20325 return pyobj;
20326 }
20327
20328
20329 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20330 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20331 return 1;
20332 }
20333
20334
20335 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20336 PyObject *pyobj = 0;
20337
20338 {
20339 #if wxUSE_UNICODE
20340 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20341 #else
20342 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20343 #endif
20344 }
20345 return pyobj;
20346 }
20347
20348
20349 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20350 PyObject *resultobj = 0;
20351 wxPyArtProvider *result = 0 ;
20352
20353 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20354 {
20355 if (!wxPyCheckForApp()) SWIG_fail;
20356 PyThreadState* __tstate = wxPyBeginAllowThreads();
20357 result = (wxPyArtProvider *)new wxPyArtProvider();
20358 wxPyEndAllowThreads(__tstate);
20359 if (PyErr_Occurred()) SWIG_fail;
20360 }
20361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20362 return resultobj;
20363 fail:
20364 return NULL;
20365 }
20366
20367
20368 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20369 PyObject *resultobj = 0;
20370 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20371 void *argp1 = 0 ;
20372 int res1 = 0 ;
20373 PyObject *swig_obj[1] ;
20374
20375 if (!args) SWIG_fail;
20376 swig_obj[0] = args;
20377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20378 if (!SWIG_IsOK(res1)) {
20379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20380 }
20381 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20382 {
20383 PyThreadState* __tstate = wxPyBeginAllowThreads();
20384 delete arg1;
20385
20386 wxPyEndAllowThreads(__tstate);
20387 if (PyErr_Occurred()) SWIG_fail;
20388 }
20389 resultobj = SWIG_Py_Void();
20390 return resultobj;
20391 fail:
20392 return NULL;
20393 }
20394
20395
20396 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20397 PyObject *resultobj = 0;
20398 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20399 PyObject *arg2 = (PyObject *) 0 ;
20400 PyObject *arg3 = (PyObject *) 0 ;
20401 void *argp1 = 0 ;
20402 int res1 = 0 ;
20403 PyObject * obj0 = 0 ;
20404 PyObject * obj1 = 0 ;
20405 PyObject * obj2 = 0 ;
20406 char * kwnames[] = {
20407 (char *) "self",(char *) "self",(char *) "_class", NULL
20408 };
20409
20410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20412 if (!SWIG_IsOK(res1)) {
20413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20414 }
20415 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20416 arg2 = obj1;
20417 arg3 = obj2;
20418 {
20419 PyThreadState* __tstate = wxPyBeginAllowThreads();
20420 (arg1)->_setCallbackInfo(arg2,arg3);
20421 wxPyEndAllowThreads(__tstate);
20422 if (PyErr_Occurred()) SWIG_fail;
20423 }
20424 resultobj = SWIG_Py_Void();
20425 return resultobj;
20426 fail:
20427 return NULL;
20428 }
20429
20430
20431 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20432 PyObject *resultobj = 0;
20433 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20434 int res1 = 0 ;
20435 PyObject * obj0 = 0 ;
20436 char * kwnames[] = {
20437 (char *) "provider", NULL
20438 };
20439
20440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20441 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20442 if (!SWIG_IsOK(res1)) {
20443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20444 }
20445 {
20446 PyThreadState* __tstate = wxPyBeginAllowThreads();
20447 wxPyArtProvider::Push(arg1);
20448 wxPyEndAllowThreads(__tstate);
20449 if (PyErr_Occurred()) SWIG_fail;
20450 }
20451 resultobj = SWIG_Py_Void();
20452 return resultobj;
20453 fail:
20454 return NULL;
20455 }
20456
20457
20458 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20459 PyObject *resultobj = 0;
20460 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20461 int res1 = 0 ;
20462 PyObject * obj0 = 0 ;
20463 char * kwnames[] = {
20464 (char *) "provider", NULL
20465 };
20466
20467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20468 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20469 if (!SWIG_IsOK(res1)) {
20470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20471 }
20472 {
20473 PyThreadState* __tstate = wxPyBeginAllowThreads();
20474 wxPyArtProvider::Insert(arg1);
20475 wxPyEndAllowThreads(__tstate);
20476 if (PyErr_Occurred()) SWIG_fail;
20477 }
20478 resultobj = SWIG_Py_Void();
20479 return resultobj;
20480 fail:
20481 return NULL;
20482 }
20483
20484
20485 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20486 PyObject *resultobj = 0;
20487 bool result;
20488
20489 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20490 {
20491 PyThreadState* __tstate = wxPyBeginAllowThreads();
20492 result = (bool)wxPyArtProvider::Pop();
20493 wxPyEndAllowThreads(__tstate);
20494 if (PyErr_Occurred()) SWIG_fail;
20495 }
20496 {
20497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20498 }
20499 return resultobj;
20500 fail:
20501 return NULL;
20502 }
20503
20504
20505 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20506 PyObject *resultobj = 0;
20507 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20508 bool result;
20509 void *argp1 = 0 ;
20510 int res1 = 0 ;
20511 PyObject * obj0 = 0 ;
20512 char * kwnames[] = {
20513 (char *) "provider", NULL
20514 };
20515
20516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20518 if (!SWIG_IsOK(res1)) {
20519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20520 }
20521 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20522 {
20523 PyThreadState* __tstate = wxPyBeginAllowThreads();
20524 result = (bool)wxPyArtProvider::Delete(arg1);
20525 wxPyEndAllowThreads(__tstate);
20526 if (PyErr_Occurred()) SWIG_fail;
20527 }
20528 {
20529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20530 }
20531 return resultobj;
20532 fail:
20533 return NULL;
20534 }
20535
20536
20537 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20538 PyObject *resultobj = 0;
20539 wxString *arg1 = 0 ;
20540 wxString const &arg2_defvalue = wxPyART_OTHER ;
20541 wxString *arg2 = (wxString *) &arg2_defvalue ;
20542 wxSize const &arg3_defvalue = wxDefaultSize ;
20543 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20544 wxBitmap result;
20545 bool temp1 = false ;
20546 bool temp2 = false ;
20547 wxSize temp3 ;
20548 PyObject * obj0 = 0 ;
20549 PyObject * obj1 = 0 ;
20550 PyObject * obj2 = 0 ;
20551 char * kwnames[] = {
20552 (char *) "id",(char *) "client",(char *) "size", NULL
20553 };
20554
20555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20556 {
20557 arg1 = wxString_in_helper(obj0);
20558 if (arg1 == NULL) SWIG_fail;
20559 temp1 = true;
20560 }
20561 if (obj1) {
20562 {
20563 arg2 = wxString_in_helper(obj1);
20564 if (arg2 == NULL) SWIG_fail;
20565 temp2 = true;
20566 }
20567 }
20568 if (obj2) {
20569 {
20570 arg3 = &temp3;
20571 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20572 }
20573 }
20574 {
20575 if (!wxPyCheckForApp()) SWIG_fail;
20576 PyThreadState* __tstate = wxPyBeginAllowThreads();
20577 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20578 wxPyEndAllowThreads(__tstate);
20579 if (PyErr_Occurred()) SWIG_fail;
20580 }
20581 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20582 {
20583 if (temp1)
20584 delete arg1;
20585 }
20586 {
20587 if (temp2)
20588 delete arg2;
20589 }
20590 return resultobj;
20591 fail:
20592 {
20593 if (temp1)
20594 delete arg1;
20595 }
20596 {
20597 if (temp2)
20598 delete arg2;
20599 }
20600 return NULL;
20601 }
20602
20603
20604 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20605 PyObject *resultobj = 0;
20606 wxString *arg1 = 0 ;
20607 wxString const &arg2_defvalue = wxPyART_OTHER ;
20608 wxString *arg2 = (wxString *) &arg2_defvalue ;
20609 wxSize const &arg3_defvalue = wxDefaultSize ;
20610 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20611 wxIcon result;
20612 bool temp1 = false ;
20613 bool temp2 = false ;
20614 wxSize temp3 ;
20615 PyObject * obj0 = 0 ;
20616 PyObject * obj1 = 0 ;
20617 PyObject * obj2 = 0 ;
20618 char * kwnames[] = {
20619 (char *) "id",(char *) "client",(char *) "size", NULL
20620 };
20621
20622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20623 {
20624 arg1 = wxString_in_helper(obj0);
20625 if (arg1 == NULL) SWIG_fail;
20626 temp1 = true;
20627 }
20628 if (obj1) {
20629 {
20630 arg2 = wxString_in_helper(obj1);
20631 if (arg2 == NULL) SWIG_fail;
20632 temp2 = true;
20633 }
20634 }
20635 if (obj2) {
20636 {
20637 arg3 = &temp3;
20638 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20639 }
20640 }
20641 {
20642 if (!wxPyCheckForApp()) SWIG_fail;
20643 PyThreadState* __tstate = wxPyBeginAllowThreads();
20644 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20645 wxPyEndAllowThreads(__tstate);
20646 if (PyErr_Occurred()) SWIG_fail;
20647 }
20648 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20649 {
20650 if (temp1)
20651 delete arg1;
20652 }
20653 {
20654 if (temp2)
20655 delete arg2;
20656 }
20657 return resultobj;
20658 fail:
20659 {
20660 if (temp1)
20661 delete arg1;
20662 }
20663 {
20664 if (temp2)
20665 delete arg2;
20666 }
20667 return NULL;
20668 }
20669
20670
20671 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20672 PyObject *resultobj = 0;
20673 wxString *arg1 = 0 ;
20674 bool arg2 = (bool) false ;
20675 wxSize result;
20676 bool temp1 = false ;
20677 bool val2 ;
20678 int ecode2 = 0 ;
20679 PyObject * obj0 = 0 ;
20680 PyObject * obj1 = 0 ;
20681 char * kwnames[] = {
20682 (char *) "client",(char *) "platform_dependent", NULL
20683 };
20684
20685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20686 {
20687 arg1 = wxString_in_helper(obj0);
20688 if (arg1 == NULL) SWIG_fail;
20689 temp1 = true;
20690 }
20691 if (obj1) {
20692 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20693 if (!SWIG_IsOK(ecode2)) {
20694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20695 }
20696 arg2 = static_cast< bool >(val2);
20697 }
20698 {
20699 PyThreadState* __tstate = wxPyBeginAllowThreads();
20700 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20701 wxPyEndAllowThreads(__tstate);
20702 if (PyErr_Occurred()) SWIG_fail;
20703 }
20704 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20705 {
20706 if (temp1)
20707 delete arg1;
20708 }
20709 return resultobj;
20710 fail:
20711 {
20712 if (temp1)
20713 delete arg1;
20714 }
20715 return NULL;
20716 }
20717
20718
20719 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20720 PyObject *resultobj = 0;
20721 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20722 void *argp1 = 0 ;
20723 int res1 = 0 ;
20724 PyObject *swig_obj[1] ;
20725
20726 if (!args) SWIG_fail;
20727 swig_obj[0] = args;
20728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20729 if (!SWIG_IsOK(res1)) {
20730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20731 }
20732 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20733 {
20734 PyThreadState* __tstate = wxPyBeginAllowThreads();
20735 wxPyArtProvider_Destroy(arg1);
20736 wxPyEndAllowThreads(__tstate);
20737 if (PyErr_Occurred()) SWIG_fail;
20738 }
20739 resultobj = SWIG_Py_Void();
20740 return resultobj;
20741 fail:
20742 return NULL;
20743 }
20744
20745
20746 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20747 PyObject *obj;
20748 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20749 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20750 return SWIG_Py_Void();
20751 }
20752
20753 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20754 return SWIG_Python_InitShadowInstance(args);
20755 }
20756
20757 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20758 PyObject *resultobj = 0;
20759 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20760 void *argp1 = 0 ;
20761 int res1 = 0 ;
20762 PyObject *swig_obj[1] ;
20763
20764 if (!args) SWIG_fail;
20765 swig_obj[0] = args;
20766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20767 if (!SWIG_IsOK(res1)) {
20768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20769 }
20770 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20771 {
20772 PyThreadState* __tstate = wxPyBeginAllowThreads();
20773 delete arg1;
20774
20775 wxPyEndAllowThreads(__tstate);
20776 if (PyErr_Occurred()) SWIG_fail;
20777 }
20778 resultobj = SWIG_Py_Void();
20779 return resultobj;
20780 fail:
20781 return NULL;
20782 }
20783
20784
20785 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20786 PyObject *resultobj = 0;
20787 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20788 wxConfigBase *result = 0 ;
20789 int res1 = 0 ;
20790 PyObject * obj0 = 0 ;
20791 char * kwnames[] = {
20792 (char *) "config", NULL
20793 };
20794
20795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20796 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20797 if (!SWIG_IsOK(res1)) {
20798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20799 }
20800 {
20801 PyThreadState* __tstate = wxPyBeginAllowThreads();
20802 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20803 wxPyEndAllowThreads(__tstate);
20804 if (PyErr_Occurred()) SWIG_fail;
20805 }
20806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20807 return resultobj;
20808 fail:
20809 return NULL;
20810 }
20811
20812
20813 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20814 PyObject *resultobj = 0;
20815 bool arg1 = (bool) true ;
20816 wxConfigBase *result = 0 ;
20817 bool val1 ;
20818 int ecode1 = 0 ;
20819 PyObject * obj0 = 0 ;
20820 char * kwnames[] = {
20821 (char *) "createOnDemand", NULL
20822 };
20823
20824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20825 if (obj0) {
20826 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20827 if (!SWIG_IsOK(ecode1)) {
20828 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20829 }
20830 arg1 = static_cast< bool >(val1);
20831 }
20832 {
20833 PyThreadState* __tstate = wxPyBeginAllowThreads();
20834 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20835 wxPyEndAllowThreads(__tstate);
20836 if (PyErr_Occurred()) SWIG_fail;
20837 }
20838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20839 return resultobj;
20840 fail:
20841 return NULL;
20842 }
20843
20844
20845 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20846 PyObject *resultobj = 0;
20847 wxConfigBase *result = 0 ;
20848
20849 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20850 {
20851 PyThreadState* __tstate = wxPyBeginAllowThreads();
20852 result = (wxConfigBase *)wxConfigBase::Create();
20853 wxPyEndAllowThreads(__tstate);
20854 if (PyErr_Occurred()) SWIG_fail;
20855 }
20856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20857 return resultobj;
20858 fail:
20859 return NULL;
20860 }
20861
20862
20863 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20864 PyObject *resultobj = 0;
20865
20866 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20867 {
20868 PyThreadState* __tstate = wxPyBeginAllowThreads();
20869 wxConfigBase::DontCreateOnDemand();
20870 wxPyEndAllowThreads(__tstate);
20871 if (PyErr_Occurred()) SWIG_fail;
20872 }
20873 resultobj = SWIG_Py_Void();
20874 return resultobj;
20875 fail:
20876 return NULL;
20877 }
20878
20879
20880 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20881 PyObject *resultobj = 0;
20882 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20883 wxString *arg2 = 0 ;
20884 void *argp1 = 0 ;
20885 int res1 = 0 ;
20886 bool temp2 = false ;
20887 PyObject * obj0 = 0 ;
20888 PyObject * obj1 = 0 ;
20889 char * kwnames[] = {
20890 (char *) "self",(char *) "path", NULL
20891 };
20892
20893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20895 if (!SWIG_IsOK(res1)) {
20896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20897 }
20898 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20899 {
20900 arg2 = wxString_in_helper(obj1);
20901 if (arg2 == NULL) SWIG_fail;
20902 temp2 = true;
20903 }
20904 {
20905 PyThreadState* __tstate = wxPyBeginAllowThreads();
20906 (arg1)->SetPath((wxString const &)*arg2);
20907 wxPyEndAllowThreads(__tstate);
20908 if (PyErr_Occurred()) SWIG_fail;
20909 }
20910 resultobj = SWIG_Py_Void();
20911 {
20912 if (temp2)
20913 delete arg2;
20914 }
20915 return resultobj;
20916 fail:
20917 {
20918 if (temp2)
20919 delete arg2;
20920 }
20921 return NULL;
20922 }
20923
20924
20925 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20926 PyObject *resultobj = 0;
20927 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20928 wxString *result = 0 ;
20929 void *argp1 = 0 ;
20930 int res1 = 0 ;
20931 PyObject *swig_obj[1] ;
20932
20933 if (!args) SWIG_fail;
20934 swig_obj[0] = args;
20935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20936 if (!SWIG_IsOK(res1)) {
20937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20938 }
20939 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20940 {
20941 PyThreadState* __tstate = wxPyBeginAllowThreads();
20942 {
20943 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
20944 result = (wxString *) &_result_ref;
20945 }
20946 wxPyEndAllowThreads(__tstate);
20947 if (PyErr_Occurred()) SWIG_fail;
20948 }
20949 {
20950 #if wxUSE_UNICODE
20951 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
20952 #else
20953 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
20954 #endif
20955 }
20956 return resultobj;
20957 fail:
20958 return NULL;
20959 }
20960
20961
20962 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20963 PyObject *resultobj = 0;
20964 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20965 PyObject *result = 0 ;
20966 void *argp1 = 0 ;
20967 int res1 = 0 ;
20968 PyObject *swig_obj[1] ;
20969
20970 if (!args) SWIG_fail;
20971 swig_obj[0] = args;
20972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20973 if (!SWIG_IsOK(res1)) {
20974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20975 }
20976 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20977 {
20978 PyThreadState* __tstate = wxPyBeginAllowThreads();
20979 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
20980 wxPyEndAllowThreads(__tstate);
20981 if (PyErr_Occurred()) SWIG_fail;
20982 }
20983 resultobj = result;
20984 return resultobj;
20985 fail:
20986 return NULL;
20987 }
20988
20989
20990 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20991 PyObject *resultobj = 0;
20992 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20993 long arg2 ;
20994 PyObject *result = 0 ;
20995 void *argp1 = 0 ;
20996 int res1 = 0 ;
20997 long val2 ;
20998 int ecode2 = 0 ;
20999 PyObject * obj0 = 0 ;
21000 PyObject * obj1 = 0 ;
21001 char * kwnames[] = {
21002 (char *) "self",(char *) "index", NULL
21003 };
21004
21005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21007 if (!SWIG_IsOK(res1)) {
21008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21009 }
21010 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21011 ecode2 = SWIG_AsVal_long(obj1, &val2);
21012 if (!SWIG_IsOK(ecode2)) {
21013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21014 }
21015 arg2 = static_cast< long >(val2);
21016 {
21017 PyThreadState* __tstate = wxPyBeginAllowThreads();
21018 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21019 wxPyEndAllowThreads(__tstate);
21020 if (PyErr_Occurred()) SWIG_fail;
21021 }
21022 resultobj = result;
21023 return resultobj;
21024 fail:
21025 return NULL;
21026 }
21027
21028
21029 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21030 PyObject *resultobj = 0;
21031 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21032 PyObject *result = 0 ;
21033 void *argp1 = 0 ;
21034 int res1 = 0 ;
21035 PyObject *swig_obj[1] ;
21036
21037 if (!args) SWIG_fail;
21038 swig_obj[0] = args;
21039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21040 if (!SWIG_IsOK(res1)) {
21041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21042 }
21043 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21044 {
21045 PyThreadState* __tstate = wxPyBeginAllowThreads();
21046 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21047 wxPyEndAllowThreads(__tstate);
21048 if (PyErr_Occurred()) SWIG_fail;
21049 }
21050 resultobj = result;
21051 return resultobj;
21052 fail:
21053 return NULL;
21054 }
21055
21056
21057 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21058 PyObject *resultobj = 0;
21059 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21060 long arg2 ;
21061 PyObject *result = 0 ;
21062 void *argp1 = 0 ;
21063 int res1 = 0 ;
21064 long val2 ;
21065 int ecode2 = 0 ;
21066 PyObject * obj0 = 0 ;
21067 PyObject * obj1 = 0 ;
21068 char * kwnames[] = {
21069 (char *) "self",(char *) "index", NULL
21070 };
21071
21072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21074 if (!SWIG_IsOK(res1)) {
21075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21076 }
21077 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21078 ecode2 = SWIG_AsVal_long(obj1, &val2);
21079 if (!SWIG_IsOK(ecode2)) {
21080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21081 }
21082 arg2 = static_cast< long >(val2);
21083 {
21084 PyThreadState* __tstate = wxPyBeginAllowThreads();
21085 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21086 wxPyEndAllowThreads(__tstate);
21087 if (PyErr_Occurred()) SWIG_fail;
21088 }
21089 resultobj = result;
21090 return resultobj;
21091 fail:
21092 return NULL;
21093 }
21094
21095
21096 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21097 PyObject *resultobj = 0;
21098 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21099 bool arg2 = (bool) false ;
21100 size_t result;
21101 void *argp1 = 0 ;
21102 int res1 = 0 ;
21103 bool val2 ;
21104 int ecode2 = 0 ;
21105 PyObject * obj0 = 0 ;
21106 PyObject * obj1 = 0 ;
21107 char * kwnames[] = {
21108 (char *) "self",(char *) "recursive", NULL
21109 };
21110
21111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21113 if (!SWIG_IsOK(res1)) {
21114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21115 }
21116 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21117 if (obj1) {
21118 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21119 if (!SWIG_IsOK(ecode2)) {
21120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21121 }
21122 arg2 = static_cast< bool >(val2);
21123 }
21124 {
21125 PyThreadState* __tstate = wxPyBeginAllowThreads();
21126 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21127 wxPyEndAllowThreads(__tstate);
21128 if (PyErr_Occurred()) SWIG_fail;
21129 }
21130 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21131 return resultobj;
21132 fail:
21133 return NULL;
21134 }
21135
21136
21137 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21138 PyObject *resultobj = 0;
21139 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21140 bool arg2 = (bool) false ;
21141 size_t result;
21142 void *argp1 = 0 ;
21143 int res1 = 0 ;
21144 bool val2 ;
21145 int ecode2 = 0 ;
21146 PyObject * obj0 = 0 ;
21147 PyObject * obj1 = 0 ;
21148 char * kwnames[] = {
21149 (char *) "self",(char *) "recursive", NULL
21150 };
21151
21152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21154 if (!SWIG_IsOK(res1)) {
21155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21156 }
21157 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21158 if (obj1) {
21159 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21160 if (!SWIG_IsOK(ecode2)) {
21161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21162 }
21163 arg2 = static_cast< bool >(val2);
21164 }
21165 {
21166 PyThreadState* __tstate = wxPyBeginAllowThreads();
21167 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21168 wxPyEndAllowThreads(__tstate);
21169 if (PyErr_Occurred()) SWIG_fail;
21170 }
21171 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21172 return resultobj;
21173 fail:
21174 return NULL;
21175 }
21176
21177
21178 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21179 PyObject *resultobj = 0;
21180 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21181 wxString *arg2 = 0 ;
21182 bool result;
21183 void *argp1 = 0 ;
21184 int res1 = 0 ;
21185 bool temp2 = false ;
21186 PyObject * obj0 = 0 ;
21187 PyObject * obj1 = 0 ;
21188 char * kwnames[] = {
21189 (char *) "self",(char *) "name", NULL
21190 };
21191
21192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21194 if (!SWIG_IsOK(res1)) {
21195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21196 }
21197 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21198 {
21199 arg2 = wxString_in_helper(obj1);
21200 if (arg2 == NULL) SWIG_fail;
21201 temp2 = true;
21202 }
21203 {
21204 PyThreadState* __tstate = wxPyBeginAllowThreads();
21205 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21206 wxPyEndAllowThreads(__tstate);
21207 if (PyErr_Occurred()) SWIG_fail;
21208 }
21209 {
21210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21211 }
21212 {
21213 if (temp2)
21214 delete arg2;
21215 }
21216 return resultobj;
21217 fail:
21218 {
21219 if (temp2)
21220 delete arg2;
21221 }
21222 return NULL;
21223 }
21224
21225
21226 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21227 PyObject *resultobj = 0;
21228 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21229 wxString *arg2 = 0 ;
21230 bool result;
21231 void *argp1 = 0 ;
21232 int res1 = 0 ;
21233 bool temp2 = false ;
21234 PyObject * obj0 = 0 ;
21235 PyObject * obj1 = 0 ;
21236 char * kwnames[] = {
21237 (char *) "self",(char *) "name", NULL
21238 };
21239
21240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21242 if (!SWIG_IsOK(res1)) {
21243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21244 }
21245 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21246 {
21247 arg2 = wxString_in_helper(obj1);
21248 if (arg2 == NULL) SWIG_fail;
21249 temp2 = true;
21250 }
21251 {
21252 PyThreadState* __tstate = wxPyBeginAllowThreads();
21253 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21254 wxPyEndAllowThreads(__tstate);
21255 if (PyErr_Occurred()) SWIG_fail;
21256 }
21257 {
21258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21259 }
21260 {
21261 if (temp2)
21262 delete arg2;
21263 }
21264 return resultobj;
21265 fail:
21266 {
21267 if (temp2)
21268 delete arg2;
21269 }
21270 return NULL;
21271 }
21272
21273
21274 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21275 PyObject *resultobj = 0;
21276 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21277 wxString *arg2 = 0 ;
21278 bool result;
21279 void *argp1 = 0 ;
21280 int res1 = 0 ;
21281 bool temp2 = false ;
21282 PyObject * obj0 = 0 ;
21283 PyObject * obj1 = 0 ;
21284 char * kwnames[] = {
21285 (char *) "self",(char *) "name", NULL
21286 };
21287
21288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21290 if (!SWIG_IsOK(res1)) {
21291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21292 }
21293 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21294 {
21295 arg2 = wxString_in_helper(obj1);
21296 if (arg2 == NULL) SWIG_fail;
21297 temp2 = true;
21298 }
21299 {
21300 PyThreadState* __tstate = wxPyBeginAllowThreads();
21301 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21302 wxPyEndAllowThreads(__tstate);
21303 if (PyErr_Occurred()) SWIG_fail;
21304 }
21305 {
21306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21307 }
21308 {
21309 if (temp2)
21310 delete arg2;
21311 }
21312 return resultobj;
21313 fail:
21314 {
21315 if (temp2)
21316 delete arg2;
21317 }
21318 return NULL;
21319 }
21320
21321
21322 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21323 PyObject *resultobj = 0;
21324 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21325 wxString *arg2 = 0 ;
21326 wxConfigBase::EntryType result;
21327 void *argp1 = 0 ;
21328 int res1 = 0 ;
21329 bool temp2 = false ;
21330 PyObject * obj0 = 0 ;
21331 PyObject * obj1 = 0 ;
21332 char * kwnames[] = {
21333 (char *) "self",(char *) "name", NULL
21334 };
21335
21336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21338 if (!SWIG_IsOK(res1)) {
21339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21340 }
21341 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21342 {
21343 arg2 = wxString_in_helper(obj1);
21344 if (arg2 == NULL) SWIG_fail;
21345 temp2 = true;
21346 }
21347 {
21348 PyThreadState* __tstate = wxPyBeginAllowThreads();
21349 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21350 wxPyEndAllowThreads(__tstate);
21351 if (PyErr_Occurred()) SWIG_fail;
21352 }
21353 resultobj = SWIG_From_int(static_cast< int >(result));
21354 {
21355 if (temp2)
21356 delete arg2;
21357 }
21358 return resultobj;
21359 fail:
21360 {
21361 if (temp2)
21362 delete arg2;
21363 }
21364 return NULL;
21365 }
21366
21367
21368 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21369 PyObject *resultobj = 0;
21370 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21371 wxString *arg2 = 0 ;
21372 wxString const &arg3_defvalue = wxPyEmptyString ;
21373 wxString *arg3 = (wxString *) &arg3_defvalue ;
21374 wxString result;
21375 void *argp1 = 0 ;
21376 int res1 = 0 ;
21377 bool temp2 = false ;
21378 bool temp3 = false ;
21379 PyObject * obj0 = 0 ;
21380 PyObject * obj1 = 0 ;
21381 PyObject * obj2 = 0 ;
21382 char * kwnames[] = {
21383 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21384 };
21385
21386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21388 if (!SWIG_IsOK(res1)) {
21389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21390 }
21391 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21392 {
21393 arg2 = wxString_in_helper(obj1);
21394 if (arg2 == NULL) SWIG_fail;
21395 temp2 = true;
21396 }
21397 if (obj2) {
21398 {
21399 arg3 = wxString_in_helper(obj2);
21400 if (arg3 == NULL) SWIG_fail;
21401 temp3 = true;
21402 }
21403 }
21404 {
21405 PyThreadState* __tstate = wxPyBeginAllowThreads();
21406 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21407 wxPyEndAllowThreads(__tstate);
21408 if (PyErr_Occurred()) SWIG_fail;
21409 }
21410 {
21411 #if wxUSE_UNICODE
21412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21413 #else
21414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21415 #endif
21416 }
21417 {
21418 if (temp2)
21419 delete arg2;
21420 }
21421 {
21422 if (temp3)
21423 delete arg3;
21424 }
21425 return resultobj;
21426 fail:
21427 {
21428 if (temp2)
21429 delete arg2;
21430 }
21431 {
21432 if (temp3)
21433 delete arg3;
21434 }
21435 return NULL;
21436 }
21437
21438
21439 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21440 PyObject *resultobj = 0;
21441 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21442 wxString *arg2 = 0 ;
21443 long arg3 = (long) 0 ;
21444 long result;
21445 void *argp1 = 0 ;
21446 int res1 = 0 ;
21447 bool temp2 = false ;
21448 long val3 ;
21449 int ecode3 = 0 ;
21450 PyObject * obj0 = 0 ;
21451 PyObject * obj1 = 0 ;
21452 PyObject * obj2 = 0 ;
21453 char * kwnames[] = {
21454 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21455 };
21456
21457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21459 if (!SWIG_IsOK(res1)) {
21460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21461 }
21462 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21463 {
21464 arg2 = wxString_in_helper(obj1);
21465 if (arg2 == NULL) SWIG_fail;
21466 temp2 = true;
21467 }
21468 if (obj2) {
21469 ecode3 = SWIG_AsVal_long(obj2, &val3);
21470 if (!SWIG_IsOK(ecode3)) {
21471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21472 }
21473 arg3 = static_cast< long >(val3);
21474 }
21475 {
21476 PyThreadState* __tstate = wxPyBeginAllowThreads();
21477 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21478 wxPyEndAllowThreads(__tstate);
21479 if (PyErr_Occurred()) SWIG_fail;
21480 }
21481 resultobj = SWIG_From_long(static_cast< long >(result));
21482 {
21483 if (temp2)
21484 delete arg2;
21485 }
21486 return resultobj;
21487 fail:
21488 {
21489 if (temp2)
21490 delete arg2;
21491 }
21492 return NULL;
21493 }
21494
21495
21496 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21497 PyObject *resultobj = 0;
21498 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21499 wxString *arg2 = 0 ;
21500 double arg3 = (double) 0.0 ;
21501 double result;
21502 void *argp1 = 0 ;
21503 int res1 = 0 ;
21504 bool temp2 = false ;
21505 double val3 ;
21506 int ecode3 = 0 ;
21507 PyObject * obj0 = 0 ;
21508 PyObject * obj1 = 0 ;
21509 PyObject * obj2 = 0 ;
21510 char * kwnames[] = {
21511 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21512 };
21513
21514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21516 if (!SWIG_IsOK(res1)) {
21517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21518 }
21519 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21520 {
21521 arg2 = wxString_in_helper(obj1);
21522 if (arg2 == NULL) SWIG_fail;
21523 temp2 = true;
21524 }
21525 if (obj2) {
21526 ecode3 = SWIG_AsVal_double(obj2, &val3);
21527 if (!SWIG_IsOK(ecode3)) {
21528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21529 }
21530 arg3 = static_cast< double >(val3);
21531 }
21532 {
21533 PyThreadState* __tstate = wxPyBeginAllowThreads();
21534 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21535 wxPyEndAllowThreads(__tstate);
21536 if (PyErr_Occurred()) SWIG_fail;
21537 }
21538 resultobj = SWIG_From_double(static_cast< double >(result));
21539 {
21540 if (temp2)
21541 delete arg2;
21542 }
21543 return resultobj;
21544 fail:
21545 {
21546 if (temp2)
21547 delete arg2;
21548 }
21549 return NULL;
21550 }
21551
21552
21553 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21554 PyObject *resultobj = 0;
21555 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21556 wxString *arg2 = 0 ;
21557 bool arg3 = (bool) false ;
21558 bool result;
21559 void *argp1 = 0 ;
21560 int res1 = 0 ;
21561 bool temp2 = false ;
21562 bool val3 ;
21563 int ecode3 = 0 ;
21564 PyObject * obj0 = 0 ;
21565 PyObject * obj1 = 0 ;
21566 PyObject * obj2 = 0 ;
21567 char * kwnames[] = {
21568 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21569 };
21570
21571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21573 if (!SWIG_IsOK(res1)) {
21574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21575 }
21576 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21577 {
21578 arg2 = wxString_in_helper(obj1);
21579 if (arg2 == NULL) SWIG_fail;
21580 temp2 = true;
21581 }
21582 if (obj2) {
21583 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21584 if (!SWIG_IsOK(ecode3)) {
21585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21586 }
21587 arg3 = static_cast< bool >(val3);
21588 }
21589 {
21590 PyThreadState* __tstate = wxPyBeginAllowThreads();
21591 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21592 wxPyEndAllowThreads(__tstate);
21593 if (PyErr_Occurred()) SWIG_fail;
21594 }
21595 {
21596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21597 }
21598 {
21599 if (temp2)
21600 delete arg2;
21601 }
21602 return resultobj;
21603 fail:
21604 {
21605 if (temp2)
21606 delete arg2;
21607 }
21608 return NULL;
21609 }
21610
21611
21612 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21613 PyObject *resultobj = 0;
21614 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21615 wxString *arg2 = 0 ;
21616 wxString *arg3 = 0 ;
21617 bool result;
21618 void *argp1 = 0 ;
21619 int res1 = 0 ;
21620 bool temp2 = false ;
21621 bool temp3 = false ;
21622 PyObject * obj0 = 0 ;
21623 PyObject * obj1 = 0 ;
21624 PyObject * obj2 = 0 ;
21625 char * kwnames[] = {
21626 (char *) "self",(char *) "key",(char *) "value", NULL
21627 };
21628
21629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21631 if (!SWIG_IsOK(res1)) {
21632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21633 }
21634 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21635 {
21636 arg2 = wxString_in_helper(obj1);
21637 if (arg2 == NULL) SWIG_fail;
21638 temp2 = true;
21639 }
21640 {
21641 arg3 = wxString_in_helper(obj2);
21642 if (arg3 == NULL) SWIG_fail;
21643 temp3 = true;
21644 }
21645 {
21646 PyThreadState* __tstate = wxPyBeginAllowThreads();
21647 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21648 wxPyEndAllowThreads(__tstate);
21649 if (PyErr_Occurred()) SWIG_fail;
21650 }
21651 {
21652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21653 }
21654 {
21655 if (temp2)
21656 delete arg2;
21657 }
21658 {
21659 if (temp3)
21660 delete arg3;
21661 }
21662 return resultobj;
21663 fail:
21664 {
21665 if (temp2)
21666 delete arg2;
21667 }
21668 {
21669 if (temp3)
21670 delete arg3;
21671 }
21672 return NULL;
21673 }
21674
21675
21676 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21677 PyObject *resultobj = 0;
21678 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21679 wxString *arg2 = 0 ;
21680 long arg3 ;
21681 bool result;
21682 void *argp1 = 0 ;
21683 int res1 = 0 ;
21684 bool temp2 = false ;
21685 long val3 ;
21686 int ecode3 = 0 ;
21687 PyObject * obj0 = 0 ;
21688 PyObject * obj1 = 0 ;
21689 PyObject * obj2 = 0 ;
21690 char * kwnames[] = {
21691 (char *) "self",(char *) "key",(char *) "value", NULL
21692 };
21693
21694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21696 if (!SWIG_IsOK(res1)) {
21697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21698 }
21699 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21700 {
21701 arg2 = wxString_in_helper(obj1);
21702 if (arg2 == NULL) SWIG_fail;
21703 temp2 = true;
21704 }
21705 ecode3 = SWIG_AsVal_long(obj2, &val3);
21706 if (!SWIG_IsOK(ecode3)) {
21707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21708 }
21709 arg3 = static_cast< long >(val3);
21710 {
21711 PyThreadState* __tstate = wxPyBeginAllowThreads();
21712 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21713 wxPyEndAllowThreads(__tstate);
21714 if (PyErr_Occurred()) SWIG_fail;
21715 }
21716 {
21717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21718 }
21719 {
21720 if (temp2)
21721 delete arg2;
21722 }
21723 return resultobj;
21724 fail:
21725 {
21726 if (temp2)
21727 delete arg2;
21728 }
21729 return NULL;
21730 }
21731
21732
21733 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21734 PyObject *resultobj = 0;
21735 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21736 wxString *arg2 = 0 ;
21737 double arg3 ;
21738 bool result;
21739 void *argp1 = 0 ;
21740 int res1 = 0 ;
21741 bool temp2 = false ;
21742 double val3 ;
21743 int ecode3 = 0 ;
21744 PyObject * obj0 = 0 ;
21745 PyObject * obj1 = 0 ;
21746 PyObject * obj2 = 0 ;
21747 char * kwnames[] = {
21748 (char *) "self",(char *) "key",(char *) "value", NULL
21749 };
21750
21751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21753 if (!SWIG_IsOK(res1)) {
21754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21755 }
21756 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21757 {
21758 arg2 = wxString_in_helper(obj1);
21759 if (arg2 == NULL) SWIG_fail;
21760 temp2 = true;
21761 }
21762 ecode3 = SWIG_AsVal_double(obj2, &val3);
21763 if (!SWIG_IsOK(ecode3)) {
21764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21765 }
21766 arg3 = static_cast< double >(val3);
21767 {
21768 PyThreadState* __tstate = wxPyBeginAllowThreads();
21769 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21770 wxPyEndAllowThreads(__tstate);
21771 if (PyErr_Occurred()) SWIG_fail;
21772 }
21773 {
21774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21775 }
21776 {
21777 if (temp2)
21778 delete arg2;
21779 }
21780 return resultobj;
21781 fail:
21782 {
21783 if (temp2)
21784 delete arg2;
21785 }
21786 return NULL;
21787 }
21788
21789
21790 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21791 PyObject *resultobj = 0;
21792 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21793 wxString *arg2 = 0 ;
21794 bool arg3 ;
21795 bool result;
21796 void *argp1 = 0 ;
21797 int res1 = 0 ;
21798 bool temp2 = false ;
21799 bool val3 ;
21800 int ecode3 = 0 ;
21801 PyObject * obj0 = 0 ;
21802 PyObject * obj1 = 0 ;
21803 PyObject * obj2 = 0 ;
21804 char * kwnames[] = {
21805 (char *) "self",(char *) "key",(char *) "value", NULL
21806 };
21807
21808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21810 if (!SWIG_IsOK(res1)) {
21811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21812 }
21813 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21814 {
21815 arg2 = wxString_in_helper(obj1);
21816 if (arg2 == NULL) SWIG_fail;
21817 temp2 = true;
21818 }
21819 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21820 if (!SWIG_IsOK(ecode3)) {
21821 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21822 }
21823 arg3 = static_cast< bool >(val3);
21824 {
21825 PyThreadState* __tstate = wxPyBeginAllowThreads();
21826 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21827 wxPyEndAllowThreads(__tstate);
21828 if (PyErr_Occurred()) SWIG_fail;
21829 }
21830 {
21831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21832 }
21833 {
21834 if (temp2)
21835 delete arg2;
21836 }
21837 return resultobj;
21838 fail:
21839 {
21840 if (temp2)
21841 delete arg2;
21842 }
21843 return NULL;
21844 }
21845
21846
21847 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21848 PyObject *resultobj = 0;
21849 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21850 bool arg2 = (bool) false ;
21851 bool result;
21852 void *argp1 = 0 ;
21853 int res1 = 0 ;
21854 bool val2 ;
21855 int ecode2 = 0 ;
21856 PyObject * obj0 = 0 ;
21857 PyObject * obj1 = 0 ;
21858 char * kwnames[] = {
21859 (char *) "self",(char *) "currentOnly", NULL
21860 };
21861
21862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21864 if (!SWIG_IsOK(res1)) {
21865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21866 }
21867 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21868 if (obj1) {
21869 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21870 if (!SWIG_IsOK(ecode2)) {
21871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21872 }
21873 arg2 = static_cast< bool >(val2);
21874 }
21875 {
21876 PyThreadState* __tstate = wxPyBeginAllowThreads();
21877 result = (bool)(arg1)->Flush(arg2);
21878 wxPyEndAllowThreads(__tstate);
21879 if (PyErr_Occurred()) SWIG_fail;
21880 }
21881 {
21882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21883 }
21884 return resultobj;
21885 fail:
21886 return NULL;
21887 }
21888
21889
21890 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21891 PyObject *resultobj = 0;
21892 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21893 wxString *arg2 = 0 ;
21894 wxString *arg3 = 0 ;
21895 bool result;
21896 void *argp1 = 0 ;
21897 int res1 = 0 ;
21898 bool temp2 = false ;
21899 bool temp3 = false ;
21900 PyObject * obj0 = 0 ;
21901 PyObject * obj1 = 0 ;
21902 PyObject * obj2 = 0 ;
21903 char * kwnames[] = {
21904 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21905 };
21906
21907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21909 if (!SWIG_IsOK(res1)) {
21910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21911 }
21912 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21913 {
21914 arg2 = wxString_in_helper(obj1);
21915 if (arg2 == NULL) SWIG_fail;
21916 temp2 = true;
21917 }
21918 {
21919 arg3 = wxString_in_helper(obj2);
21920 if (arg3 == NULL) SWIG_fail;
21921 temp3 = true;
21922 }
21923 {
21924 PyThreadState* __tstate = wxPyBeginAllowThreads();
21925 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
21926 wxPyEndAllowThreads(__tstate);
21927 if (PyErr_Occurred()) SWIG_fail;
21928 }
21929 {
21930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21931 }
21932 {
21933 if (temp2)
21934 delete arg2;
21935 }
21936 {
21937 if (temp3)
21938 delete arg3;
21939 }
21940 return resultobj;
21941 fail:
21942 {
21943 if (temp2)
21944 delete arg2;
21945 }
21946 {
21947 if (temp3)
21948 delete arg3;
21949 }
21950 return NULL;
21951 }
21952
21953
21954 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21955 PyObject *resultobj = 0;
21956 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21957 wxString *arg2 = 0 ;
21958 wxString *arg3 = 0 ;
21959 bool result;
21960 void *argp1 = 0 ;
21961 int res1 = 0 ;
21962 bool temp2 = false ;
21963 bool temp3 = false ;
21964 PyObject * obj0 = 0 ;
21965 PyObject * obj1 = 0 ;
21966 PyObject * obj2 = 0 ;
21967 char * kwnames[] = {
21968 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21969 };
21970
21971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21973 if (!SWIG_IsOK(res1)) {
21974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21975 }
21976 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21977 {
21978 arg2 = wxString_in_helper(obj1);
21979 if (arg2 == NULL) SWIG_fail;
21980 temp2 = true;
21981 }
21982 {
21983 arg3 = wxString_in_helper(obj2);
21984 if (arg3 == NULL) SWIG_fail;
21985 temp3 = true;
21986 }
21987 {
21988 PyThreadState* __tstate = wxPyBeginAllowThreads();
21989 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 {
21994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21995 }
21996 {
21997 if (temp2)
21998 delete arg2;
21999 }
22000 {
22001 if (temp3)
22002 delete arg3;
22003 }
22004 return resultobj;
22005 fail:
22006 {
22007 if (temp2)
22008 delete arg2;
22009 }
22010 {
22011 if (temp3)
22012 delete arg3;
22013 }
22014 return NULL;
22015 }
22016
22017
22018 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22019 PyObject *resultobj = 0;
22020 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22021 wxString *arg2 = 0 ;
22022 bool arg3 = (bool) true ;
22023 bool result;
22024 void *argp1 = 0 ;
22025 int res1 = 0 ;
22026 bool temp2 = false ;
22027 bool val3 ;
22028 int ecode3 = 0 ;
22029 PyObject * obj0 = 0 ;
22030 PyObject * obj1 = 0 ;
22031 PyObject * obj2 = 0 ;
22032 char * kwnames[] = {
22033 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22034 };
22035
22036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22038 if (!SWIG_IsOK(res1)) {
22039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22040 }
22041 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22042 {
22043 arg2 = wxString_in_helper(obj1);
22044 if (arg2 == NULL) SWIG_fail;
22045 temp2 = true;
22046 }
22047 if (obj2) {
22048 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22049 if (!SWIG_IsOK(ecode3)) {
22050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22051 }
22052 arg3 = static_cast< bool >(val3);
22053 }
22054 {
22055 PyThreadState* __tstate = wxPyBeginAllowThreads();
22056 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22057 wxPyEndAllowThreads(__tstate);
22058 if (PyErr_Occurred()) SWIG_fail;
22059 }
22060 {
22061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22062 }
22063 {
22064 if (temp2)
22065 delete arg2;
22066 }
22067 return resultobj;
22068 fail:
22069 {
22070 if (temp2)
22071 delete arg2;
22072 }
22073 return NULL;
22074 }
22075
22076
22077 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22078 PyObject *resultobj = 0;
22079 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22080 wxString *arg2 = 0 ;
22081 bool result;
22082 void *argp1 = 0 ;
22083 int res1 = 0 ;
22084 bool temp2 = false ;
22085 PyObject * obj0 = 0 ;
22086 PyObject * obj1 = 0 ;
22087 char * kwnames[] = {
22088 (char *) "self",(char *) "key", NULL
22089 };
22090
22091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22093 if (!SWIG_IsOK(res1)) {
22094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22095 }
22096 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22097 {
22098 arg2 = wxString_in_helper(obj1);
22099 if (arg2 == NULL) SWIG_fail;
22100 temp2 = true;
22101 }
22102 {
22103 PyThreadState* __tstate = wxPyBeginAllowThreads();
22104 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22105 wxPyEndAllowThreads(__tstate);
22106 if (PyErr_Occurred()) SWIG_fail;
22107 }
22108 {
22109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22110 }
22111 {
22112 if (temp2)
22113 delete arg2;
22114 }
22115 return resultobj;
22116 fail:
22117 {
22118 if (temp2)
22119 delete arg2;
22120 }
22121 return NULL;
22122 }
22123
22124
22125 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22126 PyObject *resultobj = 0;
22127 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22128 bool result;
22129 void *argp1 = 0 ;
22130 int res1 = 0 ;
22131 PyObject *swig_obj[1] ;
22132
22133 if (!args) SWIG_fail;
22134 swig_obj[0] = args;
22135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22136 if (!SWIG_IsOK(res1)) {
22137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22138 }
22139 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22140 {
22141 PyThreadState* __tstate = wxPyBeginAllowThreads();
22142 result = (bool)(arg1)->DeleteAll();
22143 wxPyEndAllowThreads(__tstate);
22144 if (PyErr_Occurred()) SWIG_fail;
22145 }
22146 {
22147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22148 }
22149 return resultobj;
22150 fail:
22151 return NULL;
22152 }
22153
22154
22155 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22156 PyObject *resultobj = 0;
22157 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22158 bool arg2 = (bool) true ;
22159 void *argp1 = 0 ;
22160 int res1 = 0 ;
22161 bool val2 ;
22162 int ecode2 = 0 ;
22163 PyObject * obj0 = 0 ;
22164 PyObject * obj1 = 0 ;
22165 char * kwnames[] = {
22166 (char *) "self",(char *) "doIt", NULL
22167 };
22168
22169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22171 if (!SWIG_IsOK(res1)) {
22172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22173 }
22174 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22175 if (obj1) {
22176 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22177 if (!SWIG_IsOK(ecode2)) {
22178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22179 }
22180 arg2 = static_cast< bool >(val2);
22181 }
22182 {
22183 PyThreadState* __tstate = wxPyBeginAllowThreads();
22184 (arg1)->SetExpandEnvVars(arg2);
22185 wxPyEndAllowThreads(__tstate);
22186 if (PyErr_Occurred()) SWIG_fail;
22187 }
22188 resultobj = SWIG_Py_Void();
22189 return resultobj;
22190 fail:
22191 return NULL;
22192 }
22193
22194
22195 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22196 PyObject *resultobj = 0;
22197 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22198 bool result;
22199 void *argp1 = 0 ;
22200 int res1 = 0 ;
22201 PyObject *swig_obj[1] ;
22202
22203 if (!args) SWIG_fail;
22204 swig_obj[0] = args;
22205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22206 if (!SWIG_IsOK(res1)) {
22207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22208 }
22209 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22210 {
22211 PyThreadState* __tstate = wxPyBeginAllowThreads();
22212 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22213 wxPyEndAllowThreads(__tstate);
22214 if (PyErr_Occurred()) SWIG_fail;
22215 }
22216 {
22217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22218 }
22219 return resultobj;
22220 fail:
22221 return NULL;
22222 }
22223
22224
22225 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22226 PyObject *resultobj = 0;
22227 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22228 bool arg2 = (bool) true ;
22229 void *argp1 = 0 ;
22230 int res1 = 0 ;
22231 bool val2 ;
22232 int ecode2 = 0 ;
22233 PyObject * obj0 = 0 ;
22234 PyObject * obj1 = 0 ;
22235 char * kwnames[] = {
22236 (char *) "self",(char *) "doIt", NULL
22237 };
22238
22239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22241 if (!SWIG_IsOK(res1)) {
22242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22243 }
22244 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22245 if (obj1) {
22246 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22247 if (!SWIG_IsOK(ecode2)) {
22248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22249 }
22250 arg2 = static_cast< bool >(val2);
22251 }
22252 {
22253 PyThreadState* __tstate = wxPyBeginAllowThreads();
22254 (arg1)->SetRecordDefaults(arg2);
22255 wxPyEndAllowThreads(__tstate);
22256 if (PyErr_Occurred()) SWIG_fail;
22257 }
22258 resultobj = SWIG_Py_Void();
22259 return resultobj;
22260 fail:
22261 return NULL;
22262 }
22263
22264
22265 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22266 PyObject *resultobj = 0;
22267 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22268 bool result;
22269 void *argp1 = 0 ;
22270 int res1 = 0 ;
22271 PyObject *swig_obj[1] ;
22272
22273 if (!args) SWIG_fail;
22274 swig_obj[0] = args;
22275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22276 if (!SWIG_IsOK(res1)) {
22277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22278 }
22279 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22280 {
22281 PyThreadState* __tstate = wxPyBeginAllowThreads();
22282 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22283 wxPyEndAllowThreads(__tstate);
22284 if (PyErr_Occurred()) SWIG_fail;
22285 }
22286 {
22287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22288 }
22289 return resultobj;
22290 fail:
22291 return NULL;
22292 }
22293
22294
22295 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22296 PyObject *resultobj = 0;
22297 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22298 wxString *arg2 = 0 ;
22299 wxString result;
22300 void *argp1 = 0 ;
22301 int res1 = 0 ;
22302 bool temp2 = false ;
22303 PyObject * obj0 = 0 ;
22304 PyObject * obj1 = 0 ;
22305 char * kwnames[] = {
22306 (char *) "self",(char *) "str", NULL
22307 };
22308
22309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22311 if (!SWIG_IsOK(res1)) {
22312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22313 }
22314 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22315 {
22316 arg2 = wxString_in_helper(obj1);
22317 if (arg2 == NULL) SWIG_fail;
22318 temp2 = true;
22319 }
22320 {
22321 PyThreadState* __tstate = wxPyBeginAllowThreads();
22322 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22323 wxPyEndAllowThreads(__tstate);
22324 if (PyErr_Occurred()) SWIG_fail;
22325 }
22326 {
22327 #if wxUSE_UNICODE
22328 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22329 #else
22330 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22331 #endif
22332 }
22333 {
22334 if (temp2)
22335 delete arg2;
22336 }
22337 return resultobj;
22338 fail:
22339 {
22340 if (temp2)
22341 delete arg2;
22342 }
22343 return NULL;
22344 }
22345
22346
22347 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22348 PyObject *resultobj = 0;
22349 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22350 wxString result;
22351 void *argp1 = 0 ;
22352 int res1 = 0 ;
22353 PyObject *swig_obj[1] ;
22354
22355 if (!args) SWIG_fail;
22356 swig_obj[0] = args;
22357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22358 if (!SWIG_IsOK(res1)) {
22359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22360 }
22361 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22362 {
22363 PyThreadState* __tstate = wxPyBeginAllowThreads();
22364 result = ((wxConfigBase const *)arg1)->GetAppName();
22365 wxPyEndAllowThreads(__tstate);
22366 if (PyErr_Occurred()) SWIG_fail;
22367 }
22368 {
22369 #if wxUSE_UNICODE
22370 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22371 #else
22372 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22373 #endif
22374 }
22375 return resultobj;
22376 fail:
22377 return NULL;
22378 }
22379
22380
22381 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22382 PyObject *resultobj = 0;
22383 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22384 wxString result;
22385 void *argp1 = 0 ;
22386 int res1 = 0 ;
22387 PyObject *swig_obj[1] ;
22388
22389 if (!args) SWIG_fail;
22390 swig_obj[0] = args;
22391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22392 if (!SWIG_IsOK(res1)) {
22393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22394 }
22395 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22396 {
22397 PyThreadState* __tstate = wxPyBeginAllowThreads();
22398 result = ((wxConfigBase const *)arg1)->GetVendorName();
22399 wxPyEndAllowThreads(__tstate);
22400 if (PyErr_Occurred()) SWIG_fail;
22401 }
22402 {
22403 #if wxUSE_UNICODE
22404 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22405 #else
22406 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22407 #endif
22408 }
22409 return resultobj;
22410 fail:
22411 return NULL;
22412 }
22413
22414
22415 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22416 PyObject *resultobj = 0;
22417 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22418 wxString *arg2 = 0 ;
22419 void *argp1 = 0 ;
22420 int res1 = 0 ;
22421 bool temp2 = false ;
22422 PyObject * obj0 = 0 ;
22423 PyObject * obj1 = 0 ;
22424 char * kwnames[] = {
22425 (char *) "self",(char *) "appName", NULL
22426 };
22427
22428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22430 if (!SWIG_IsOK(res1)) {
22431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22432 }
22433 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22434 {
22435 arg2 = wxString_in_helper(obj1);
22436 if (arg2 == NULL) SWIG_fail;
22437 temp2 = true;
22438 }
22439 {
22440 PyThreadState* __tstate = wxPyBeginAllowThreads();
22441 (arg1)->SetAppName((wxString const &)*arg2);
22442 wxPyEndAllowThreads(__tstate);
22443 if (PyErr_Occurred()) SWIG_fail;
22444 }
22445 resultobj = SWIG_Py_Void();
22446 {
22447 if (temp2)
22448 delete arg2;
22449 }
22450 return resultobj;
22451 fail:
22452 {
22453 if (temp2)
22454 delete arg2;
22455 }
22456 return NULL;
22457 }
22458
22459
22460 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22461 PyObject *resultobj = 0;
22462 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22463 wxString *arg2 = 0 ;
22464 void *argp1 = 0 ;
22465 int res1 = 0 ;
22466 bool temp2 = false ;
22467 PyObject * obj0 = 0 ;
22468 PyObject * obj1 = 0 ;
22469 char * kwnames[] = {
22470 (char *) "self",(char *) "vendorName", NULL
22471 };
22472
22473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22475 if (!SWIG_IsOK(res1)) {
22476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22477 }
22478 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22479 {
22480 arg2 = wxString_in_helper(obj1);
22481 if (arg2 == NULL) SWIG_fail;
22482 temp2 = true;
22483 }
22484 {
22485 PyThreadState* __tstate = wxPyBeginAllowThreads();
22486 (arg1)->SetVendorName((wxString const &)*arg2);
22487 wxPyEndAllowThreads(__tstate);
22488 if (PyErr_Occurred()) SWIG_fail;
22489 }
22490 resultobj = SWIG_Py_Void();
22491 {
22492 if (temp2)
22493 delete arg2;
22494 }
22495 return resultobj;
22496 fail:
22497 {
22498 if (temp2)
22499 delete arg2;
22500 }
22501 return NULL;
22502 }
22503
22504
22505 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22506 PyObject *resultobj = 0;
22507 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22508 long arg2 ;
22509 void *argp1 = 0 ;
22510 int res1 = 0 ;
22511 long val2 ;
22512 int ecode2 = 0 ;
22513 PyObject * obj0 = 0 ;
22514 PyObject * obj1 = 0 ;
22515 char * kwnames[] = {
22516 (char *) "self",(char *) "style", NULL
22517 };
22518
22519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22521 if (!SWIG_IsOK(res1)) {
22522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22523 }
22524 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22525 ecode2 = SWIG_AsVal_long(obj1, &val2);
22526 if (!SWIG_IsOK(ecode2)) {
22527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22528 }
22529 arg2 = static_cast< long >(val2);
22530 {
22531 PyThreadState* __tstate = wxPyBeginAllowThreads();
22532 (arg1)->SetStyle(arg2);
22533 wxPyEndAllowThreads(__tstate);
22534 if (PyErr_Occurred()) SWIG_fail;
22535 }
22536 resultobj = SWIG_Py_Void();
22537 return resultobj;
22538 fail:
22539 return NULL;
22540 }
22541
22542
22543 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22544 PyObject *resultobj = 0;
22545 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22546 long result;
22547 void *argp1 = 0 ;
22548 int res1 = 0 ;
22549 PyObject *swig_obj[1] ;
22550
22551 if (!args) SWIG_fail;
22552 swig_obj[0] = args;
22553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22554 if (!SWIG_IsOK(res1)) {
22555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22556 }
22557 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22558 {
22559 PyThreadState* __tstate = wxPyBeginAllowThreads();
22560 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22561 wxPyEndAllowThreads(__tstate);
22562 if (PyErr_Occurred()) SWIG_fail;
22563 }
22564 resultobj = SWIG_From_long(static_cast< long >(result));
22565 return resultobj;
22566 fail:
22567 return NULL;
22568 }
22569
22570
22571 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22572 PyObject *obj;
22573 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22574 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22575 return SWIG_Py_Void();
22576 }
22577
22578 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22579 PyObject *resultobj = 0;
22580 wxString const &arg1_defvalue = wxPyEmptyString ;
22581 wxString *arg1 = (wxString *) &arg1_defvalue ;
22582 wxString const &arg2_defvalue = wxPyEmptyString ;
22583 wxString *arg2 = (wxString *) &arg2_defvalue ;
22584 wxString const &arg3_defvalue = wxPyEmptyString ;
22585 wxString *arg3 = (wxString *) &arg3_defvalue ;
22586 wxString const &arg4_defvalue = wxPyEmptyString ;
22587 wxString *arg4 = (wxString *) &arg4_defvalue ;
22588 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22589 wxConfig *result = 0 ;
22590 bool temp1 = false ;
22591 bool temp2 = false ;
22592 bool temp3 = false ;
22593 bool temp4 = false ;
22594 long val5 ;
22595 int ecode5 = 0 ;
22596 PyObject * obj0 = 0 ;
22597 PyObject * obj1 = 0 ;
22598 PyObject * obj2 = 0 ;
22599 PyObject * obj3 = 0 ;
22600 PyObject * obj4 = 0 ;
22601 char * kwnames[] = {
22602 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22603 };
22604
22605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22606 if (obj0) {
22607 {
22608 arg1 = wxString_in_helper(obj0);
22609 if (arg1 == NULL) SWIG_fail;
22610 temp1 = true;
22611 }
22612 }
22613 if (obj1) {
22614 {
22615 arg2 = wxString_in_helper(obj1);
22616 if (arg2 == NULL) SWIG_fail;
22617 temp2 = true;
22618 }
22619 }
22620 if (obj2) {
22621 {
22622 arg3 = wxString_in_helper(obj2);
22623 if (arg3 == NULL) SWIG_fail;
22624 temp3 = true;
22625 }
22626 }
22627 if (obj3) {
22628 {
22629 arg4 = wxString_in_helper(obj3);
22630 if (arg4 == NULL) SWIG_fail;
22631 temp4 = true;
22632 }
22633 }
22634 if (obj4) {
22635 ecode5 = SWIG_AsVal_long(obj4, &val5);
22636 if (!SWIG_IsOK(ecode5)) {
22637 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22638 }
22639 arg5 = static_cast< long >(val5);
22640 }
22641 {
22642 PyThreadState* __tstate = wxPyBeginAllowThreads();
22643 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22644 wxPyEndAllowThreads(__tstate);
22645 if (PyErr_Occurred()) SWIG_fail;
22646 }
22647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22648 {
22649 if (temp1)
22650 delete arg1;
22651 }
22652 {
22653 if (temp2)
22654 delete arg2;
22655 }
22656 {
22657 if (temp3)
22658 delete arg3;
22659 }
22660 {
22661 if (temp4)
22662 delete arg4;
22663 }
22664 return resultobj;
22665 fail:
22666 {
22667 if (temp1)
22668 delete arg1;
22669 }
22670 {
22671 if (temp2)
22672 delete arg2;
22673 }
22674 {
22675 if (temp3)
22676 delete arg3;
22677 }
22678 {
22679 if (temp4)
22680 delete arg4;
22681 }
22682 return NULL;
22683 }
22684
22685
22686 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22687 PyObject *resultobj = 0;
22688 wxConfig *arg1 = (wxConfig *) 0 ;
22689 void *argp1 = 0 ;
22690 int res1 = 0 ;
22691 PyObject *swig_obj[1] ;
22692
22693 if (!args) SWIG_fail;
22694 swig_obj[0] = args;
22695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22696 if (!SWIG_IsOK(res1)) {
22697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22698 }
22699 arg1 = reinterpret_cast< wxConfig * >(argp1);
22700 {
22701 PyThreadState* __tstate = wxPyBeginAllowThreads();
22702 delete arg1;
22703
22704 wxPyEndAllowThreads(__tstate);
22705 if (PyErr_Occurred()) SWIG_fail;
22706 }
22707 resultobj = SWIG_Py_Void();
22708 return resultobj;
22709 fail:
22710 return NULL;
22711 }
22712
22713
22714 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22715 PyObject *obj;
22716 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22717 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22718 return SWIG_Py_Void();
22719 }
22720
22721 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22722 return SWIG_Python_InitShadowInstance(args);
22723 }
22724
22725 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22726 PyObject *resultobj = 0;
22727 wxString const &arg1_defvalue = wxPyEmptyString ;
22728 wxString *arg1 = (wxString *) &arg1_defvalue ;
22729 wxString const &arg2_defvalue = wxPyEmptyString ;
22730 wxString *arg2 = (wxString *) &arg2_defvalue ;
22731 wxString const &arg3_defvalue = wxPyEmptyString ;
22732 wxString *arg3 = (wxString *) &arg3_defvalue ;
22733 wxString const &arg4_defvalue = wxPyEmptyString ;
22734 wxString *arg4 = (wxString *) &arg4_defvalue ;
22735 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22736 wxFileConfig *result = 0 ;
22737 bool temp1 = false ;
22738 bool temp2 = false ;
22739 bool temp3 = false ;
22740 bool temp4 = false ;
22741 long val5 ;
22742 int ecode5 = 0 ;
22743 PyObject * obj0 = 0 ;
22744 PyObject * obj1 = 0 ;
22745 PyObject * obj2 = 0 ;
22746 PyObject * obj3 = 0 ;
22747 PyObject * obj4 = 0 ;
22748 char * kwnames[] = {
22749 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22750 };
22751
22752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22753 if (obj0) {
22754 {
22755 arg1 = wxString_in_helper(obj0);
22756 if (arg1 == NULL) SWIG_fail;
22757 temp1 = true;
22758 }
22759 }
22760 if (obj1) {
22761 {
22762 arg2 = wxString_in_helper(obj1);
22763 if (arg2 == NULL) SWIG_fail;
22764 temp2 = true;
22765 }
22766 }
22767 if (obj2) {
22768 {
22769 arg3 = wxString_in_helper(obj2);
22770 if (arg3 == NULL) SWIG_fail;
22771 temp3 = true;
22772 }
22773 }
22774 if (obj3) {
22775 {
22776 arg4 = wxString_in_helper(obj3);
22777 if (arg4 == NULL) SWIG_fail;
22778 temp4 = true;
22779 }
22780 }
22781 if (obj4) {
22782 ecode5 = SWIG_AsVal_long(obj4, &val5);
22783 if (!SWIG_IsOK(ecode5)) {
22784 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22785 }
22786 arg5 = static_cast< long >(val5);
22787 }
22788 {
22789 PyThreadState* __tstate = wxPyBeginAllowThreads();
22790 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22791 wxPyEndAllowThreads(__tstate);
22792 if (PyErr_Occurred()) SWIG_fail;
22793 }
22794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22795 {
22796 if (temp1)
22797 delete arg1;
22798 }
22799 {
22800 if (temp2)
22801 delete arg2;
22802 }
22803 {
22804 if (temp3)
22805 delete arg3;
22806 }
22807 {
22808 if (temp4)
22809 delete arg4;
22810 }
22811 return resultobj;
22812 fail:
22813 {
22814 if (temp1)
22815 delete arg1;
22816 }
22817 {
22818 if (temp2)
22819 delete arg2;
22820 }
22821 {
22822 if (temp3)
22823 delete arg3;
22824 }
22825 {
22826 if (temp4)
22827 delete arg4;
22828 }
22829 return NULL;
22830 }
22831
22832
22833 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22834 PyObject *resultobj = 0;
22835 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22836 void *argp1 = 0 ;
22837 int res1 = 0 ;
22838 PyObject *swig_obj[1] ;
22839
22840 if (!args) SWIG_fail;
22841 swig_obj[0] = args;
22842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22843 if (!SWIG_IsOK(res1)) {
22844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22845 }
22846 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22847 {
22848 PyThreadState* __tstate = wxPyBeginAllowThreads();
22849 delete arg1;
22850
22851 wxPyEndAllowThreads(__tstate);
22852 if (PyErr_Occurred()) SWIG_fail;
22853 }
22854 resultobj = SWIG_Py_Void();
22855 return resultobj;
22856 fail:
22857 return NULL;
22858 }
22859
22860
22861 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22862 PyObject *obj;
22863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22864 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22865 return SWIG_Py_Void();
22866 }
22867
22868 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22869 return SWIG_Python_InitShadowInstance(args);
22870 }
22871
22872 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22873 PyObject *resultobj = 0;
22874 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22875 wxString *arg2 = 0 ;
22876 wxConfigPathChanger *result = 0 ;
22877 void *argp1 = 0 ;
22878 int res1 = 0 ;
22879 bool temp2 = false ;
22880 PyObject * obj0 = 0 ;
22881 PyObject * obj1 = 0 ;
22882 char * kwnames[] = {
22883 (char *) "config",(char *) "entry", NULL
22884 };
22885
22886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22888 if (!SWIG_IsOK(res1)) {
22889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22890 }
22891 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22892 {
22893 arg2 = wxString_in_helper(obj1);
22894 if (arg2 == NULL) SWIG_fail;
22895 temp2 = true;
22896 }
22897 {
22898 PyThreadState* __tstate = wxPyBeginAllowThreads();
22899 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22900 wxPyEndAllowThreads(__tstate);
22901 if (PyErr_Occurred()) SWIG_fail;
22902 }
22903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
22904 {
22905 if (temp2)
22906 delete arg2;
22907 }
22908 return resultobj;
22909 fail:
22910 {
22911 if (temp2)
22912 delete arg2;
22913 }
22914 return NULL;
22915 }
22916
22917
22918 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22919 PyObject *resultobj = 0;
22920 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22921 void *argp1 = 0 ;
22922 int res1 = 0 ;
22923 PyObject *swig_obj[1] ;
22924
22925 if (!args) SWIG_fail;
22926 swig_obj[0] = args;
22927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
22928 if (!SWIG_IsOK(res1)) {
22929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
22930 }
22931 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22932 {
22933 PyThreadState* __tstate = wxPyBeginAllowThreads();
22934 delete arg1;
22935
22936 wxPyEndAllowThreads(__tstate);
22937 if (PyErr_Occurred()) SWIG_fail;
22938 }
22939 resultobj = SWIG_Py_Void();
22940 return resultobj;
22941 fail:
22942 return NULL;
22943 }
22944
22945
22946 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22947 PyObject *resultobj = 0;
22948 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22949 wxString *result = 0 ;
22950 void *argp1 = 0 ;
22951 int res1 = 0 ;
22952 PyObject *swig_obj[1] ;
22953
22954 if (!args) SWIG_fail;
22955 swig_obj[0] = args;
22956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
22957 if (!SWIG_IsOK(res1)) {
22958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
22959 }
22960 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22961 {
22962 PyThreadState* __tstate = wxPyBeginAllowThreads();
22963 {
22964 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
22965 result = (wxString *) &_result_ref;
22966 }
22967 wxPyEndAllowThreads(__tstate);
22968 if (PyErr_Occurred()) SWIG_fail;
22969 }
22970 {
22971 #if wxUSE_UNICODE
22972 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22973 #else
22974 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22975 #endif
22976 }
22977 return resultobj;
22978 fail:
22979 return NULL;
22980 }
22981
22982
22983 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22984 PyObject *obj;
22985 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22986 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
22987 return SWIG_Py_Void();
22988 }
22989
22990 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22991 return SWIG_Python_InitShadowInstance(args);
22992 }
22993
22994 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22995 PyObject *resultobj = 0;
22996 wxString *arg1 = 0 ;
22997 wxString result;
22998 bool temp1 = false ;
22999 PyObject * obj0 = 0 ;
23000 char * kwnames[] = {
23001 (char *) "sz", NULL
23002 };
23003
23004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23005 {
23006 arg1 = wxString_in_helper(obj0);
23007 if (arg1 == NULL) SWIG_fail;
23008 temp1 = true;
23009 }
23010 {
23011 PyThreadState* __tstate = wxPyBeginAllowThreads();
23012 result = wxExpandEnvVars((wxString const &)*arg1);
23013 wxPyEndAllowThreads(__tstate);
23014 if (PyErr_Occurred()) SWIG_fail;
23015 }
23016 {
23017 #if wxUSE_UNICODE
23018 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23019 #else
23020 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23021 #endif
23022 }
23023 {
23024 if (temp1)
23025 delete arg1;
23026 }
23027 return resultobj;
23028 fail:
23029 {
23030 if (temp1)
23031 delete arg1;
23032 }
23033 return NULL;
23034 }
23035
23036
23037 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23038 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23039 return 1;
23040 }
23041
23042
23043 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23044 PyObject *pyobj = 0;
23045
23046 {
23047 #if wxUSE_UNICODE
23048 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23049 #else
23050 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23051 #endif
23052 }
23053 return pyobj;
23054 }
23055
23056
23057 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23058 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23059 return 1;
23060 }
23061
23062
23063 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23064 PyObject *pyobj = 0;
23065
23066 {
23067 #if wxUSE_UNICODE
23068 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23069 #else
23070 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23071 #endif
23072 }
23073 return pyobj;
23074 }
23075
23076
23077 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23078 PyObject *resultobj = 0;
23079 wxDateTime::Country arg1 ;
23080 int val1 ;
23081 int ecode1 = 0 ;
23082 PyObject * obj0 = 0 ;
23083 char * kwnames[] = {
23084 (char *) "country", NULL
23085 };
23086
23087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23088 ecode1 = SWIG_AsVal_int(obj0, &val1);
23089 if (!SWIG_IsOK(ecode1)) {
23090 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23091 }
23092 arg1 = static_cast< wxDateTime::Country >(val1);
23093 {
23094 PyThreadState* __tstate = wxPyBeginAllowThreads();
23095 wxDateTime::SetCountry(arg1);
23096 wxPyEndAllowThreads(__tstate);
23097 if (PyErr_Occurred()) SWIG_fail;
23098 }
23099 resultobj = SWIG_Py_Void();
23100 return resultobj;
23101 fail:
23102 return NULL;
23103 }
23104
23105
23106 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23107 PyObject *resultobj = 0;
23108 wxDateTime::Country result;
23109
23110 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23111 {
23112 PyThreadState* __tstate = wxPyBeginAllowThreads();
23113 result = (wxDateTime::Country)wxDateTime::GetCountry();
23114 wxPyEndAllowThreads(__tstate);
23115 if (PyErr_Occurred()) SWIG_fail;
23116 }
23117 resultobj = SWIG_From_int(static_cast< int >(result));
23118 return resultobj;
23119 fail:
23120 return NULL;
23121 }
23122
23123
23124 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23125 PyObject *resultobj = 0;
23126 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23127 bool result;
23128 int val1 ;
23129 int ecode1 = 0 ;
23130 PyObject * obj0 = 0 ;
23131 char * kwnames[] = {
23132 (char *) "country", NULL
23133 };
23134
23135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23136 if (obj0) {
23137 ecode1 = SWIG_AsVal_int(obj0, &val1);
23138 if (!SWIG_IsOK(ecode1)) {
23139 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23140 }
23141 arg1 = static_cast< wxDateTime::Country >(val1);
23142 }
23143 {
23144 PyThreadState* __tstate = wxPyBeginAllowThreads();
23145 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23146 wxPyEndAllowThreads(__tstate);
23147 if (PyErr_Occurred()) SWIG_fail;
23148 }
23149 {
23150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23151 }
23152 return resultobj;
23153 fail:
23154 return NULL;
23155 }
23156
23157
23158 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23159 PyObject *resultobj = 0;
23160 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23161 int result;
23162 int val1 ;
23163 int ecode1 = 0 ;
23164 PyObject * obj0 = 0 ;
23165 char * kwnames[] = {
23166 (char *) "cal", NULL
23167 };
23168
23169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23170 if (obj0) {
23171 ecode1 = SWIG_AsVal_int(obj0, &val1);
23172 if (!SWIG_IsOK(ecode1)) {
23173 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23174 }
23175 arg1 = static_cast< wxDateTime::Calendar >(val1);
23176 }
23177 {
23178 PyThreadState* __tstate = wxPyBeginAllowThreads();
23179 result = (int)wxDateTime::GetCurrentYear(arg1);
23180 wxPyEndAllowThreads(__tstate);
23181 if (PyErr_Occurred()) SWIG_fail;
23182 }
23183 resultobj = SWIG_From_int(static_cast< int >(result));
23184 return resultobj;
23185 fail:
23186 return NULL;
23187 }
23188
23189
23190 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23191 PyObject *resultobj = 0;
23192 int arg1 ;
23193 int result;
23194 int val1 ;
23195 int ecode1 = 0 ;
23196 PyObject * obj0 = 0 ;
23197 char * kwnames[] = {
23198 (char *) "year", NULL
23199 };
23200
23201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23202 ecode1 = SWIG_AsVal_int(obj0, &val1);
23203 if (!SWIG_IsOK(ecode1)) {
23204 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23205 }
23206 arg1 = static_cast< int >(val1);
23207 {
23208 PyThreadState* __tstate = wxPyBeginAllowThreads();
23209 result = (int)wxDateTime::ConvertYearToBC(arg1);
23210 wxPyEndAllowThreads(__tstate);
23211 if (PyErr_Occurred()) SWIG_fail;
23212 }
23213 resultobj = SWIG_From_int(static_cast< int >(result));
23214 return resultobj;
23215 fail:
23216 return NULL;
23217 }
23218
23219
23220 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23221 PyObject *resultobj = 0;
23222 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23223 wxDateTime::Month result;
23224 int val1 ;
23225 int ecode1 = 0 ;
23226 PyObject * obj0 = 0 ;
23227 char * kwnames[] = {
23228 (char *) "cal", NULL
23229 };
23230
23231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23232 if (obj0) {
23233 ecode1 = SWIG_AsVal_int(obj0, &val1);
23234 if (!SWIG_IsOK(ecode1)) {
23235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23236 }
23237 arg1 = static_cast< wxDateTime::Calendar >(val1);
23238 }
23239 {
23240 PyThreadState* __tstate = wxPyBeginAllowThreads();
23241 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23242 wxPyEndAllowThreads(__tstate);
23243 if (PyErr_Occurred()) SWIG_fail;
23244 }
23245 resultobj = SWIG_From_int(static_cast< int >(result));
23246 return resultobj;
23247 fail:
23248 return NULL;
23249 }
23250
23251
23252 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23253 PyObject *resultobj = 0;
23254 int arg1 = (int) wxDateTime::Inv_Year ;
23255 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23256 bool result;
23257 int val1 ;
23258 int ecode1 = 0 ;
23259 int val2 ;
23260 int ecode2 = 0 ;
23261 PyObject * obj0 = 0 ;
23262 PyObject * obj1 = 0 ;
23263 char * kwnames[] = {
23264 (char *) "year",(char *) "cal", NULL
23265 };
23266
23267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23268 if (obj0) {
23269 ecode1 = SWIG_AsVal_int(obj0, &val1);
23270 if (!SWIG_IsOK(ecode1)) {
23271 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23272 }
23273 arg1 = static_cast< int >(val1);
23274 }
23275 if (obj1) {
23276 ecode2 = SWIG_AsVal_int(obj1, &val2);
23277 if (!SWIG_IsOK(ecode2)) {
23278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23279 }
23280 arg2 = static_cast< wxDateTime::Calendar >(val2);
23281 }
23282 {
23283 PyThreadState* __tstate = wxPyBeginAllowThreads();
23284 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23285 wxPyEndAllowThreads(__tstate);
23286 if (PyErr_Occurred()) SWIG_fail;
23287 }
23288 {
23289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23290 }
23291 return resultobj;
23292 fail:
23293 return NULL;
23294 }
23295
23296
23297 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23298 PyObject *resultobj = 0;
23299 int arg1 = (int) wxDateTime::Inv_Year ;
23300 int result;
23301 int val1 ;
23302 int ecode1 = 0 ;
23303 PyObject * obj0 = 0 ;
23304 char * kwnames[] = {
23305 (char *) "year", NULL
23306 };
23307
23308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23309 if (obj0) {
23310 ecode1 = SWIG_AsVal_int(obj0, &val1);
23311 if (!SWIG_IsOK(ecode1)) {
23312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23313 }
23314 arg1 = static_cast< int >(val1);
23315 }
23316 {
23317 PyThreadState* __tstate = wxPyBeginAllowThreads();
23318 result = (int)wxDateTime::GetCentury(arg1);
23319 wxPyEndAllowThreads(__tstate);
23320 if (PyErr_Occurred()) SWIG_fail;
23321 }
23322 resultobj = SWIG_From_int(static_cast< int >(result));
23323 return resultobj;
23324 fail:
23325 return NULL;
23326 }
23327
23328
23329 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23330 PyObject *resultobj = 0;
23331 int arg1 ;
23332 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23333 int result;
23334 int val1 ;
23335 int ecode1 = 0 ;
23336 int val2 ;
23337 int ecode2 = 0 ;
23338 PyObject * obj0 = 0 ;
23339 PyObject * obj1 = 0 ;
23340 char * kwnames[] = {
23341 (char *) "year",(char *) "cal", NULL
23342 };
23343
23344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23345 ecode1 = SWIG_AsVal_int(obj0, &val1);
23346 if (!SWIG_IsOK(ecode1)) {
23347 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23348 }
23349 arg1 = static_cast< int >(val1);
23350 if (obj1) {
23351 ecode2 = SWIG_AsVal_int(obj1, &val2);
23352 if (!SWIG_IsOK(ecode2)) {
23353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23354 }
23355 arg2 = static_cast< wxDateTime::Calendar >(val2);
23356 }
23357 {
23358 PyThreadState* __tstate = wxPyBeginAllowThreads();
23359 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23360 wxPyEndAllowThreads(__tstate);
23361 if (PyErr_Occurred()) SWIG_fail;
23362 }
23363 resultobj = SWIG_From_int(static_cast< int >(result));
23364 return resultobj;
23365 fail:
23366 return NULL;
23367 }
23368
23369
23370 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23371 PyObject *resultobj = 0;
23372 wxDateTime::Month arg1 ;
23373 int arg2 = (int) wxDateTime::Inv_Year ;
23374 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23375 int result;
23376 int val1 ;
23377 int ecode1 = 0 ;
23378 int val2 ;
23379 int ecode2 = 0 ;
23380 int val3 ;
23381 int ecode3 = 0 ;
23382 PyObject * obj0 = 0 ;
23383 PyObject * obj1 = 0 ;
23384 PyObject * obj2 = 0 ;
23385 char * kwnames[] = {
23386 (char *) "month",(char *) "year",(char *) "cal", NULL
23387 };
23388
23389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23390 ecode1 = SWIG_AsVal_int(obj0, &val1);
23391 if (!SWIG_IsOK(ecode1)) {
23392 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23393 }
23394 arg1 = static_cast< wxDateTime::Month >(val1);
23395 if (obj1) {
23396 ecode2 = SWIG_AsVal_int(obj1, &val2);
23397 if (!SWIG_IsOK(ecode2)) {
23398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23399 }
23400 arg2 = static_cast< int >(val2);
23401 }
23402 if (obj2) {
23403 ecode3 = SWIG_AsVal_int(obj2, &val3);
23404 if (!SWIG_IsOK(ecode3)) {
23405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23406 }
23407 arg3 = static_cast< wxDateTime::Calendar >(val3);
23408 }
23409 {
23410 PyThreadState* __tstate = wxPyBeginAllowThreads();
23411 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23412 wxPyEndAllowThreads(__tstate);
23413 if (PyErr_Occurred()) SWIG_fail;
23414 }
23415 resultobj = SWIG_From_int(static_cast< int >(result));
23416 return resultobj;
23417 fail:
23418 return NULL;
23419 }
23420
23421
23422 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23423 PyObject *resultobj = 0;
23424 wxDateTime::Month arg1 ;
23425 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23426 wxString result;
23427 int val1 ;
23428 int ecode1 = 0 ;
23429 int val2 ;
23430 int ecode2 = 0 ;
23431 PyObject * obj0 = 0 ;
23432 PyObject * obj1 = 0 ;
23433 char * kwnames[] = {
23434 (char *) "month",(char *) "flags", NULL
23435 };
23436
23437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23438 ecode1 = SWIG_AsVal_int(obj0, &val1);
23439 if (!SWIG_IsOK(ecode1)) {
23440 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23441 }
23442 arg1 = static_cast< wxDateTime::Month >(val1);
23443 if (obj1) {
23444 ecode2 = SWIG_AsVal_int(obj1, &val2);
23445 if (!SWIG_IsOK(ecode2)) {
23446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23447 }
23448 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23449 }
23450 {
23451 PyThreadState* __tstate = wxPyBeginAllowThreads();
23452 result = wxDateTime::GetMonthName(arg1,arg2);
23453 wxPyEndAllowThreads(__tstate);
23454 if (PyErr_Occurred()) SWIG_fail;
23455 }
23456 {
23457 #if wxUSE_UNICODE
23458 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23459 #else
23460 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23461 #endif
23462 }
23463 return resultobj;
23464 fail:
23465 return NULL;
23466 }
23467
23468
23469 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23470 PyObject *resultobj = 0;
23471 wxDateTime::WeekDay arg1 ;
23472 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23473 wxString result;
23474 int val1 ;
23475 int ecode1 = 0 ;
23476 int val2 ;
23477 int ecode2 = 0 ;
23478 PyObject * obj0 = 0 ;
23479 PyObject * obj1 = 0 ;
23480 char * kwnames[] = {
23481 (char *) "weekday",(char *) "flags", NULL
23482 };
23483
23484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23485 ecode1 = SWIG_AsVal_int(obj0, &val1);
23486 if (!SWIG_IsOK(ecode1)) {
23487 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23488 }
23489 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23490 if (obj1) {
23491 ecode2 = SWIG_AsVal_int(obj1, &val2);
23492 if (!SWIG_IsOK(ecode2)) {
23493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23494 }
23495 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23496 }
23497 {
23498 PyThreadState* __tstate = wxPyBeginAllowThreads();
23499 result = wxDateTime::GetWeekDayName(arg1,arg2);
23500 wxPyEndAllowThreads(__tstate);
23501 if (PyErr_Occurred()) SWIG_fail;
23502 }
23503 {
23504 #if wxUSE_UNICODE
23505 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23506 #else
23507 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23508 #endif
23509 }
23510 return resultobj;
23511 fail:
23512 return NULL;
23513 }
23514
23515
23516 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23517 PyObject *resultobj = 0;
23518 PyObject *result = 0 ;
23519
23520 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23521 {
23522 PyThreadState* __tstate = wxPyBeginAllowThreads();
23523 result = (PyObject *)wxDateTime_GetAmPmStrings();
23524 wxPyEndAllowThreads(__tstate);
23525 if (PyErr_Occurred()) SWIG_fail;
23526 }
23527 resultobj = result;
23528 return resultobj;
23529 fail:
23530 return NULL;
23531 }
23532
23533
23534 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23535 PyObject *resultobj = 0;
23536 int arg1 = (int) wxDateTime::Inv_Year ;
23537 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23538 bool result;
23539 int val1 ;
23540 int ecode1 = 0 ;
23541 int val2 ;
23542 int ecode2 = 0 ;
23543 PyObject * obj0 = 0 ;
23544 PyObject * obj1 = 0 ;
23545 char * kwnames[] = {
23546 (char *) "year",(char *) "country", NULL
23547 };
23548
23549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23550 if (obj0) {
23551 ecode1 = SWIG_AsVal_int(obj0, &val1);
23552 if (!SWIG_IsOK(ecode1)) {
23553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23554 }
23555 arg1 = static_cast< int >(val1);
23556 }
23557 if (obj1) {
23558 ecode2 = SWIG_AsVal_int(obj1, &val2);
23559 if (!SWIG_IsOK(ecode2)) {
23560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23561 }
23562 arg2 = static_cast< wxDateTime::Country >(val2);
23563 }
23564 {
23565 PyThreadState* __tstate = wxPyBeginAllowThreads();
23566 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23567 wxPyEndAllowThreads(__tstate);
23568 if (PyErr_Occurred()) SWIG_fail;
23569 }
23570 {
23571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23572 }
23573 return resultobj;
23574 fail:
23575 return NULL;
23576 }
23577
23578
23579 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23580 PyObject *resultobj = 0;
23581 int arg1 = (int) wxDateTime::Inv_Year ;
23582 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23583 wxDateTime result;
23584 int val1 ;
23585 int ecode1 = 0 ;
23586 int val2 ;
23587 int ecode2 = 0 ;
23588 PyObject * obj0 = 0 ;
23589 PyObject * obj1 = 0 ;
23590 char * kwnames[] = {
23591 (char *) "year",(char *) "country", NULL
23592 };
23593
23594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23595 if (obj0) {
23596 ecode1 = SWIG_AsVal_int(obj0, &val1);
23597 if (!SWIG_IsOK(ecode1)) {
23598 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23599 }
23600 arg1 = static_cast< int >(val1);
23601 }
23602 if (obj1) {
23603 ecode2 = SWIG_AsVal_int(obj1, &val2);
23604 if (!SWIG_IsOK(ecode2)) {
23605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23606 }
23607 arg2 = static_cast< wxDateTime::Country >(val2);
23608 }
23609 {
23610 PyThreadState* __tstate = wxPyBeginAllowThreads();
23611 result = wxDateTime::GetBeginDST(arg1,arg2);
23612 wxPyEndAllowThreads(__tstate);
23613 if (PyErr_Occurred()) SWIG_fail;
23614 }
23615 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23616 return resultobj;
23617 fail:
23618 return NULL;
23619 }
23620
23621
23622 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23623 PyObject *resultobj = 0;
23624 int arg1 = (int) wxDateTime::Inv_Year ;
23625 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23626 wxDateTime result;
23627 int val1 ;
23628 int ecode1 = 0 ;
23629 int val2 ;
23630 int ecode2 = 0 ;
23631 PyObject * obj0 = 0 ;
23632 PyObject * obj1 = 0 ;
23633 char * kwnames[] = {
23634 (char *) "year",(char *) "country", NULL
23635 };
23636
23637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23638 if (obj0) {
23639 ecode1 = SWIG_AsVal_int(obj0, &val1);
23640 if (!SWIG_IsOK(ecode1)) {
23641 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23642 }
23643 arg1 = static_cast< int >(val1);
23644 }
23645 if (obj1) {
23646 ecode2 = SWIG_AsVal_int(obj1, &val2);
23647 if (!SWIG_IsOK(ecode2)) {
23648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23649 }
23650 arg2 = static_cast< wxDateTime::Country >(val2);
23651 }
23652 {
23653 PyThreadState* __tstate = wxPyBeginAllowThreads();
23654 result = wxDateTime::GetEndDST(arg1,arg2);
23655 wxPyEndAllowThreads(__tstate);
23656 if (PyErr_Occurred()) SWIG_fail;
23657 }
23658 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23659 return resultobj;
23660 fail:
23661 return NULL;
23662 }
23663
23664
23665 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23666 PyObject *resultobj = 0;
23667 wxDateTime result;
23668
23669 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23670 {
23671 PyThreadState* __tstate = wxPyBeginAllowThreads();
23672 result = wxDateTime::Now();
23673 wxPyEndAllowThreads(__tstate);
23674 if (PyErr_Occurred()) SWIG_fail;
23675 }
23676 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23677 return resultobj;
23678 fail:
23679 return NULL;
23680 }
23681
23682
23683 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23684 PyObject *resultobj = 0;
23685 wxDateTime result;
23686
23687 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23688 {
23689 PyThreadState* __tstate = wxPyBeginAllowThreads();
23690 result = wxDateTime::UNow();
23691 wxPyEndAllowThreads(__tstate);
23692 if (PyErr_Occurred()) SWIG_fail;
23693 }
23694 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23695 return resultobj;
23696 fail:
23697 return NULL;
23698 }
23699
23700
23701 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23702 PyObject *resultobj = 0;
23703 wxDateTime result;
23704
23705 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23706 {
23707 PyThreadState* __tstate = wxPyBeginAllowThreads();
23708 result = wxDateTime::Today();
23709 wxPyEndAllowThreads(__tstate);
23710 if (PyErr_Occurred()) SWIG_fail;
23711 }
23712 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23713 return resultobj;
23714 fail:
23715 return NULL;
23716 }
23717
23718
23719 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23720 PyObject *resultobj = 0;
23721 wxDateTime *result = 0 ;
23722
23723 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23724 {
23725 PyThreadState* __tstate = wxPyBeginAllowThreads();
23726 result = (wxDateTime *)new wxDateTime();
23727 wxPyEndAllowThreads(__tstate);
23728 if (PyErr_Occurred()) SWIG_fail;
23729 }
23730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23731 return resultobj;
23732 fail:
23733 return NULL;
23734 }
23735
23736
23737 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23738 PyObject *resultobj = 0;
23739 time_t arg1 ;
23740 wxDateTime *result = 0 ;
23741 unsigned int val1 ;
23742 int ecode1 = 0 ;
23743 PyObject * obj0 = 0 ;
23744 char * kwnames[] = {
23745 (char *) "timet", NULL
23746 };
23747
23748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23749 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23750 if (!SWIG_IsOK(ecode1)) {
23751 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23752 }
23753 arg1 = static_cast< time_t >(val1);
23754 {
23755 PyThreadState* __tstate = wxPyBeginAllowThreads();
23756 result = (wxDateTime *)new wxDateTime(arg1);
23757 wxPyEndAllowThreads(__tstate);
23758 if (PyErr_Occurred()) SWIG_fail;
23759 }
23760 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23761 return resultobj;
23762 fail:
23763 return NULL;
23764 }
23765
23766
23767 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23768 PyObject *resultobj = 0;
23769 double arg1 ;
23770 wxDateTime *result = 0 ;
23771 double val1 ;
23772 int ecode1 = 0 ;
23773 PyObject * obj0 = 0 ;
23774 char * kwnames[] = {
23775 (char *) "jdn", NULL
23776 };
23777
23778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23779 ecode1 = SWIG_AsVal_double(obj0, &val1);
23780 if (!SWIG_IsOK(ecode1)) {
23781 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23782 }
23783 arg1 = static_cast< double >(val1);
23784 {
23785 PyThreadState* __tstate = wxPyBeginAllowThreads();
23786 result = (wxDateTime *)new wxDateTime(arg1);
23787 wxPyEndAllowThreads(__tstate);
23788 if (PyErr_Occurred()) SWIG_fail;
23789 }
23790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23791 return resultobj;
23792 fail:
23793 return NULL;
23794 }
23795
23796
23797 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23798 PyObject *resultobj = 0;
23799 int arg1 ;
23800 int arg2 = (int) 0 ;
23801 int arg3 = (int) 0 ;
23802 int arg4 = (int) 0 ;
23803 wxDateTime *result = 0 ;
23804 int val1 ;
23805 int ecode1 = 0 ;
23806 int val2 ;
23807 int ecode2 = 0 ;
23808 int val3 ;
23809 int ecode3 = 0 ;
23810 int val4 ;
23811 int ecode4 = 0 ;
23812 PyObject * obj0 = 0 ;
23813 PyObject * obj1 = 0 ;
23814 PyObject * obj2 = 0 ;
23815 PyObject * obj3 = 0 ;
23816 char * kwnames[] = {
23817 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23818 };
23819
23820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23821 ecode1 = SWIG_AsVal_int(obj0, &val1);
23822 if (!SWIG_IsOK(ecode1)) {
23823 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23824 }
23825 arg1 = static_cast< int >(val1);
23826 if (obj1) {
23827 ecode2 = SWIG_AsVal_int(obj1, &val2);
23828 if (!SWIG_IsOK(ecode2)) {
23829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23830 }
23831 arg2 = static_cast< int >(val2);
23832 }
23833 if (obj2) {
23834 ecode3 = SWIG_AsVal_int(obj2, &val3);
23835 if (!SWIG_IsOK(ecode3)) {
23836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23837 }
23838 arg3 = static_cast< int >(val3);
23839 }
23840 if (obj3) {
23841 ecode4 = SWIG_AsVal_int(obj3, &val4);
23842 if (!SWIG_IsOK(ecode4)) {
23843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23844 }
23845 arg4 = static_cast< int >(val4);
23846 }
23847 {
23848 PyThreadState* __tstate = wxPyBeginAllowThreads();
23849 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23850 wxPyEndAllowThreads(__tstate);
23851 if (PyErr_Occurred()) SWIG_fail;
23852 }
23853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23854 return resultobj;
23855 fail:
23856 return NULL;
23857 }
23858
23859
23860 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23861 PyObject *resultobj = 0;
23862 int arg1 ;
23863 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23864 int arg3 = (int) wxDateTime::Inv_Year ;
23865 int arg4 = (int) 0 ;
23866 int arg5 = (int) 0 ;
23867 int arg6 = (int) 0 ;
23868 int arg7 = (int) 0 ;
23869 wxDateTime *result = 0 ;
23870 int val1 ;
23871 int ecode1 = 0 ;
23872 int val2 ;
23873 int ecode2 = 0 ;
23874 int val3 ;
23875 int ecode3 = 0 ;
23876 int val4 ;
23877 int ecode4 = 0 ;
23878 int val5 ;
23879 int ecode5 = 0 ;
23880 int val6 ;
23881 int ecode6 = 0 ;
23882 int val7 ;
23883 int ecode7 = 0 ;
23884 PyObject * obj0 = 0 ;
23885 PyObject * obj1 = 0 ;
23886 PyObject * obj2 = 0 ;
23887 PyObject * obj3 = 0 ;
23888 PyObject * obj4 = 0 ;
23889 PyObject * obj5 = 0 ;
23890 PyObject * obj6 = 0 ;
23891 char * kwnames[] = {
23892 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23893 };
23894
23895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23896 ecode1 = SWIG_AsVal_int(obj0, &val1);
23897 if (!SWIG_IsOK(ecode1)) {
23898 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23899 }
23900 arg1 = static_cast< int >(val1);
23901 if (obj1) {
23902 ecode2 = SWIG_AsVal_int(obj1, &val2);
23903 if (!SWIG_IsOK(ecode2)) {
23904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23905 }
23906 arg2 = static_cast< wxDateTime::Month >(val2);
23907 }
23908 if (obj2) {
23909 ecode3 = SWIG_AsVal_int(obj2, &val3);
23910 if (!SWIG_IsOK(ecode3)) {
23911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
23912 }
23913 arg3 = static_cast< int >(val3);
23914 }
23915 if (obj3) {
23916 ecode4 = SWIG_AsVal_int(obj3, &val4);
23917 if (!SWIG_IsOK(ecode4)) {
23918 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
23919 }
23920 arg4 = static_cast< int >(val4);
23921 }
23922 if (obj4) {
23923 ecode5 = SWIG_AsVal_int(obj4, &val5);
23924 if (!SWIG_IsOK(ecode5)) {
23925 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
23926 }
23927 arg5 = static_cast< int >(val5);
23928 }
23929 if (obj5) {
23930 ecode6 = SWIG_AsVal_int(obj5, &val6);
23931 if (!SWIG_IsOK(ecode6)) {
23932 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
23933 }
23934 arg6 = static_cast< int >(val6);
23935 }
23936 if (obj6) {
23937 ecode7 = SWIG_AsVal_int(obj6, &val7);
23938 if (!SWIG_IsOK(ecode7)) {
23939 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
23940 }
23941 arg7 = static_cast< int >(val7);
23942 }
23943 {
23944 PyThreadState* __tstate = wxPyBeginAllowThreads();
23945 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
23946 wxPyEndAllowThreads(__tstate);
23947 if (PyErr_Occurred()) SWIG_fail;
23948 }
23949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23950 return resultobj;
23951 fail:
23952 return NULL;
23953 }
23954
23955
23956 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23957 PyObject *resultobj = 0;
23958 wxDateTime *arg1 = 0 ;
23959 wxDateTime *result = 0 ;
23960 void *argp1 = 0 ;
23961 int res1 = 0 ;
23962 PyObject * obj0 = 0 ;
23963 char * kwnames[] = {
23964 (char *) "date", NULL
23965 };
23966
23967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
23968 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
23969 if (!SWIG_IsOK(res1)) {
23970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23971 }
23972 if (!argp1) {
23973 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23974 }
23975 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23976 {
23977 PyThreadState* __tstate = wxPyBeginAllowThreads();
23978 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
23979 wxPyEndAllowThreads(__tstate);
23980 if (PyErr_Occurred()) SWIG_fail;
23981 }
23982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23983 return resultobj;
23984 fail:
23985 return NULL;
23986 }
23987
23988
23989 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23990 PyObject *resultobj = 0;
23991 wxDateTime *arg1 = (wxDateTime *) 0 ;
23992 void *argp1 = 0 ;
23993 int res1 = 0 ;
23994 PyObject *swig_obj[1] ;
23995
23996 if (!args) SWIG_fail;
23997 swig_obj[0] = args;
23998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
23999 if (!SWIG_IsOK(res1)) {
24000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24001 }
24002 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24003 {
24004 PyThreadState* __tstate = wxPyBeginAllowThreads();
24005 delete arg1;
24006
24007 wxPyEndAllowThreads(__tstate);
24008 if (PyErr_Occurred()) SWIG_fail;
24009 }
24010 resultobj = SWIG_Py_Void();
24011 return resultobj;
24012 fail:
24013 return NULL;
24014 }
24015
24016
24017 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24018 PyObject *resultobj = 0;
24019 wxDateTime *arg1 = (wxDateTime *) 0 ;
24020 wxDateTime *result = 0 ;
24021 void *argp1 = 0 ;
24022 int res1 = 0 ;
24023 PyObject *swig_obj[1] ;
24024
24025 if (!args) SWIG_fail;
24026 swig_obj[0] = args;
24027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24028 if (!SWIG_IsOK(res1)) {
24029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24030 }
24031 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24032 {
24033 PyThreadState* __tstate = wxPyBeginAllowThreads();
24034 {
24035 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24036 result = (wxDateTime *) &_result_ref;
24037 }
24038 wxPyEndAllowThreads(__tstate);
24039 if (PyErr_Occurred()) SWIG_fail;
24040 }
24041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24042 return resultobj;
24043 fail:
24044 return NULL;
24045 }
24046
24047
24048 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24049 PyObject *resultobj = 0;
24050 wxDateTime *arg1 = (wxDateTime *) 0 ;
24051 time_t arg2 ;
24052 wxDateTime *result = 0 ;
24053 void *argp1 = 0 ;
24054 int res1 = 0 ;
24055 unsigned int val2 ;
24056 int ecode2 = 0 ;
24057 PyObject * obj0 = 0 ;
24058 PyObject * obj1 = 0 ;
24059 char * kwnames[] = {
24060 (char *) "self",(char *) "timet", NULL
24061 };
24062
24063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24065 if (!SWIG_IsOK(res1)) {
24066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24067 }
24068 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24069 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24070 if (!SWIG_IsOK(ecode2)) {
24071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24072 }
24073 arg2 = static_cast< time_t >(val2);
24074 {
24075 PyThreadState* __tstate = wxPyBeginAllowThreads();
24076 {
24077 wxDateTime &_result_ref = (arg1)->Set(arg2);
24078 result = (wxDateTime *) &_result_ref;
24079 }
24080 wxPyEndAllowThreads(__tstate);
24081 if (PyErr_Occurred()) SWIG_fail;
24082 }
24083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24084 return resultobj;
24085 fail:
24086 return NULL;
24087 }
24088
24089
24090 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24091 PyObject *resultobj = 0;
24092 wxDateTime *arg1 = (wxDateTime *) 0 ;
24093 double arg2 ;
24094 wxDateTime *result = 0 ;
24095 void *argp1 = 0 ;
24096 int res1 = 0 ;
24097 double val2 ;
24098 int ecode2 = 0 ;
24099 PyObject * obj0 = 0 ;
24100 PyObject * obj1 = 0 ;
24101 char * kwnames[] = {
24102 (char *) "self",(char *) "jdn", NULL
24103 };
24104
24105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24107 if (!SWIG_IsOK(res1)) {
24108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24109 }
24110 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24111 ecode2 = SWIG_AsVal_double(obj1, &val2);
24112 if (!SWIG_IsOK(ecode2)) {
24113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24114 }
24115 arg2 = static_cast< double >(val2);
24116 {
24117 PyThreadState* __tstate = wxPyBeginAllowThreads();
24118 {
24119 wxDateTime &_result_ref = (arg1)->Set(arg2);
24120 result = (wxDateTime *) &_result_ref;
24121 }
24122 wxPyEndAllowThreads(__tstate);
24123 if (PyErr_Occurred()) SWIG_fail;
24124 }
24125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24126 return resultobj;
24127 fail:
24128 return NULL;
24129 }
24130
24131
24132 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24133 PyObject *resultobj = 0;
24134 wxDateTime *arg1 = (wxDateTime *) 0 ;
24135 int arg2 ;
24136 int arg3 = (int) 0 ;
24137 int arg4 = (int) 0 ;
24138 int arg5 = (int) 0 ;
24139 wxDateTime *result = 0 ;
24140 void *argp1 = 0 ;
24141 int res1 = 0 ;
24142 int val2 ;
24143 int ecode2 = 0 ;
24144 int val3 ;
24145 int ecode3 = 0 ;
24146 int val4 ;
24147 int ecode4 = 0 ;
24148 int val5 ;
24149 int ecode5 = 0 ;
24150 PyObject * obj0 = 0 ;
24151 PyObject * obj1 = 0 ;
24152 PyObject * obj2 = 0 ;
24153 PyObject * obj3 = 0 ;
24154 PyObject * obj4 = 0 ;
24155 char * kwnames[] = {
24156 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24157 };
24158
24159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24161 if (!SWIG_IsOK(res1)) {
24162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24163 }
24164 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24165 ecode2 = SWIG_AsVal_int(obj1, &val2);
24166 if (!SWIG_IsOK(ecode2)) {
24167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24168 }
24169 arg2 = static_cast< int >(val2);
24170 if (obj2) {
24171 ecode3 = SWIG_AsVal_int(obj2, &val3);
24172 if (!SWIG_IsOK(ecode3)) {
24173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24174 }
24175 arg3 = static_cast< int >(val3);
24176 }
24177 if (obj3) {
24178 ecode4 = SWIG_AsVal_int(obj3, &val4);
24179 if (!SWIG_IsOK(ecode4)) {
24180 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24181 }
24182 arg4 = static_cast< int >(val4);
24183 }
24184 if (obj4) {
24185 ecode5 = SWIG_AsVal_int(obj4, &val5);
24186 if (!SWIG_IsOK(ecode5)) {
24187 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24188 }
24189 arg5 = static_cast< int >(val5);
24190 }
24191 {
24192 PyThreadState* __tstate = wxPyBeginAllowThreads();
24193 {
24194 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24195 result = (wxDateTime *) &_result_ref;
24196 }
24197 wxPyEndAllowThreads(__tstate);
24198 if (PyErr_Occurred()) SWIG_fail;
24199 }
24200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24201 return resultobj;
24202 fail:
24203 return NULL;
24204 }
24205
24206
24207 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24208 PyObject *resultobj = 0;
24209 wxDateTime *arg1 = (wxDateTime *) 0 ;
24210 int arg2 ;
24211 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24212 int arg4 = (int) wxDateTime::Inv_Year ;
24213 int arg5 = (int) 0 ;
24214 int arg6 = (int) 0 ;
24215 int arg7 = (int) 0 ;
24216 int arg8 = (int) 0 ;
24217 wxDateTime *result = 0 ;
24218 void *argp1 = 0 ;
24219 int res1 = 0 ;
24220 int val2 ;
24221 int ecode2 = 0 ;
24222 int val3 ;
24223 int ecode3 = 0 ;
24224 int val4 ;
24225 int ecode4 = 0 ;
24226 int val5 ;
24227 int ecode5 = 0 ;
24228 int val6 ;
24229 int ecode6 = 0 ;
24230 int val7 ;
24231 int ecode7 = 0 ;
24232 int val8 ;
24233 int ecode8 = 0 ;
24234 PyObject * obj0 = 0 ;
24235 PyObject * obj1 = 0 ;
24236 PyObject * obj2 = 0 ;
24237 PyObject * obj3 = 0 ;
24238 PyObject * obj4 = 0 ;
24239 PyObject * obj5 = 0 ;
24240 PyObject * obj6 = 0 ;
24241 PyObject * obj7 = 0 ;
24242 char * kwnames[] = {
24243 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24244 };
24245
24246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24248 if (!SWIG_IsOK(res1)) {
24249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24250 }
24251 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24252 ecode2 = SWIG_AsVal_int(obj1, &val2);
24253 if (!SWIG_IsOK(ecode2)) {
24254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24255 }
24256 arg2 = static_cast< int >(val2);
24257 if (obj2) {
24258 ecode3 = SWIG_AsVal_int(obj2, &val3);
24259 if (!SWIG_IsOK(ecode3)) {
24260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24261 }
24262 arg3 = static_cast< wxDateTime::Month >(val3);
24263 }
24264 if (obj3) {
24265 ecode4 = SWIG_AsVal_int(obj3, &val4);
24266 if (!SWIG_IsOK(ecode4)) {
24267 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24268 }
24269 arg4 = static_cast< int >(val4);
24270 }
24271 if (obj4) {
24272 ecode5 = SWIG_AsVal_int(obj4, &val5);
24273 if (!SWIG_IsOK(ecode5)) {
24274 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24275 }
24276 arg5 = static_cast< int >(val5);
24277 }
24278 if (obj5) {
24279 ecode6 = SWIG_AsVal_int(obj5, &val6);
24280 if (!SWIG_IsOK(ecode6)) {
24281 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24282 }
24283 arg6 = static_cast< int >(val6);
24284 }
24285 if (obj6) {
24286 ecode7 = SWIG_AsVal_int(obj6, &val7);
24287 if (!SWIG_IsOK(ecode7)) {
24288 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24289 }
24290 arg7 = static_cast< int >(val7);
24291 }
24292 if (obj7) {
24293 ecode8 = SWIG_AsVal_int(obj7, &val8);
24294 if (!SWIG_IsOK(ecode8)) {
24295 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24296 }
24297 arg8 = static_cast< int >(val8);
24298 }
24299 {
24300 PyThreadState* __tstate = wxPyBeginAllowThreads();
24301 {
24302 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24303 result = (wxDateTime *) &_result_ref;
24304 }
24305 wxPyEndAllowThreads(__tstate);
24306 if (PyErr_Occurred()) SWIG_fail;
24307 }
24308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24309 return resultobj;
24310 fail:
24311 return NULL;
24312 }
24313
24314
24315 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24316 PyObject *resultobj = 0;
24317 wxDateTime *arg1 = (wxDateTime *) 0 ;
24318 wxDateTime *result = 0 ;
24319 void *argp1 = 0 ;
24320 int res1 = 0 ;
24321 PyObject *swig_obj[1] ;
24322
24323 if (!args) SWIG_fail;
24324 swig_obj[0] = args;
24325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24326 if (!SWIG_IsOK(res1)) {
24327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24328 }
24329 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24330 {
24331 PyThreadState* __tstate = wxPyBeginAllowThreads();
24332 {
24333 wxDateTime &_result_ref = (arg1)->ResetTime();
24334 result = (wxDateTime *) &_result_ref;
24335 }
24336 wxPyEndAllowThreads(__tstate);
24337 if (PyErr_Occurred()) SWIG_fail;
24338 }
24339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24340 return resultobj;
24341 fail:
24342 return NULL;
24343 }
24344
24345
24346 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24347 PyObject *resultobj = 0;
24348 wxDateTime *arg1 = (wxDateTime *) 0 ;
24349 int arg2 ;
24350 wxDateTime *result = 0 ;
24351 void *argp1 = 0 ;
24352 int res1 = 0 ;
24353 int val2 ;
24354 int ecode2 = 0 ;
24355 PyObject * obj0 = 0 ;
24356 PyObject * obj1 = 0 ;
24357 char * kwnames[] = {
24358 (char *) "self",(char *) "year", NULL
24359 };
24360
24361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24363 if (!SWIG_IsOK(res1)) {
24364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24365 }
24366 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24367 ecode2 = SWIG_AsVal_int(obj1, &val2);
24368 if (!SWIG_IsOK(ecode2)) {
24369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24370 }
24371 arg2 = static_cast< int >(val2);
24372 {
24373 PyThreadState* __tstate = wxPyBeginAllowThreads();
24374 {
24375 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24376 result = (wxDateTime *) &_result_ref;
24377 }
24378 wxPyEndAllowThreads(__tstate);
24379 if (PyErr_Occurred()) SWIG_fail;
24380 }
24381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24382 return resultobj;
24383 fail:
24384 return NULL;
24385 }
24386
24387
24388 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24389 PyObject *resultobj = 0;
24390 wxDateTime *arg1 = (wxDateTime *) 0 ;
24391 wxDateTime::Month arg2 ;
24392 wxDateTime *result = 0 ;
24393 void *argp1 = 0 ;
24394 int res1 = 0 ;
24395 int val2 ;
24396 int ecode2 = 0 ;
24397 PyObject * obj0 = 0 ;
24398 PyObject * obj1 = 0 ;
24399 char * kwnames[] = {
24400 (char *) "self",(char *) "month", NULL
24401 };
24402
24403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24405 if (!SWIG_IsOK(res1)) {
24406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24407 }
24408 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24409 ecode2 = SWIG_AsVal_int(obj1, &val2);
24410 if (!SWIG_IsOK(ecode2)) {
24411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24412 }
24413 arg2 = static_cast< wxDateTime::Month >(val2);
24414 {
24415 PyThreadState* __tstate = wxPyBeginAllowThreads();
24416 {
24417 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24418 result = (wxDateTime *) &_result_ref;
24419 }
24420 wxPyEndAllowThreads(__tstate);
24421 if (PyErr_Occurred()) SWIG_fail;
24422 }
24423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24424 return resultobj;
24425 fail:
24426 return NULL;
24427 }
24428
24429
24430 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24431 PyObject *resultobj = 0;
24432 wxDateTime *arg1 = (wxDateTime *) 0 ;
24433 int arg2 ;
24434 wxDateTime *result = 0 ;
24435 void *argp1 = 0 ;
24436 int res1 = 0 ;
24437 int val2 ;
24438 int ecode2 = 0 ;
24439 PyObject * obj0 = 0 ;
24440 PyObject * obj1 = 0 ;
24441 char * kwnames[] = {
24442 (char *) "self",(char *) "day", NULL
24443 };
24444
24445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24447 if (!SWIG_IsOK(res1)) {
24448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24449 }
24450 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24451 ecode2 = SWIG_AsVal_int(obj1, &val2);
24452 if (!SWIG_IsOK(ecode2)) {
24453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24454 }
24455 arg2 = static_cast< int >(val2);
24456 {
24457 PyThreadState* __tstate = wxPyBeginAllowThreads();
24458 {
24459 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24460 result = (wxDateTime *) &_result_ref;
24461 }
24462 wxPyEndAllowThreads(__tstate);
24463 if (PyErr_Occurred()) SWIG_fail;
24464 }
24465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24466 return resultobj;
24467 fail:
24468 return NULL;
24469 }
24470
24471
24472 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24473 PyObject *resultobj = 0;
24474 wxDateTime *arg1 = (wxDateTime *) 0 ;
24475 int arg2 ;
24476 wxDateTime *result = 0 ;
24477 void *argp1 = 0 ;
24478 int res1 = 0 ;
24479 int val2 ;
24480 int ecode2 = 0 ;
24481 PyObject * obj0 = 0 ;
24482 PyObject * obj1 = 0 ;
24483 char * kwnames[] = {
24484 (char *) "self",(char *) "hour", NULL
24485 };
24486
24487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24489 if (!SWIG_IsOK(res1)) {
24490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24491 }
24492 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24493 ecode2 = SWIG_AsVal_int(obj1, &val2);
24494 if (!SWIG_IsOK(ecode2)) {
24495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24496 }
24497 arg2 = static_cast< int >(val2);
24498 {
24499 PyThreadState* __tstate = wxPyBeginAllowThreads();
24500 {
24501 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24502 result = (wxDateTime *) &_result_ref;
24503 }
24504 wxPyEndAllowThreads(__tstate);
24505 if (PyErr_Occurred()) SWIG_fail;
24506 }
24507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24508 return resultobj;
24509 fail:
24510 return NULL;
24511 }
24512
24513
24514 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24515 PyObject *resultobj = 0;
24516 wxDateTime *arg1 = (wxDateTime *) 0 ;
24517 int arg2 ;
24518 wxDateTime *result = 0 ;
24519 void *argp1 = 0 ;
24520 int res1 = 0 ;
24521 int val2 ;
24522 int ecode2 = 0 ;
24523 PyObject * obj0 = 0 ;
24524 PyObject * obj1 = 0 ;
24525 char * kwnames[] = {
24526 (char *) "self",(char *) "minute", NULL
24527 };
24528
24529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24531 if (!SWIG_IsOK(res1)) {
24532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24533 }
24534 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24535 ecode2 = SWIG_AsVal_int(obj1, &val2);
24536 if (!SWIG_IsOK(ecode2)) {
24537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24538 }
24539 arg2 = static_cast< int >(val2);
24540 {
24541 PyThreadState* __tstate = wxPyBeginAllowThreads();
24542 {
24543 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24544 result = (wxDateTime *) &_result_ref;
24545 }
24546 wxPyEndAllowThreads(__tstate);
24547 if (PyErr_Occurred()) SWIG_fail;
24548 }
24549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24550 return resultobj;
24551 fail:
24552 return NULL;
24553 }
24554
24555
24556 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24557 PyObject *resultobj = 0;
24558 wxDateTime *arg1 = (wxDateTime *) 0 ;
24559 int arg2 ;
24560 wxDateTime *result = 0 ;
24561 void *argp1 = 0 ;
24562 int res1 = 0 ;
24563 int val2 ;
24564 int ecode2 = 0 ;
24565 PyObject * obj0 = 0 ;
24566 PyObject * obj1 = 0 ;
24567 char * kwnames[] = {
24568 (char *) "self",(char *) "second", NULL
24569 };
24570
24571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24573 if (!SWIG_IsOK(res1)) {
24574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24575 }
24576 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24577 ecode2 = SWIG_AsVal_int(obj1, &val2);
24578 if (!SWIG_IsOK(ecode2)) {
24579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24580 }
24581 arg2 = static_cast< int >(val2);
24582 {
24583 PyThreadState* __tstate = wxPyBeginAllowThreads();
24584 {
24585 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24586 result = (wxDateTime *) &_result_ref;
24587 }
24588 wxPyEndAllowThreads(__tstate);
24589 if (PyErr_Occurred()) SWIG_fail;
24590 }
24591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24592 return resultobj;
24593 fail:
24594 return NULL;
24595 }
24596
24597
24598 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24599 PyObject *resultobj = 0;
24600 wxDateTime *arg1 = (wxDateTime *) 0 ;
24601 int arg2 ;
24602 wxDateTime *result = 0 ;
24603 void *argp1 = 0 ;
24604 int res1 = 0 ;
24605 int val2 ;
24606 int ecode2 = 0 ;
24607 PyObject * obj0 = 0 ;
24608 PyObject * obj1 = 0 ;
24609 char * kwnames[] = {
24610 (char *) "self",(char *) "millisecond", NULL
24611 };
24612
24613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24615 if (!SWIG_IsOK(res1)) {
24616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24617 }
24618 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24619 ecode2 = SWIG_AsVal_int(obj1, &val2);
24620 if (!SWIG_IsOK(ecode2)) {
24621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24622 }
24623 arg2 = static_cast< int >(val2);
24624 {
24625 PyThreadState* __tstate = wxPyBeginAllowThreads();
24626 {
24627 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24628 result = (wxDateTime *) &_result_ref;
24629 }
24630 wxPyEndAllowThreads(__tstate);
24631 if (PyErr_Occurred()) SWIG_fail;
24632 }
24633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24634 return resultobj;
24635 fail:
24636 return NULL;
24637 }
24638
24639
24640 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24641 PyObject *resultobj = 0;
24642 wxDateTime *arg1 = (wxDateTime *) 0 ;
24643 wxDateTime::WeekDay arg2 ;
24644 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24645 wxDateTime *result = 0 ;
24646 void *argp1 = 0 ;
24647 int res1 = 0 ;
24648 int val2 ;
24649 int ecode2 = 0 ;
24650 int val3 ;
24651 int ecode3 = 0 ;
24652 PyObject * obj0 = 0 ;
24653 PyObject * obj1 = 0 ;
24654 PyObject * obj2 = 0 ;
24655 char * kwnames[] = {
24656 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24657 };
24658
24659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24661 if (!SWIG_IsOK(res1)) {
24662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24663 }
24664 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24665 ecode2 = SWIG_AsVal_int(obj1, &val2);
24666 if (!SWIG_IsOK(ecode2)) {
24667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24668 }
24669 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24670 if (obj2) {
24671 ecode3 = SWIG_AsVal_int(obj2, &val3);
24672 if (!SWIG_IsOK(ecode3)) {
24673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24674 }
24675 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24676 }
24677 {
24678 PyThreadState* __tstate = wxPyBeginAllowThreads();
24679 {
24680 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24681 result = (wxDateTime *) &_result_ref;
24682 }
24683 wxPyEndAllowThreads(__tstate);
24684 if (PyErr_Occurred()) SWIG_fail;
24685 }
24686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24687 return resultobj;
24688 fail:
24689 return NULL;
24690 }
24691
24692
24693 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24694 PyObject *resultobj = 0;
24695 wxDateTime *arg1 = (wxDateTime *) 0 ;
24696 wxDateTime::WeekDay arg2 ;
24697 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24698 wxDateTime result;
24699 void *argp1 = 0 ;
24700 int res1 = 0 ;
24701 int val2 ;
24702 int ecode2 = 0 ;
24703 int val3 ;
24704 int ecode3 = 0 ;
24705 PyObject * obj0 = 0 ;
24706 PyObject * obj1 = 0 ;
24707 PyObject * obj2 = 0 ;
24708 char * kwnames[] = {
24709 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24710 };
24711
24712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24714 if (!SWIG_IsOK(res1)) {
24715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24716 }
24717 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24718 ecode2 = SWIG_AsVal_int(obj1, &val2);
24719 if (!SWIG_IsOK(ecode2)) {
24720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24721 }
24722 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24723 if (obj2) {
24724 ecode3 = SWIG_AsVal_int(obj2, &val3);
24725 if (!SWIG_IsOK(ecode3)) {
24726 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24727 }
24728 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24729 }
24730 {
24731 PyThreadState* __tstate = wxPyBeginAllowThreads();
24732 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24733 wxPyEndAllowThreads(__tstate);
24734 if (PyErr_Occurred()) SWIG_fail;
24735 }
24736 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24737 return resultobj;
24738 fail:
24739 return NULL;
24740 }
24741
24742
24743 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24744 PyObject *resultobj = 0;
24745 wxDateTime *arg1 = (wxDateTime *) 0 ;
24746 wxDateTime::WeekDay arg2 ;
24747 wxDateTime *result = 0 ;
24748 void *argp1 = 0 ;
24749 int res1 = 0 ;
24750 int val2 ;
24751 int ecode2 = 0 ;
24752 PyObject * obj0 = 0 ;
24753 PyObject * obj1 = 0 ;
24754 char * kwnames[] = {
24755 (char *) "self",(char *) "weekday", NULL
24756 };
24757
24758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24760 if (!SWIG_IsOK(res1)) {
24761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24762 }
24763 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24764 ecode2 = SWIG_AsVal_int(obj1, &val2);
24765 if (!SWIG_IsOK(ecode2)) {
24766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24767 }
24768 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24769 {
24770 PyThreadState* __tstate = wxPyBeginAllowThreads();
24771 {
24772 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24773 result = (wxDateTime *) &_result_ref;
24774 }
24775 wxPyEndAllowThreads(__tstate);
24776 if (PyErr_Occurred()) SWIG_fail;
24777 }
24778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24779 return resultobj;
24780 fail:
24781 return NULL;
24782 }
24783
24784
24785 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24786 PyObject *resultobj = 0;
24787 wxDateTime *arg1 = (wxDateTime *) 0 ;
24788 wxDateTime::WeekDay arg2 ;
24789 wxDateTime result;
24790 void *argp1 = 0 ;
24791 int res1 = 0 ;
24792 int val2 ;
24793 int ecode2 = 0 ;
24794 PyObject * obj0 = 0 ;
24795 PyObject * obj1 = 0 ;
24796 char * kwnames[] = {
24797 (char *) "self",(char *) "weekday", NULL
24798 };
24799
24800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24802 if (!SWIG_IsOK(res1)) {
24803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24804 }
24805 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24806 ecode2 = SWIG_AsVal_int(obj1, &val2);
24807 if (!SWIG_IsOK(ecode2)) {
24808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24809 }
24810 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24811 {
24812 PyThreadState* __tstate = wxPyBeginAllowThreads();
24813 result = (arg1)->GetNextWeekDay(arg2);
24814 wxPyEndAllowThreads(__tstate);
24815 if (PyErr_Occurred()) SWIG_fail;
24816 }
24817 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24818 return resultobj;
24819 fail:
24820 return NULL;
24821 }
24822
24823
24824 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24825 PyObject *resultobj = 0;
24826 wxDateTime *arg1 = (wxDateTime *) 0 ;
24827 wxDateTime::WeekDay arg2 ;
24828 wxDateTime *result = 0 ;
24829 void *argp1 = 0 ;
24830 int res1 = 0 ;
24831 int val2 ;
24832 int ecode2 = 0 ;
24833 PyObject * obj0 = 0 ;
24834 PyObject * obj1 = 0 ;
24835 char * kwnames[] = {
24836 (char *) "self",(char *) "weekday", NULL
24837 };
24838
24839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24841 if (!SWIG_IsOK(res1)) {
24842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24843 }
24844 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24845 ecode2 = SWIG_AsVal_int(obj1, &val2);
24846 if (!SWIG_IsOK(ecode2)) {
24847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24848 }
24849 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24850 {
24851 PyThreadState* __tstate = wxPyBeginAllowThreads();
24852 {
24853 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24854 result = (wxDateTime *) &_result_ref;
24855 }
24856 wxPyEndAllowThreads(__tstate);
24857 if (PyErr_Occurred()) SWIG_fail;
24858 }
24859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24860 return resultobj;
24861 fail:
24862 return NULL;
24863 }
24864
24865
24866 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24867 PyObject *resultobj = 0;
24868 wxDateTime *arg1 = (wxDateTime *) 0 ;
24869 wxDateTime::WeekDay arg2 ;
24870 wxDateTime result;
24871 void *argp1 = 0 ;
24872 int res1 = 0 ;
24873 int val2 ;
24874 int ecode2 = 0 ;
24875 PyObject * obj0 = 0 ;
24876 PyObject * obj1 = 0 ;
24877 char * kwnames[] = {
24878 (char *) "self",(char *) "weekday", NULL
24879 };
24880
24881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24883 if (!SWIG_IsOK(res1)) {
24884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24885 }
24886 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24887 ecode2 = SWIG_AsVal_int(obj1, &val2);
24888 if (!SWIG_IsOK(ecode2)) {
24889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24890 }
24891 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24892 {
24893 PyThreadState* __tstate = wxPyBeginAllowThreads();
24894 result = (arg1)->GetPrevWeekDay(arg2);
24895 wxPyEndAllowThreads(__tstate);
24896 if (PyErr_Occurred()) SWIG_fail;
24897 }
24898 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24899 return resultobj;
24900 fail:
24901 return NULL;
24902 }
24903
24904
24905 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24906 PyObject *resultobj = 0;
24907 wxDateTime *arg1 = (wxDateTime *) 0 ;
24908 wxDateTime::WeekDay arg2 ;
24909 int arg3 = (int) 1 ;
24910 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24911 int arg5 = (int) wxDateTime::Inv_Year ;
24912 bool result;
24913 void *argp1 = 0 ;
24914 int res1 = 0 ;
24915 int val2 ;
24916 int ecode2 = 0 ;
24917 int val3 ;
24918 int ecode3 = 0 ;
24919 int val4 ;
24920 int ecode4 = 0 ;
24921 int val5 ;
24922 int ecode5 = 0 ;
24923 PyObject * obj0 = 0 ;
24924 PyObject * obj1 = 0 ;
24925 PyObject * obj2 = 0 ;
24926 PyObject * obj3 = 0 ;
24927 PyObject * obj4 = 0 ;
24928 char * kwnames[] = {
24929 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
24930 };
24931
24932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24934 if (!SWIG_IsOK(res1)) {
24935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24936 }
24937 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24938 ecode2 = SWIG_AsVal_int(obj1, &val2);
24939 if (!SWIG_IsOK(ecode2)) {
24940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24941 }
24942 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24943 if (obj2) {
24944 ecode3 = SWIG_AsVal_int(obj2, &val3);
24945 if (!SWIG_IsOK(ecode3)) {
24946 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
24947 }
24948 arg3 = static_cast< int >(val3);
24949 }
24950 if (obj3) {
24951 ecode4 = SWIG_AsVal_int(obj3, &val4);
24952 if (!SWIG_IsOK(ecode4)) {
24953 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
24954 }
24955 arg4 = static_cast< wxDateTime::Month >(val4);
24956 }
24957 if (obj4) {
24958 ecode5 = SWIG_AsVal_int(obj4, &val5);
24959 if (!SWIG_IsOK(ecode5)) {
24960 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
24961 }
24962 arg5 = static_cast< int >(val5);
24963 }
24964 {
24965 PyThreadState* __tstate = wxPyBeginAllowThreads();
24966 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
24967 wxPyEndAllowThreads(__tstate);
24968 if (PyErr_Occurred()) SWIG_fail;
24969 }
24970 {
24971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24972 }
24973 return resultobj;
24974 fail:
24975 return NULL;
24976 }
24977
24978
24979 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24980 PyObject *resultobj = 0;
24981 wxDateTime *arg1 = (wxDateTime *) 0 ;
24982 wxDateTime::WeekDay arg2 ;
24983 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24984 int arg4 = (int) wxDateTime::Inv_Year ;
24985 bool result;
24986 void *argp1 = 0 ;
24987 int res1 = 0 ;
24988 int val2 ;
24989 int ecode2 = 0 ;
24990 int val3 ;
24991 int ecode3 = 0 ;
24992 int val4 ;
24993 int ecode4 = 0 ;
24994 PyObject * obj0 = 0 ;
24995 PyObject * obj1 = 0 ;
24996 PyObject * obj2 = 0 ;
24997 PyObject * obj3 = 0 ;
24998 char * kwnames[] = {
24999 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25000 };
25001
25002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25004 if (!SWIG_IsOK(res1)) {
25005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25006 }
25007 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25008 ecode2 = SWIG_AsVal_int(obj1, &val2);
25009 if (!SWIG_IsOK(ecode2)) {
25010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25011 }
25012 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25013 if (obj2) {
25014 ecode3 = SWIG_AsVal_int(obj2, &val3);
25015 if (!SWIG_IsOK(ecode3)) {
25016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25017 }
25018 arg3 = static_cast< wxDateTime::Month >(val3);
25019 }
25020 if (obj3) {
25021 ecode4 = SWIG_AsVal_int(obj3, &val4);
25022 if (!SWIG_IsOK(ecode4)) {
25023 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25024 }
25025 arg4 = static_cast< int >(val4);
25026 }
25027 {
25028 PyThreadState* __tstate = wxPyBeginAllowThreads();
25029 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25030 wxPyEndAllowThreads(__tstate);
25031 if (PyErr_Occurred()) SWIG_fail;
25032 }
25033 {
25034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25035 }
25036 return resultobj;
25037 fail:
25038 return NULL;
25039 }
25040
25041
25042 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25043 PyObject *resultobj = 0;
25044 wxDateTime *arg1 = (wxDateTime *) 0 ;
25045 wxDateTime::WeekDay arg2 ;
25046 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25047 int arg4 = (int) wxDateTime::Inv_Year ;
25048 wxDateTime result;
25049 void *argp1 = 0 ;
25050 int res1 = 0 ;
25051 int val2 ;
25052 int ecode2 = 0 ;
25053 int val3 ;
25054 int ecode3 = 0 ;
25055 int val4 ;
25056 int ecode4 = 0 ;
25057 PyObject * obj0 = 0 ;
25058 PyObject * obj1 = 0 ;
25059 PyObject * obj2 = 0 ;
25060 PyObject * obj3 = 0 ;
25061 char * kwnames[] = {
25062 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25063 };
25064
25065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25067 if (!SWIG_IsOK(res1)) {
25068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25069 }
25070 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25071 ecode2 = SWIG_AsVal_int(obj1, &val2);
25072 if (!SWIG_IsOK(ecode2)) {
25073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25074 }
25075 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25076 if (obj2) {
25077 ecode3 = SWIG_AsVal_int(obj2, &val3);
25078 if (!SWIG_IsOK(ecode3)) {
25079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25080 }
25081 arg3 = static_cast< wxDateTime::Month >(val3);
25082 }
25083 if (obj3) {
25084 ecode4 = SWIG_AsVal_int(obj3, &val4);
25085 if (!SWIG_IsOK(ecode4)) {
25086 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25087 }
25088 arg4 = static_cast< int >(val4);
25089 }
25090 {
25091 PyThreadState* __tstate = wxPyBeginAllowThreads();
25092 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25093 wxPyEndAllowThreads(__tstate);
25094 if (PyErr_Occurred()) SWIG_fail;
25095 }
25096 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25097 return resultobj;
25098 fail:
25099 return NULL;
25100 }
25101
25102
25103 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25104 PyObject *resultobj = 0;
25105 wxDateTime *arg1 = (wxDateTime *) 0 ;
25106 int arg2 ;
25107 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25108 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25109 bool result;
25110 void *argp1 = 0 ;
25111 int res1 = 0 ;
25112 int val2 ;
25113 int ecode2 = 0 ;
25114 int val3 ;
25115 int ecode3 = 0 ;
25116 int val4 ;
25117 int ecode4 = 0 ;
25118 PyObject * obj0 = 0 ;
25119 PyObject * obj1 = 0 ;
25120 PyObject * obj2 = 0 ;
25121 PyObject * obj3 = 0 ;
25122 char * kwnames[] = {
25123 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25124 };
25125
25126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25128 if (!SWIG_IsOK(res1)) {
25129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25130 }
25131 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25132 ecode2 = SWIG_AsVal_int(obj1, &val2);
25133 if (!SWIG_IsOK(ecode2)) {
25134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25135 }
25136 arg2 = static_cast< int >(val2);
25137 if (obj2) {
25138 ecode3 = SWIG_AsVal_int(obj2, &val3);
25139 if (!SWIG_IsOK(ecode3)) {
25140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25141 }
25142 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25143 }
25144 if (obj3) {
25145 ecode4 = SWIG_AsVal_int(obj3, &val4);
25146 if (!SWIG_IsOK(ecode4)) {
25147 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25148 }
25149 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25150 }
25151 {
25152 PyThreadState* __tstate = wxPyBeginAllowThreads();
25153 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25154 wxPyEndAllowThreads(__tstate);
25155 if (PyErr_Occurred()) SWIG_fail;
25156 }
25157 {
25158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25159 }
25160 return resultobj;
25161 fail:
25162 return NULL;
25163 }
25164
25165
25166 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25167 PyObject *resultobj = 0;
25168 wxDateTime *arg1 = (wxDateTime *) 0 ;
25169 int arg2 ;
25170 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25171 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25172 wxDateTime result;
25173 void *argp1 = 0 ;
25174 int res1 = 0 ;
25175 int val2 ;
25176 int ecode2 = 0 ;
25177 int val3 ;
25178 int ecode3 = 0 ;
25179 int val4 ;
25180 int ecode4 = 0 ;
25181 PyObject * obj0 = 0 ;
25182 PyObject * obj1 = 0 ;
25183 PyObject * obj2 = 0 ;
25184 PyObject * obj3 = 0 ;
25185 char * kwnames[] = {
25186 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25187 };
25188
25189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25191 if (!SWIG_IsOK(res1)) {
25192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25193 }
25194 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25195 ecode2 = SWIG_AsVal_int(obj1, &val2);
25196 if (!SWIG_IsOK(ecode2)) {
25197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25198 }
25199 arg2 = static_cast< int >(val2);
25200 if (obj2) {
25201 ecode3 = SWIG_AsVal_int(obj2, &val3);
25202 if (!SWIG_IsOK(ecode3)) {
25203 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25204 }
25205 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25206 }
25207 if (obj3) {
25208 ecode4 = SWIG_AsVal_int(obj3, &val4);
25209 if (!SWIG_IsOK(ecode4)) {
25210 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25211 }
25212 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25213 }
25214 {
25215 PyThreadState* __tstate = wxPyBeginAllowThreads();
25216 result = (arg1)->GetWeek(arg2,arg3,arg4);
25217 wxPyEndAllowThreads(__tstate);
25218 if (PyErr_Occurred()) SWIG_fail;
25219 }
25220 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25221 return resultobj;
25222 fail:
25223 return NULL;
25224 }
25225
25226
25227 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25228 PyObject *resultobj = 0;
25229 int arg1 ;
25230 int arg2 ;
25231 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25232 wxDateTime result;
25233 int val1 ;
25234 int ecode1 = 0 ;
25235 int val2 ;
25236 int ecode2 = 0 ;
25237 int val3 ;
25238 int ecode3 = 0 ;
25239 PyObject * obj0 = 0 ;
25240 PyObject * obj1 = 0 ;
25241 PyObject * obj2 = 0 ;
25242 char * kwnames[] = {
25243 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25244 };
25245
25246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25247 ecode1 = SWIG_AsVal_int(obj0, &val1);
25248 if (!SWIG_IsOK(ecode1)) {
25249 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25250 }
25251 arg1 = static_cast< int >(val1);
25252 ecode2 = SWIG_AsVal_int(obj1, &val2);
25253 if (!SWIG_IsOK(ecode2)) {
25254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25255 }
25256 arg2 = static_cast< int >(val2);
25257 if (obj2) {
25258 ecode3 = SWIG_AsVal_int(obj2, &val3);
25259 if (!SWIG_IsOK(ecode3)) {
25260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25261 }
25262 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25263 }
25264 {
25265 PyThreadState* __tstate = wxPyBeginAllowThreads();
25266 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25267 wxPyEndAllowThreads(__tstate);
25268 if (PyErr_Occurred()) SWIG_fail;
25269 }
25270 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25271 return resultobj;
25272 fail:
25273 return NULL;
25274 }
25275
25276
25277 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25278 PyObject *resultobj = 0;
25279 wxDateTime *arg1 = (wxDateTime *) 0 ;
25280 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25281 int arg3 = (int) wxDateTime::Inv_Year ;
25282 wxDateTime *result = 0 ;
25283 void *argp1 = 0 ;
25284 int res1 = 0 ;
25285 int val2 ;
25286 int ecode2 = 0 ;
25287 int val3 ;
25288 int ecode3 = 0 ;
25289 PyObject * obj0 = 0 ;
25290 PyObject * obj1 = 0 ;
25291 PyObject * obj2 = 0 ;
25292 char * kwnames[] = {
25293 (char *) "self",(char *) "month",(char *) "year", NULL
25294 };
25295
25296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25298 if (!SWIG_IsOK(res1)) {
25299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25300 }
25301 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25302 if (obj1) {
25303 ecode2 = SWIG_AsVal_int(obj1, &val2);
25304 if (!SWIG_IsOK(ecode2)) {
25305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25306 }
25307 arg2 = static_cast< wxDateTime::Month >(val2);
25308 }
25309 if (obj2) {
25310 ecode3 = SWIG_AsVal_int(obj2, &val3);
25311 if (!SWIG_IsOK(ecode3)) {
25312 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25313 }
25314 arg3 = static_cast< int >(val3);
25315 }
25316 {
25317 PyThreadState* __tstate = wxPyBeginAllowThreads();
25318 {
25319 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25320 result = (wxDateTime *) &_result_ref;
25321 }
25322 wxPyEndAllowThreads(__tstate);
25323 if (PyErr_Occurred()) SWIG_fail;
25324 }
25325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25326 return resultobj;
25327 fail:
25328 return NULL;
25329 }
25330
25331
25332 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25333 PyObject *resultobj = 0;
25334 wxDateTime *arg1 = (wxDateTime *) 0 ;
25335 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25336 int arg3 = (int) wxDateTime::Inv_Year ;
25337 wxDateTime result;
25338 void *argp1 = 0 ;
25339 int res1 = 0 ;
25340 int val2 ;
25341 int ecode2 = 0 ;
25342 int val3 ;
25343 int ecode3 = 0 ;
25344 PyObject * obj0 = 0 ;
25345 PyObject * obj1 = 0 ;
25346 PyObject * obj2 = 0 ;
25347 char * kwnames[] = {
25348 (char *) "self",(char *) "month",(char *) "year", NULL
25349 };
25350
25351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25353 if (!SWIG_IsOK(res1)) {
25354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25355 }
25356 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25357 if (obj1) {
25358 ecode2 = SWIG_AsVal_int(obj1, &val2);
25359 if (!SWIG_IsOK(ecode2)) {
25360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25361 }
25362 arg2 = static_cast< wxDateTime::Month >(val2);
25363 }
25364 if (obj2) {
25365 ecode3 = SWIG_AsVal_int(obj2, &val3);
25366 if (!SWIG_IsOK(ecode3)) {
25367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25368 }
25369 arg3 = static_cast< int >(val3);
25370 }
25371 {
25372 PyThreadState* __tstate = wxPyBeginAllowThreads();
25373 result = (arg1)->GetLastMonthDay(arg2,arg3);
25374 wxPyEndAllowThreads(__tstate);
25375 if (PyErr_Occurred()) SWIG_fail;
25376 }
25377 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25378 return resultobj;
25379 fail:
25380 return NULL;
25381 }
25382
25383
25384 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25385 PyObject *resultobj = 0;
25386 wxDateTime *arg1 = (wxDateTime *) 0 ;
25387 int arg2 ;
25388 wxDateTime *result = 0 ;
25389 void *argp1 = 0 ;
25390 int res1 = 0 ;
25391 int val2 ;
25392 int ecode2 = 0 ;
25393 PyObject * obj0 = 0 ;
25394 PyObject * obj1 = 0 ;
25395 char * kwnames[] = {
25396 (char *) "self",(char *) "yday", NULL
25397 };
25398
25399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25401 if (!SWIG_IsOK(res1)) {
25402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25403 }
25404 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25405 ecode2 = SWIG_AsVal_int(obj1, &val2);
25406 if (!SWIG_IsOK(ecode2)) {
25407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25408 }
25409 arg2 = static_cast< int >(val2);
25410 {
25411 PyThreadState* __tstate = wxPyBeginAllowThreads();
25412 {
25413 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25414 result = (wxDateTime *) &_result_ref;
25415 }
25416 wxPyEndAllowThreads(__tstate);
25417 if (PyErr_Occurred()) SWIG_fail;
25418 }
25419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25420 return resultobj;
25421 fail:
25422 return NULL;
25423 }
25424
25425
25426 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25427 PyObject *resultobj = 0;
25428 wxDateTime *arg1 = (wxDateTime *) 0 ;
25429 int arg2 ;
25430 wxDateTime result;
25431 void *argp1 = 0 ;
25432 int res1 = 0 ;
25433 int val2 ;
25434 int ecode2 = 0 ;
25435 PyObject * obj0 = 0 ;
25436 PyObject * obj1 = 0 ;
25437 char * kwnames[] = {
25438 (char *) "self",(char *) "yday", NULL
25439 };
25440
25441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25443 if (!SWIG_IsOK(res1)) {
25444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25445 }
25446 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25447 ecode2 = SWIG_AsVal_int(obj1, &val2);
25448 if (!SWIG_IsOK(ecode2)) {
25449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25450 }
25451 arg2 = static_cast< int >(val2);
25452 {
25453 PyThreadState* __tstate = wxPyBeginAllowThreads();
25454 result = (arg1)->GetYearDay(arg2);
25455 wxPyEndAllowThreads(__tstate);
25456 if (PyErr_Occurred()) SWIG_fail;
25457 }
25458 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25459 return resultobj;
25460 fail:
25461 return NULL;
25462 }
25463
25464
25465 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25466 PyObject *resultobj = 0;
25467 wxDateTime *arg1 = (wxDateTime *) 0 ;
25468 double result;
25469 void *argp1 = 0 ;
25470 int res1 = 0 ;
25471 PyObject *swig_obj[1] ;
25472
25473 if (!args) SWIG_fail;
25474 swig_obj[0] = args;
25475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25476 if (!SWIG_IsOK(res1)) {
25477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25478 }
25479 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25480 {
25481 PyThreadState* __tstate = wxPyBeginAllowThreads();
25482 result = (double)(arg1)->GetJulianDayNumber();
25483 wxPyEndAllowThreads(__tstate);
25484 if (PyErr_Occurred()) SWIG_fail;
25485 }
25486 resultobj = SWIG_From_double(static_cast< double >(result));
25487 return resultobj;
25488 fail:
25489 return NULL;
25490 }
25491
25492
25493 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25494 PyObject *resultobj = 0;
25495 wxDateTime *arg1 = (wxDateTime *) 0 ;
25496 double result;
25497 void *argp1 = 0 ;
25498 int res1 = 0 ;
25499 PyObject *swig_obj[1] ;
25500
25501 if (!args) SWIG_fail;
25502 swig_obj[0] = args;
25503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25504 if (!SWIG_IsOK(res1)) {
25505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25506 }
25507 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25508 {
25509 PyThreadState* __tstate = wxPyBeginAllowThreads();
25510 result = (double)(arg1)->GetJDN();
25511 wxPyEndAllowThreads(__tstate);
25512 if (PyErr_Occurred()) SWIG_fail;
25513 }
25514 resultobj = SWIG_From_double(static_cast< double >(result));
25515 return resultobj;
25516 fail:
25517 return NULL;
25518 }
25519
25520
25521 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25522 PyObject *resultobj = 0;
25523 wxDateTime *arg1 = (wxDateTime *) 0 ;
25524 double result;
25525 void *argp1 = 0 ;
25526 int res1 = 0 ;
25527 PyObject *swig_obj[1] ;
25528
25529 if (!args) SWIG_fail;
25530 swig_obj[0] = args;
25531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25532 if (!SWIG_IsOK(res1)) {
25533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25534 }
25535 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25536 {
25537 PyThreadState* __tstate = wxPyBeginAllowThreads();
25538 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25539 wxPyEndAllowThreads(__tstate);
25540 if (PyErr_Occurred()) SWIG_fail;
25541 }
25542 resultobj = SWIG_From_double(static_cast< double >(result));
25543 return resultobj;
25544 fail:
25545 return NULL;
25546 }
25547
25548
25549 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25550 PyObject *resultobj = 0;
25551 wxDateTime *arg1 = (wxDateTime *) 0 ;
25552 double result;
25553 void *argp1 = 0 ;
25554 int res1 = 0 ;
25555 PyObject *swig_obj[1] ;
25556
25557 if (!args) SWIG_fail;
25558 swig_obj[0] = args;
25559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25560 if (!SWIG_IsOK(res1)) {
25561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25562 }
25563 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25564 {
25565 PyThreadState* __tstate = wxPyBeginAllowThreads();
25566 result = (double)(arg1)->GetMJD();
25567 wxPyEndAllowThreads(__tstate);
25568 if (PyErr_Occurred()) SWIG_fail;
25569 }
25570 resultobj = SWIG_From_double(static_cast< double >(result));
25571 return resultobj;
25572 fail:
25573 return NULL;
25574 }
25575
25576
25577 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25578 PyObject *resultobj = 0;
25579 wxDateTime *arg1 = (wxDateTime *) 0 ;
25580 double result;
25581 void *argp1 = 0 ;
25582 int res1 = 0 ;
25583 PyObject *swig_obj[1] ;
25584
25585 if (!args) SWIG_fail;
25586 swig_obj[0] = args;
25587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25588 if (!SWIG_IsOK(res1)) {
25589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25590 }
25591 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25592 {
25593 PyThreadState* __tstate = wxPyBeginAllowThreads();
25594 result = (double)(arg1)->GetRataDie();
25595 wxPyEndAllowThreads(__tstate);
25596 if (PyErr_Occurred()) SWIG_fail;
25597 }
25598 resultobj = SWIG_From_double(static_cast< double >(result));
25599 return resultobj;
25600 fail:
25601 return NULL;
25602 }
25603
25604
25605 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25606 PyObject *resultobj = 0;
25607 wxDateTime *arg1 = (wxDateTime *) 0 ;
25608 wxDateTime::TimeZone *arg2 = 0 ;
25609 bool arg3 = (bool) false ;
25610 wxDateTime result;
25611 void *argp1 = 0 ;
25612 int res1 = 0 ;
25613 bool temp2 = false ;
25614 bool val3 ;
25615 int ecode3 = 0 ;
25616 PyObject * obj0 = 0 ;
25617 PyObject * obj1 = 0 ;
25618 PyObject * obj2 = 0 ;
25619 char * kwnames[] = {
25620 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25621 };
25622
25623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25625 if (!SWIG_IsOK(res1)) {
25626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25627 }
25628 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25629 {
25630 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25631 temp2 = true;
25632 }
25633 if (obj2) {
25634 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25635 if (!SWIG_IsOK(ecode3)) {
25636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25637 }
25638 arg3 = static_cast< bool >(val3);
25639 }
25640 {
25641 PyThreadState* __tstate = wxPyBeginAllowThreads();
25642 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25643 wxPyEndAllowThreads(__tstate);
25644 if (PyErr_Occurred()) SWIG_fail;
25645 }
25646 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25647 {
25648 if (temp2) delete arg2;
25649 }
25650 return resultobj;
25651 fail:
25652 {
25653 if (temp2) delete arg2;
25654 }
25655 return NULL;
25656 }
25657
25658
25659 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25660 PyObject *resultobj = 0;
25661 wxDateTime *arg1 = (wxDateTime *) 0 ;
25662 wxDateTime::TimeZone *arg2 = 0 ;
25663 bool arg3 = (bool) false ;
25664 wxDateTime *result = 0 ;
25665 void *argp1 = 0 ;
25666 int res1 = 0 ;
25667 bool temp2 = false ;
25668 bool val3 ;
25669 int ecode3 = 0 ;
25670 PyObject * obj0 = 0 ;
25671 PyObject * obj1 = 0 ;
25672 PyObject * obj2 = 0 ;
25673 char * kwnames[] = {
25674 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25675 };
25676
25677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25679 if (!SWIG_IsOK(res1)) {
25680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25681 }
25682 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25683 {
25684 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25685 temp2 = true;
25686 }
25687 if (obj2) {
25688 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25689 if (!SWIG_IsOK(ecode3)) {
25690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25691 }
25692 arg3 = static_cast< bool >(val3);
25693 }
25694 {
25695 PyThreadState* __tstate = wxPyBeginAllowThreads();
25696 {
25697 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25698 result = (wxDateTime *) &_result_ref;
25699 }
25700 wxPyEndAllowThreads(__tstate);
25701 if (PyErr_Occurred()) SWIG_fail;
25702 }
25703 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25704 {
25705 if (temp2) delete arg2;
25706 }
25707 return resultobj;
25708 fail:
25709 {
25710 if (temp2) delete arg2;
25711 }
25712 return NULL;
25713 }
25714
25715
25716 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25717 PyObject *resultobj = 0;
25718 wxDateTime *arg1 = (wxDateTime *) 0 ;
25719 wxDateTime::TimeZone *arg2 = 0 ;
25720 bool arg3 = (bool) false ;
25721 wxDateTime result;
25722 void *argp1 = 0 ;
25723 int res1 = 0 ;
25724 bool temp2 = false ;
25725 bool val3 ;
25726 int ecode3 = 0 ;
25727 PyObject * obj0 = 0 ;
25728 PyObject * obj1 = 0 ;
25729 PyObject * obj2 = 0 ;
25730 char * kwnames[] = {
25731 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25732 };
25733
25734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25736 if (!SWIG_IsOK(res1)) {
25737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25738 }
25739 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25740 {
25741 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25742 temp2 = true;
25743 }
25744 if (obj2) {
25745 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25746 if (!SWIG_IsOK(ecode3)) {
25747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25748 }
25749 arg3 = static_cast< bool >(val3);
25750 }
25751 {
25752 PyThreadState* __tstate = wxPyBeginAllowThreads();
25753 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25754 wxPyEndAllowThreads(__tstate);
25755 if (PyErr_Occurred()) SWIG_fail;
25756 }
25757 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25758 {
25759 if (temp2) delete arg2;
25760 }
25761 return resultobj;
25762 fail:
25763 {
25764 if (temp2) delete arg2;
25765 }
25766 return NULL;
25767 }
25768
25769
25770 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25771 PyObject *resultobj = 0;
25772 wxDateTime *arg1 = (wxDateTime *) 0 ;
25773 wxDateTime::TimeZone *arg2 = 0 ;
25774 bool arg3 = (bool) false ;
25775 wxDateTime *result = 0 ;
25776 void *argp1 = 0 ;
25777 int res1 = 0 ;
25778 bool temp2 = false ;
25779 bool val3 ;
25780 int ecode3 = 0 ;
25781 PyObject * obj0 = 0 ;
25782 PyObject * obj1 = 0 ;
25783 PyObject * obj2 = 0 ;
25784 char * kwnames[] = {
25785 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25786 };
25787
25788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25790 if (!SWIG_IsOK(res1)) {
25791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25792 }
25793 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25794 {
25795 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25796 temp2 = true;
25797 }
25798 if (obj2) {
25799 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25800 if (!SWIG_IsOK(ecode3)) {
25801 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25802 }
25803 arg3 = static_cast< bool >(val3);
25804 }
25805 {
25806 PyThreadState* __tstate = wxPyBeginAllowThreads();
25807 {
25808 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25809 result = (wxDateTime *) &_result_ref;
25810 }
25811 wxPyEndAllowThreads(__tstate);
25812 if (PyErr_Occurred()) SWIG_fail;
25813 }
25814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25815 {
25816 if (temp2) delete arg2;
25817 }
25818 return resultobj;
25819 fail:
25820 {
25821 if (temp2) delete arg2;
25822 }
25823 return NULL;
25824 }
25825
25826
25827 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25828 PyObject *resultobj = 0;
25829 wxDateTime *arg1 = (wxDateTime *) 0 ;
25830 bool arg2 = (bool) false ;
25831 wxDateTime result;
25832 void *argp1 = 0 ;
25833 int res1 = 0 ;
25834 bool val2 ;
25835 int ecode2 = 0 ;
25836 PyObject * obj0 = 0 ;
25837 PyObject * obj1 = 0 ;
25838 char * kwnames[] = {
25839 (char *) "self",(char *) "noDST", NULL
25840 };
25841
25842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25844 if (!SWIG_IsOK(res1)) {
25845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25846 }
25847 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25848 if (obj1) {
25849 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25850 if (!SWIG_IsOK(ecode2)) {
25851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25852 }
25853 arg2 = static_cast< bool >(val2);
25854 }
25855 {
25856 PyThreadState* __tstate = wxPyBeginAllowThreads();
25857 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25858 wxPyEndAllowThreads(__tstate);
25859 if (PyErr_Occurred()) SWIG_fail;
25860 }
25861 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25862 return resultobj;
25863 fail:
25864 return NULL;
25865 }
25866
25867
25868 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25869 PyObject *resultobj = 0;
25870 wxDateTime *arg1 = (wxDateTime *) 0 ;
25871 bool arg2 = (bool) false ;
25872 wxDateTime *result = 0 ;
25873 void *argp1 = 0 ;
25874 int res1 = 0 ;
25875 bool val2 ;
25876 int ecode2 = 0 ;
25877 PyObject * obj0 = 0 ;
25878 PyObject * obj1 = 0 ;
25879 char * kwnames[] = {
25880 (char *) "self",(char *) "noDST", NULL
25881 };
25882
25883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25885 if (!SWIG_IsOK(res1)) {
25886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25887 }
25888 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25889 if (obj1) {
25890 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25891 if (!SWIG_IsOK(ecode2)) {
25892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25893 }
25894 arg2 = static_cast< bool >(val2);
25895 }
25896 {
25897 PyThreadState* __tstate = wxPyBeginAllowThreads();
25898 {
25899 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25900 result = (wxDateTime *) &_result_ref;
25901 }
25902 wxPyEndAllowThreads(__tstate);
25903 if (PyErr_Occurred()) SWIG_fail;
25904 }
25905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25906 return resultobj;
25907 fail:
25908 return NULL;
25909 }
25910
25911
25912 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25913 PyObject *resultobj = 0;
25914 wxDateTime *arg1 = (wxDateTime *) 0 ;
25915 bool arg2 = (bool) false ;
25916 wxDateTime result;
25917 void *argp1 = 0 ;
25918 int res1 = 0 ;
25919 bool val2 ;
25920 int ecode2 = 0 ;
25921 PyObject * obj0 = 0 ;
25922 PyObject * obj1 = 0 ;
25923 char * kwnames[] = {
25924 (char *) "self",(char *) "noDST", NULL
25925 };
25926
25927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25929 if (!SWIG_IsOK(res1)) {
25930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25931 }
25932 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25933 if (obj1) {
25934 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25935 if (!SWIG_IsOK(ecode2)) {
25936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
25937 }
25938 arg2 = static_cast< bool >(val2);
25939 }
25940 {
25941 PyThreadState* __tstate = wxPyBeginAllowThreads();
25942 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
25943 wxPyEndAllowThreads(__tstate);
25944 if (PyErr_Occurred()) SWIG_fail;
25945 }
25946 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25947 return resultobj;
25948 fail:
25949 return NULL;
25950 }
25951
25952
25953 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25954 PyObject *resultobj = 0;
25955 wxDateTime *arg1 = (wxDateTime *) 0 ;
25956 bool arg2 = (bool) false ;
25957 wxDateTime *result = 0 ;
25958 void *argp1 = 0 ;
25959 int res1 = 0 ;
25960 bool val2 ;
25961 int ecode2 = 0 ;
25962 PyObject * obj0 = 0 ;
25963 PyObject * obj1 = 0 ;
25964 char * kwnames[] = {
25965 (char *) "self",(char *) "noDST", NULL
25966 };
25967
25968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25970 if (!SWIG_IsOK(res1)) {
25971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
25972 }
25973 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25974 if (obj1) {
25975 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25976 if (!SWIG_IsOK(ecode2)) {
25977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
25978 }
25979 arg2 = static_cast< bool >(val2);
25980 }
25981 {
25982 PyThreadState* __tstate = wxPyBeginAllowThreads();
25983 {
25984 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
25985 result = (wxDateTime *) &_result_ref;
25986 }
25987 wxPyEndAllowThreads(__tstate);
25988 if (PyErr_Occurred()) SWIG_fail;
25989 }
25990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25991 return resultobj;
25992 fail:
25993 return NULL;
25994 }
25995
25996
25997 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25998 PyObject *resultobj = 0;
25999 wxDateTime *arg1 = (wxDateTime *) 0 ;
26000 bool arg2 = (bool) false ;
26001 wxDateTime result;
26002 void *argp1 = 0 ;
26003 int res1 = 0 ;
26004 bool val2 ;
26005 int ecode2 = 0 ;
26006 PyObject * obj0 = 0 ;
26007 PyObject * obj1 = 0 ;
26008 char * kwnames[] = {
26009 (char *) "self",(char *) "noDST", NULL
26010 };
26011
26012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26014 if (!SWIG_IsOK(res1)) {
26015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26016 }
26017 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26018 if (obj1) {
26019 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26020 if (!SWIG_IsOK(ecode2)) {
26021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26022 }
26023 arg2 = static_cast< bool >(val2);
26024 }
26025 {
26026 PyThreadState* __tstate = wxPyBeginAllowThreads();
26027 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26028 wxPyEndAllowThreads(__tstate);
26029 if (PyErr_Occurred()) SWIG_fail;
26030 }
26031 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26032 return resultobj;
26033 fail:
26034 return NULL;
26035 }
26036
26037
26038 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26039 PyObject *resultobj = 0;
26040 wxDateTime *arg1 = (wxDateTime *) 0 ;
26041 bool arg2 = (bool) false ;
26042 wxDateTime *result = 0 ;
26043 void *argp1 = 0 ;
26044 int res1 = 0 ;
26045 bool val2 ;
26046 int ecode2 = 0 ;
26047 PyObject * obj0 = 0 ;
26048 PyObject * obj1 = 0 ;
26049 char * kwnames[] = {
26050 (char *) "self",(char *) "noDST", NULL
26051 };
26052
26053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26055 if (!SWIG_IsOK(res1)) {
26056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26057 }
26058 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26059 if (obj1) {
26060 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26061 if (!SWIG_IsOK(ecode2)) {
26062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26063 }
26064 arg2 = static_cast< bool >(val2);
26065 }
26066 {
26067 PyThreadState* __tstate = wxPyBeginAllowThreads();
26068 {
26069 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26070 result = (wxDateTime *) &_result_ref;
26071 }
26072 wxPyEndAllowThreads(__tstate);
26073 if (PyErr_Occurred()) SWIG_fail;
26074 }
26075 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26076 return resultobj;
26077 fail:
26078 return NULL;
26079 }
26080
26081
26082 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26083 PyObject *resultobj = 0;
26084 wxDateTime *arg1 = (wxDateTime *) 0 ;
26085 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26086 int result;
26087 void *argp1 = 0 ;
26088 int res1 = 0 ;
26089 int val2 ;
26090 int ecode2 = 0 ;
26091 PyObject * obj0 = 0 ;
26092 PyObject * obj1 = 0 ;
26093 char * kwnames[] = {
26094 (char *) "self",(char *) "country", NULL
26095 };
26096
26097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26099 if (!SWIG_IsOK(res1)) {
26100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26101 }
26102 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26103 if (obj1) {
26104 ecode2 = SWIG_AsVal_int(obj1, &val2);
26105 if (!SWIG_IsOK(ecode2)) {
26106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26107 }
26108 arg2 = static_cast< wxDateTime::Country >(val2);
26109 }
26110 {
26111 PyThreadState* __tstate = wxPyBeginAllowThreads();
26112 result = (int)(arg1)->IsDST(arg2);
26113 wxPyEndAllowThreads(__tstate);
26114 if (PyErr_Occurred()) SWIG_fail;
26115 }
26116 resultobj = SWIG_From_int(static_cast< int >(result));
26117 return resultobj;
26118 fail:
26119 return NULL;
26120 }
26121
26122
26123 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26124 PyObject *resultobj = 0;
26125 wxDateTime *arg1 = (wxDateTime *) 0 ;
26126 bool result;
26127 void *argp1 = 0 ;
26128 int res1 = 0 ;
26129 PyObject *swig_obj[1] ;
26130
26131 if (!args) SWIG_fail;
26132 swig_obj[0] = args;
26133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26134 if (!SWIG_IsOK(res1)) {
26135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26136 }
26137 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26138 {
26139 PyThreadState* __tstate = wxPyBeginAllowThreads();
26140 result = (bool)((wxDateTime const *)arg1)->IsValid();
26141 wxPyEndAllowThreads(__tstate);
26142 if (PyErr_Occurred()) SWIG_fail;
26143 }
26144 {
26145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26146 }
26147 return resultobj;
26148 fail:
26149 return NULL;
26150 }
26151
26152
26153 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26154 PyObject *resultobj = 0;
26155 wxDateTime *arg1 = (wxDateTime *) 0 ;
26156 time_t result;
26157 void *argp1 = 0 ;
26158 int res1 = 0 ;
26159 PyObject *swig_obj[1] ;
26160
26161 if (!args) SWIG_fail;
26162 swig_obj[0] = args;
26163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26164 if (!SWIG_IsOK(res1)) {
26165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26166 }
26167 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26168 {
26169 PyThreadState* __tstate = wxPyBeginAllowThreads();
26170 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26171 wxPyEndAllowThreads(__tstate);
26172 if (PyErr_Occurred()) SWIG_fail;
26173 }
26174 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26175 return resultobj;
26176 fail:
26177 return NULL;
26178 }
26179
26180
26181 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26182 PyObject *resultobj = 0;
26183 wxDateTime *arg1 = (wxDateTime *) 0 ;
26184 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26185 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26186 int result;
26187 void *argp1 = 0 ;
26188 int res1 = 0 ;
26189 bool temp2 = false ;
26190 PyObject * obj0 = 0 ;
26191 PyObject * obj1 = 0 ;
26192 char * kwnames[] = {
26193 (char *) "self",(char *) "tz", NULL
26194 };
26195
26196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26198 if (!SWIG_IsOK(res1)) {
26199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26200 }
26201 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26202 if (obj1) {
26203 {
26204 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26205 temp2 = true;
26206 }
26207 }
26208 {
26209 PyThreadState* __tstate = wxPyBeginAllowThreads();
26210 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26211 wxPyEndAllowThreads(__tstate);
26212 if (PyErr_Occurred()) SWIG_fail;
26213 }
26214 resultobj = SWIG_From_int(static_cast< int >(result));
26215 {
26216 if (temp2) delete arg2;
26217 }
26218 return resultobj;
26219 fail:
26220 {
26221 if (temp2) delete arg2;
26222 }
26223 return NULL;
26224 }
26225
26226
26227 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26228 PyObject *resultobj = 0;
26229 wxDateTime *arg1 = (wxDateTime *) 0 ;
26230 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26231 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26232 wxDateTime::Month result;
26233 void *argp1 = 0 ;
26234 int res1 = 0 ;
26235 bool temp2 = false ;
26236 PyObject * obj0 = 0 ;
26237 PyObject * obj1 = 0 ;
26238 char * kwnames[] = {
26239 (char *) "self",(char *) "tz", NULL
26240 };
26241
26242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26244 if (!SWIG_IsOK(res1)) {
26245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26246 }
26247 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26248 if (obj1) {
26249 {
26250 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26251 temp2 = true;
26252 }
26253 }
26254 {
26255 PyThreadState* __tstate = wxPyBeginAllowThreads();
26256 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26257 wxPyEndAllowThreads(__tstate);
26258 if (PyErr_Occurred()) SWIG_fail;
26259 }
26260 resultobj = SWIG_From_int(static_cast< int >(result));
26261 {
26262 if (temp2) delete arg2;
26263 }
26264 return resultobj;
26265 fail:
26266 {
26267 if (temp2) delete arg2;
26268 }
26269 return NULL;
26270 }
26271
26272
26273 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26274 PyObject *resultobj = 0;
26275 wxDateTime *arg1 = (wxDateTime *) 0 ;
26276 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26277 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26278 int result;
26279 void *argp1 = 0 ;
26280 int res1 = 0 ;
26281 bool temp2 = false ;
26282 PyObject * obj0 = 0 ;
26283 PyObject * obj1 = 0 ;
26284 char * kwnames[] = {
26285 (char *) "self",(char *) "tz", NULL
26286 };
26287
26288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26290 if (!SWIG_IsOK(res1)) {
26291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26292 }
26293 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26294 if (obj1) {
26295 {
26296 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26297 temp2 = true;
26298 }
26299 }
26300 {
26301 PyThreadState* __tstate = wxPyBeginAllowThreads();
26302 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26303 wxPyEndAllowThreads(__tstate);
26304 if (PyErr_Occurred()) SWIG_fail;
26305 }
26306 resultobj = SWIG_From_int(static_cast< int >(result));
26307 {
26308 if (temp2) delete arg2;
26309 }
26310 return resultobj;
26311 fail:
26312 {
26313 if (temp2) delete arg2;
26314 }
26315 return NULL;
26316 }
26317
26318
26319 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26320 PyObject *resultobj = 0;
26321 wxDateTime *arg1 = (wxDateTime *) 0 ;
26322 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26323 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26324 wxDateTime::WeekDay result;
26325 void *argp1 = 0 ;
26326 int res1 = 0 ;
26327 bool temp2 = false ;
26328 PyObject * obj0 = 0 ;
26329 PyObject * obj1 = 0 ;
26330 char * kwnames[] = {
26331 (char *) "self",(char *) "tz", NULL
26332 };
26333
26334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26336 if (!SWIG_IsOK(res1)) {
26337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26338 }
26339 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26340 if (obj1) {
26341 {
26342 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26343 temp2 = true;
26344 }
26345 }
26346 {
26347 PyThreadState* __tstate = wxPyBeginAllowThreads();
26348 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26349 wxPyEndAllowThreads(__tstate);
26350 if (PyErr_Occurred()) SWIG_fail;
26351 }
26352 resultobj = SWIG_From_int(static_cast< int >(result));
26353 {
26354 if (temp2) delete arg2;
26355 }
26356 return resultobj;
26357 fail:
26358 {
26359 if (temp2) delete arg2;
26360 }
26361 return NULL;
26362 }
26363
26364
26365 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26366 PyObject *resultobj = 0;
26367 wxDateTime *arg1 = (wxDateTime *) 0 ;
26368 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26369 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26370 int result;
26371 void *argp1 = 0 ;
26372 int res1 = 0 ;
26373 bool temp2 = false ;
26374 PyObject * obj0 = 0 ;
26375 PyObject * obj1 = 0 ;
26376 char * kwnames[] = {
26377 (char *) "self",(char *) "tz", NULL
26378 };
26379
26380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26382 if (!SWIG_IsOK(res1)) {
26383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26384 }
26385 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26386 if (obj1) {
26387 {
26388 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26389 temp2 = true;
26390 }
26391 }
26392 {
26393 PyThreadState* __tstate = wxPyBeginAllowThreads();
26394 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26395 wxPyEndAllowThreads(__tstate);
26396 if (PyErr_Occurred()) SWIG_fail;
26397 }
26398 resultobj = SWIG_From_int(static_cast< int >(result));
26399 {
26400 if (temp2) delete arg2;
26401 }
26402 return resultobj;
26403 fail:
26404 {
26405 if (temp2) delete arg2;
26406 }
26407 return NULL;
26408 }
26409
26410
26411 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26412 PyObject *resultobj = 0;
26413 wxDateTime *arg1 = (wxDateTime *) 0 ;
26414 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26415 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26416 int result;
26417 void *argp1 = 0 ;
26418 int res1 = 0 ;
26419 bool temp2 = false ;
26420 PyObject * obj0 = 0 ;
26421 PyObject * obj1 = 0 ;
26422 char * kwnames[] = {
26423 (char *) "self",(char *) "tz", NULL
26424 };
26425
26426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26428 if (!SWIG_IsOK(res1)) {
26429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26430 }
26431 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26432 if (obj1) {
26433 {
26434 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26435 temp2 = true;
26436 }
26437 }
26438 {
26439 PyThreadState* __tstate = wxPyBeginAllowThreads();
26440 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26441 wxPyEndAllowThreads(__tstate);
26442 if (PyErr_Occurred()) SWIG_fail;
26443 }
26444 resultobj = SWIG_From_int(static_cast< int >(result));
26445 {
26446 if (temp2) delete arg2;
26447 }
26448 return resultobj;
26449 fail:
26450 {
26451 if (temp2) delete arg2;
26452 }
26453 return NULL;
26454 }
26455
26456
26457 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26458 PyObject *resultobj = 0;
26459 wxDateTime *arg1 = (wxDateTime *) 0 ;
26460 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26461 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26462 int result;
26463 void *argp1 = 0 ;
26464 int res1 = 0 ;
26465 bool temp2 = false ;
26466 PyObject * obj0 = 0 ;
26467 PyObject * obj1 = 0 ;
26468 char * kwnames[] = {
26469 (char *) "self",(char *) "tz", NULL
26470 };
26471
26472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26474 if (!SWIG_IsOK(res1)) {
26475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26476 }
26477 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26478 if (obj1) {
26479 {
26480 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26481 temp2 = true;
26482 }
26483 }
26484 {
26485 PyThreadState* __tstate = wxPyBeginAllowThreads();
26486 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26487 wxPyEndAllowThreads(__tstate);
26488 if (PyErr_Occurred()) SWIG_fail;
26489 }
26490 resultobj = SWIG_From_int(static_cast< int >(result));
26491 {
26492 if (temp2) delete arg2;
26493 }
26494 return resultobj;
26495 fail:
26496 {
26497 if (temp2) delete arg2;
26498 }
26499 return NULL;
26500 }
26501
26502
26503 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26504 PyObject *resultobj = 0;
26505 wxDateTime *arg1 = (wxDateTime *) 0 ;
26506 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26507 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26508 int result;
26509 void *argp1 = 0 ;
26510 int res1 = 0 ;
26511 bool temp2 = false ;
26512 PyObject * obj0 = 0 ;
26513 PyObject * obj1 = 0 ;
26514 char * kwnames[] = {
26515 (char *) "self",(char *) "tz", NULL
26516 };
26517
26518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26520 if (!SWIG_IsOK(res1)) {
26521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26522 }
26523 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26524 if (obj1) {
26525 {
26526 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26527 temp2 = true;
26528 }
26529 }
26530 {
26531 PyThreadState* __tstate = wxPyBeginAllowThreads();
26532 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26533 wxPyEndAllowThreads(__tstate);
26534 if (PyErr_Occurred()) SWIG_fail;
26535 }
26536 resultobj = SWIG_From_int(static_cast< int >(result));
26537 {
26538 if (temp2) delete arg2;
26539 }
26540 return resultobj;
26541 fail:
26542 {
26543 if (temp2) delete arg2;
26544 }
26545 return NULL;
26546 }
26547
26548
26549 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26550 PyObject *resultobj = 0;
26551 wxDateTime *arg1 = (wxDateTime *) 0 ;
26552 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26553 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26554 int result;
26555 void *argp1 = 0 ;
26556 int res1 = 0 ;
26557 bool temp2 = false ;
26558 PyObject * obj0 = 0 ;
26559 PyObject * obj1 = 0 ;
26560 char * kwnames[] = {
26561 (char *) "self",(char *) "tz", NULL
26562 };
26563
26564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26566 if (!SWIG_IsOK(res1)) {
26567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26568 }
26569 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26570 if (obj1) {
26571 {
26572 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26573 temp2 = true;
26574 }
26575 }
26576 {
26577 PyThreadState* __tstate = wxPyBeginAllowThreads();
26578 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26579 wxPyEndAllowThreads(__tstate);
26580 if (PyErr_Occurred()) SWIG_fail;
26581 }
26582 resultobj = SWIG_From_int(static_cast< int >(result));
26583 {
26584 if (temp2) delete arg2;
26585 }
26586 return resultobj;
26587 fail:
26588 {
26589 if (temp2) delete arg2;
26590 }
26591 return NULL;
26592 }
26593
26594
26595 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26596 PyObject *resultobj = 0;
26597 wxDateTime *arg1 = (wxDateTime *) 0 ;
26598 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26599 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26600 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26601 int result;
26602 void *argp1 = 0 ;
26603 int res1 = 0 ;
26604 int val2 ;
26605 int ecode2 = 0 ;
26606 bool temp3 = false ;
26607 PyObject * obj0 = 0 ;
26608 PyObject * obj1 = 0 ;
26609 PyObject * obj2 = 0 ;
26610 char * kwnames[] = {
26611 (char *) "self",(char *) "flags",(char *) "tz", NULL
26612 };
26613
26614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26616 if (!SWIG_IsOK(res1)) {
26617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26618 }
26619 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26620 if (obj1) {
26621 ecode2 = SWIG_AsVal_int(obj1, &val2);
26622 if (!SWIG_IsOK(ecode2)) {
26623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26624 }
26625 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26626 }
26627 if (obj2) {
26628 {
26629 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26630 temp3 = true;
26631 }
26632 }
26633 {
26634 PyThreadState* __tstate = wxPyBeginAllowThreads();
26635 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26636 wxPyEndAllowThreads(__tstate);
26637 if (PyErr_Occurred()) SWIG_fail;
26638 }
26639 resultobj = SWIG_From_int(static_cast< int >(result));
26640 {
26641 if (temp3) delete arg3;
26642 }
26643 return resultobj;
26644 fail:
26645 {
26646 if (temp3) delete arg3;
26647 }
26648 return NULL;
26649 }
26650
26651
26652 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26653 PyObject *resultobj = 0;
26654 wxDateTime *arg1 = (wxDateTime *) 0 ;
26655 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26656 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26657 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26658 int result;
26659 void *argp1 = 0 ;
26660 int res1 = 0 ;
26661 int val2 ;
26662 int ecode2 = 0 ;
26663 bool temp3 = false ;
26664 PyObject * obj0 = 0 ;
26665 PyObject * obj1 = 0 ;
26666 PyObject * obj2 = 0 ;
26667 char * kwnames[] = {
26668 (char *) "self",(char *) "flags",(char *) "tz", NULL
26669 };
26670
26671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26673 if (!SWIG_IsOK(res1)) {
26674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26675 }
26676 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26677 if (obj1) {
26678 ecode2 = SWIG_AsVal_int(obj1, &val2);
26679 if (!SWIG_IsOK(ecode2)) {
26680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26681 }
26682 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26683 }
26684 if (obj2) {
26685 {
26686 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26687 temp3 = true;
26688 }
26689 }
26690 {
26691 PyThreadState* __tstate = wxPyBeginAllowThreads();
26692 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26693 wxPyEndAllowThreads(__tstate);
26694 if (PyErr_Occurred()) SWIG_fail;
26695 }
26696 resultobj = SWIG_From_int(static_cast< int >(result));
26697 {
26698 if (temp3) delete arg3;
26699 }
26700 return resultobj;
26701 fail:
26702 {
26703 if (temp3) delete arg3;
26704 }
26705 return NULL;
26706 }
26707
26708
26709 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26710 PyObject *resultobj = 0;
26711 wxDateTime *arg1 = (wxDateTime *) 0 ;
26712 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26713 bool result;
26714 void *argp1 = 0 ;
26715 int res1 = 0 ;
26716 int val2 ;
26717 int ecode2 = 0 ;
26718 PyObject * obj0 = 0 ;
26719 PyObject * obj1 = 0 ;
26720 char * kwnames[] = {
26721 (char *) "self",(char *) "country", NULL
26722 };
26723
26724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26726 if (!SWIG_IsOK(res1)) {
26727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26728 }
26729 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26730 if (obj1) {
26731 ecode2 = SWIG_AsVal_int(obj1, &val2);
26732 if (!SWIG_IsOK(ecode2)) {
26733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26734 }
26735 arg2 = static_cast< wxDateTime::Country >(val2);
26736 }
26737 {
26738 PyThreadState* __tstate = wxPyBeginAllowThreads();
26739 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26740 wxPyEndAllowThreads(__tstate);
26741 if (PyErr_Occurred()) SWIG_fail;
26742 }
26743 {
26744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26745 }
26746 return resultobj;
26747 fail:
26748 return NULL;
26749 }
26750
26751
26752 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26753 PyObject *resultobj = 0;
26754 wxDateTime *arg1 = (wxDateTime *) 0 ;
26755 wxDateTime *arg2 = 0 ;
26756 bool result;
26757 void *argp1 = 0 ;
26758 int res1 = 0 ;
26759 void *argp2 = 0 ;
26760 int res2 = 0 ;
26761 PyObject * obj0 = 0 ;
26762 PyObject * obj1 = 0 ;
26763 char * kwnames[] = {
26764 (char *) "self",(char *) "datetime", NULL
26765 };
26766
26767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26769 if (!SWIG_IsOK(res1)) {
26770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26771 }
26772 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26773 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26774 if (!SWIG_IsOK(res2)) {
26775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26776 }
26777 if (!argp2) {
26778 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26779 }
26780 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26781 {
26782 PyThreadState* __tstate = wxPyBeginAllowThreads();
26783 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26784 wxPyEndAllowThreads(__tstate);
26785 if (PyErr_Occurred()) SWIG_fail;
26786 }
26787 {
26788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26789 }
26790 return resultobj;
26791 fail:
26792 return NULL;
26793 }
26794
26795
26796 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26797 PyObject *resultobj = 0;
26798 wxDateTime *arg1 = (wxDateTime *) 0 ;
26799 wxDateTime *arg2 = 0 ;
26800 bool result;
26801 void *argp1 = 0 ;
26802 int res1 = 0 ;
26803 void *argp2 = 0 ;
26804 int res2 = 0 ;
26805 PyObject * obj0 = 0 ;
26806 PyObject * obj1 = 0 ;
26807 char * kwnames[] = {
26808 (char *) "self",(char *) "datetime", NULL
26809 };
26810
26811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26813 if (!SWIG_IsOK(res1)) {
26814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26815 }
26816 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26817 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26818 if (!SWIG_IsOK(res2)) {
26819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26820 }
26821 if (!argp2) {
26822 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26823 }
26824 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26825 {
26826 PyThreadState* __tstate = wxPyBeginAllowThreads();
26827 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26828 wxPyEndAllowThreads(__tstate);
26829 if (PyErr_Occurred()) SWIG_fail;
26830 }
26831 {
26832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26833 }
26834 return resultobj;
26835 fail:
26836 return NULL;
26837 }
26838
26839
26840 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26841 PyObject *resultobj = 0;
26842 wxDateTime *arg1 = (wxDateTime *) 0 ;
26843 wxDateTime *arg2 = 0 ;
26844 bool result;
26845 void *argp1 = 0 ;
26846 int res1 = 0 ;
26847 void *argp2 = 0 ;
26848 int res2 = 0 ;
26849 PyObject * obj0 = 0 ;
26850 PyObject * obj1 = 0 ;
26851 char * kwnames[] = {
26852 (char *) "self",(char *) "datetime", NULL
26853 };
26854
26855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26857 if (!SWIG_IsOK(res1)) {
26858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26859 }
26860 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26861 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26862 if (!SWIG_IsOK(res2)) {
26863 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26864 }
26865 if (!argp2) {
26866 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26867 }
26868 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26869 {
26870 PyThreadState* __tstate = wxPyBeginAllowThreads();
26871 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26872 wxPyEndAllowThreads(__tstate);
26873 if (PyErr_Occurred()) SWIG_fail;
26874 }
26875 {
26876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26877 }
26878 return resultobj;
26879 fail:
26880 return NULL;
26881 }
26882
26883
26884 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26885 PyObject *resultobj = 0;
26886 wxDateTime *arg1 = (wxDateTime *) 0 ;
26887 wxDateTime *arg2 = 0 ;
26888 wxDateTime *arg3 = 0 ;
26889 bool result;
26890 void *argp1 = 0 ;
26891 int res1 = 0 ;
26892 void *argp2 = 0 ;
26893 int res2 = 0 ;
26894 void *argp3 = 0 ;
26895 int res3 = 0 ;
26896 PyObject * obj0 = 0 ;
26897 PyObject * obj1 = 0 ;
26898 PyObject * obj2 = 0 ;
26899 char * kwnames[] = {
26900 (char *) "self",(char *) "t1",(char *) "t2", NULL
26901 };
26902
26903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26905 if (!SWIG_IsOK(res1)) {
26906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26907 }
26908 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26909 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26910 if (!SWIG_IsOK(res2)) {
26911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26912 }
26913 if (!argp2) {
26914 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26915 }
26916 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26917 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26918 if (!SWIG_IsOK(res3)) {
26919 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26920 }
26921 if (!argp3) {
26922 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26923 }
26924 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26925 {
26926 PyThreadState* __tstate = wxPyBeginAllowThreads();
26927 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26928 wxPyEndAllowThreads(__tstate);
26929 if (PyErr_Occurred()) SWIG_fail;
26930 }
26931 {
26932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26933 }
26934 return resultobj;
26935 fail:
26936 return NULL;
26937 }
26938
26939
26940 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26941 PyObject *resultobj = 0;
26942 wxDateTime *arg1 = (wxDateTime *) 0 ;
26943 wxDateTime *arg2 = 0 ;
26944 wxDateTime *arg3 = 0 ;
26945 bool result;
26946 void *argp1 = 0 ;
26947 int res1 = 0 ;
26948 void *argp2 = 0 ;
26949 int res2 = 0 ;
26950 void *argp3 = 0 ;
26951 int res3 = 0 ;
26952 PyObject * obj0 = 0 ;
26953 PyObject * obj1 = 0 ;
26954 PyObject * obj2 = 0 ;
26955 char * kwnames[] = {
26956 (char *) "self",(char *) "t1",(char *) "t2", NULL
26957 };
26958
26959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26961 if (!SWIG_IsOK(res1)) {
26962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26963 }
26964 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26965 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26966 if (!SWIG_IsOK(res2)) {
26967 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26968 }
26969 if (!argp2) {
26970 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26971 }
26972 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26973 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26974 if (!SWIG_IsOK(res3)) {
26975 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26976 }
26977 if (!argp3) {
26978 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26979 }
26980 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26981 {
26982 PyThreadState* __tstate = wxPyBeginAllowThreads();
26983 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26984 wxPyEndAllowThreads(__tstate);
26985 if (PyErr_Occurred()) SWIG_fail;
26986 }
26987 {
26988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26989 }
26990 return resultobj;
26991 fail:
26992 return NULL;
26993 }
26994
26995
26996 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26997 PyObject *resultobj = 0;
26998 wxDateTime *arg1 = (wxDateTime *) 0 ;
26999 wxDateTime *arg2 = 0 ;
27000 bool result;
27001 void *argp1 = 0 ;
27002 int res1 = 0 ;
27003 void *argp2 = 0 ;
27004 int res2 = 0 ;
27005 PyObject * obj0 = 0 ;
27006 PyObject * obj1 = 0 ;
27007 char * kwnames[] = {
27008 (char *) "self",(char *) "dt", NULL
27009 };
27010
27011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27013 if (!SWIG_IsOK(res1)) {
27014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27015 }
27016 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27017 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27018 if (!SWIG_IsOK(res2)) {
27019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27020 }
27021 if (!argp2) {
27022 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27023 }
27024 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27025 {
27026 PyThreadState* __tstate = wxPyBeginAllowThreads();
27027 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27028 wxPyEndAllowThreads(__tstate);
27029 if (PyErr_Occurred()) SWIG_fail;
27030 }
27031 {
27032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27033 }
27034 return resultobj;
27035 fail:
27036 return NULL;
27037 }
27038
27039
27040 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27041 PyObject *resultobj = 0;
27042 wxDateTime *arg1 = (wxDateTime *) 0 ;
27043 wxDateTime *arg2 = 0 ;
27044 bool result;
27045 void *argp1 = 0 ;
27046 int res1 = 0 ;
27047 void *argp2 = 0 ;
27048 int res2 = 0 ;
27049 PyObject * obj0 = 0 ;
27050 PyObject * obj1 = 0 ;
27051 char * kwnames[] = {
27052 (char *) "self",(char *) "dt", NULL
27053 };
27054
27055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27057 if (!SWIG_IsOK(res1)) {
27058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27059 }
27060 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27061 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27062 if (!SWIG_IsOK(res2)) {
27063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27064 }
27065 if (!argp2) {
27066 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27067 }
27068 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27069 {
27070 PyThreadState* __tstate = wxPyBeginAllowThreads();
27071 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27072 wxPyEndAllowThreads(__tstate);
27073 if (PyErr_Occurred()) SWIG_fail;
27074 }
27075 {
27076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27077 }
27078 return resultobj;
27079 fail:
27080 return NULL;
27081 }
27082
27083
27084 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27085 PyObject *resultobj = 0;
27086 wxDateTime *arg1 = (wxDateTime *) 0 ;
27087 wxDateTime *arg2 = 0 ;
27088 wxTimeSpan *arg3 = 0 ;
27089 bool result;
27090 void *argp1 = 0 ;
27091 int res1 = 0 ;
27092 void *argp2 = 0 ;
27093 int res2 = 0 ;
27094 void *argp3 = 0 ;
27095 int res3 = 0 ;
27096 PyObject * obj0 = 0 ;
27097 PyObject * obj1 = 0 ;
27098 PyObject * obj2 = 0 ;
27099 char * kwnames[] = {
27100 (char *) "self",(char *) "dt",(char *) "ts", NULL
27101 };
27102
27103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27105 if (!SWIG_IsOK(res1)) {
27106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27107 }
27108 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27109 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27110 if (!SWIG_IsOK(res2)) {
27111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27112 }
27113 if (!argp2) {
27114 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27115 }
27116 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27117 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27118 if (!SWIG_IsOK(res3)) {
27119 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27120 }
27121 if (!argp3) {
27122 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27123 }
27124 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27125 {
27126 PyThreadState* __tstate = wxPyBeginAllowThreads();
27127 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27128 wxPyEndAllowThreads(__tstate);
27129 if (PyErr_Occurred()) SWIG_fail;
27130 }
27131 {
27132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27133 }
27134 return resultobj;
27135 fail:
27136 return NULL;
27137 }
27138
27139
27140 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27141 PyObject *resultobj = 0;
27142 wxDateTime *arg1 = (wxDateTime *) 0 ;
27143 wxTimeSpan *arg2 = 0 ;
27144 wxDateTime *result = 0 ;
27145 void *argp1 = 0 ;
27146 int res1 = 0 ;
27147 void *argp2 = 0 ;
27148 int res2 = 0 ;
27149 PyObject * obj0 = 0 ;
27150 PyObject * obj1 = 0 ;
27151 char * kwnames[] = {
27152 (char *) "self",(char *) "diff", NULL
27153 };
27154
27155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27157 if (!SWIG_IsOK(res1)) {
27158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27159 }
27160 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27161 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27162 if (!SWIG_IsOK(res2)) {
27163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27164 }
27165 if (!argp2) {
27166 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27167 }
27168 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27169 {
27170 PyThreadState* __tstate = wxPyBeginAllowThreads();
27171 {
27172 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27173 result = (wxDateTime *) &_result_ref;
27174 }
27175 wxPyEndAllowThreads(__tstate);
27176 if (PyErr_Occurred()) SWIG_fail;
27177 }
27178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27179 return resultobj;
27180 fail:
27181 return NULL;
27182 }
27183
27184
27185 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27186 PyObject *resultobj = 0;
27187 wxDateTime *arg1 = (wxDateTime *) 0 ;
27188 wxDateSpan *arg2 = 0 ;
27189 wxDateTime *result = 0 ;
27190 void *argp1 = 0 ;
27191 int res1 = 0 ;
27192 void *argp2 = 0 ;
27193 int res2 = 0 ;
27194 PyObject * obj0 = 0 ;
27195 PyObject * obj1 = 0 ;
27196 char * kwnames[] = {
27197 (char *) "self",(char *) "diff", NULL
27198 };
27199
27200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27202 if (!SWIG_IsOK(res1)) {
27203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27204 }
27205 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27206 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27207 if (!SWIG_IsOK(res2)) {
27208 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27209 }
27210 if (!argp2) {
27211 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27212 }
27213 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27214 {
27215 PyThreadState* __tstate = wxPyBeginAllowThreads();
27216 {
27217 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27218 result = (wxDateTime *) &_result_ref;
27219 }
27220 wxPyEndAllowThreads(__tstate);
27221 if (PyErr_Occurred()) SWIG_fail;
27222 }
27223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27224 return resultobj;
27225 fail:
27226 return NULL;
27227 }
27228
27229
27230 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27231 PyObject *resultobj = 0;
27232 wxDateTime *arg1 = (wxDateTime *) 0 ;
27233 wxTimeSpan *arg2 = 0 ;
27234 wxDateTime *result = 0 ;
27235 void *argp1 = 0 ;
27236 int res1 = 0 ;
27237 void *argp2 = 0 ;
27238 int res2 = 0 ;
27239 PyObject * obj0 = 0 ;
27240 PyObject * obj1 = 0 ;
27241 char * kwnames[] = {
27242 (char *) "self",(char *) "diff", NULL
27243 };
27244
27245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27247 if (!SWIG_IsOK(res1)) {
27248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27249 }
27250 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27251 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27252 if (!SWIG_IsOK(res2)) {
27253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27254 }
27255 if (!argp2) {
27256 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27257 }
27258 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27259 {
27260 PyThreadState* __tstate = wxPyBeginAllowThreads();
27261 {
27262 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27263 result = (wxDateTime *) &_result_ref;
27264 }
27265 wxPyEndAllowThreads(__tstate);
27266 if (PyErr_Occurred()) SWIG_fail;
27267 }
27268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27269 return resultobj;
27270 fail:
27271 return NULL;
27272 }
27273
27274
27275 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27276 PyObject *resultobj = 0;
27277 wxDateTime *arg1 = (wxDateTime *) 0 ;
27278 wxDateSpan *arg2 = 0 ;
27279 wxDateTime *result = 0 ;
27280 void *argp1 = 0 ;
27281 int res1 = 0 ;
27282 void *argp2 = 0 ;
27283 int res2 = 0 ;
27284 PyObject * obj0 = 0 ;
27285 PyObject * obj1 = 0 ;
27286 char * kwnames[] = {
27287 (char *) "self",(char *) "diff", NULL
27288 };
27289
27290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27292 if (!SWIG_IsOK(res1)) {
27293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27294 }
27295 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27296 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27297 if (!SWIG_IsOK(res2)) {
27298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27299 }
27300 if (!argp2) {
27301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27302 }
27303 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27304 {
27305 PyThreadState* __tstate = wxPyBeginAllowThreads();
27306 {
27307 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27308 result = (wxDateTime *) &_result_ref;
27309 }
27310 wxPyEndAllowThreads(__tstate);
27311 if (PyErr_Occurred()) SWIG_fail;
27312 }
27313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27314 return resultobj;
27315 fail:
27316 return NULL;
27317 }
27318
27319
27320 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27321 PyObject *resultobj = 0;
27322 wxDateTime *arg1 = (wxDateTime *) 0 ;
27323 wxDateTime *arg2 = 0 ;
27324 wxTimeSpan result;
27325 void *argp1 = 0 ;
27326 int res1 = 0 ;
27327 void *argp2 = 0 ;
27328 int res2 = 0 ;
27329 PyObject * obj0 = 0 ;
27330 PyObject * obj1 = 0 ;
27331 char * kwnames[] = {
27332 (char *) "self",(char *) "dt", NULL
27333 };
27334
27335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27337 if (!SWIG_IsOK(res1)) {
27338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27339 }
27340 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27341 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27342 if (!SWIG_IsOK(res2)) {
27343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27344 }
27345 if (!argp2) {
27346 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27347 }
27348 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27349 {
27350 PyThreadState* __tstate = wxPyBeginAllowThreads();
27351 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27352 wxPyEndAllowThreads(__tstate);
27353 if (PyErr_Occurred()) SWIG_fail;
27354 }
27355 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27356 return resultobj;
27357 fail:
27358 return NULL;
27359 }
27360
27361
27362 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27363 PyObject *resultobj = 0;
27364 wxDateTime *arg1 = (wxDateTime *) 0 ;
27365 wxTimeSpan *arg2 = 0 ;
27366 wxDateTime *result = 0 ;
27367 void *argp1 = 0 ;
27368 int res1 = 0 ;
27369 void *argp2 = 0 ;
27370 int res2 = 0 ;
27371
27372 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27374 if (!SWIG_IsOK(res1)) {
27375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27376 }
27377 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27378 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27379 if (!SWIG_IsOK(res2)) {
27380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27381 }
27382 if (!argp2) {
27383 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27384 }
27385 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27386 {
27387 PyThreadState* __tstate = wxPyBeginAllowThreads();
27388 {
27389 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27390 result = (wxDateTime *) &_result_ref;
27391 }
27392 wxPyEndAllowThreads(__tstate);
27393 if (PyErr_Occurred()) SWIG_fail;
27394 }
27395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27396 return resultobj;
27397 fail:
27398 return NULL;
27399 }
27400
27401
27402 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27403 PyObject *resultobj = 0;
27404 wxDateTime *arg1 = (wxDateTime *) 0 ;
27405 wxDateSpan *arg2 = 0 ;
27406 wxDateTime *result = 0 ;
27407 void *argp1 = 0 ;
27408 int res1 = 0 ;
27409 void *argp2 = 0 ;
27410 int res2 = 0 ;
27411
27412 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27414 if (!SWIG_IsOK(res1)) {
27415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27416 }
27417 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27418 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27419 if (!SWIG_IsOK(res2)) {
27420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27421 }
27422 if (!argp2) {
27423 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27424 }
27425 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27426 {
27427 PyThreadState* __tstate = wxPyBeginAllowThreads();
27428 {
27429 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27430 result = (wxDateTime *) &_result_ref;
27431 }
27432 wxPyEndAllowThreads(__tstate);
27433 if (PyErr_Occurred()) SWIG_fail;
27434 }
27435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27436 return resultobj;
27437 fail:
27438 return NULL;
27439 }
27440
27441
27442 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27443 int argc;
27444 PyObject *argv[3];
27445
27446 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27447 --argc;
27448 if (argc == 2) {
27449 int _v = 0;
27450 {
27451 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27452 _v = SWIG_CheckState(res);
27453 }
27454 if (!_v) goto check_1;
27455 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27456 }
27457 check_1:
27458
27459 if (argc == 2) {
27460 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27461 }
27462
27463 fail:
27464 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27465 return NULL;
27466 }
27467
27468
27469 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27470 PyObject *resultobj = 0;
27471 wxDateTime *arg1 = (wxDateTime *) 0 ;
27472 wxTimeSpan *arg2 = 0 ;
27473 wxDateTime *result = 0 ;
27474 void *argp1 = 0 ;
27475 int res1 = 0 ;
27476 void *argp2 = 0 ;
27477 int res2 = 0 ;
27478
27479 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27481 if (!SWIG_IsOK(res1)) {
27482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27483 }
27484 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27485 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27486 if (!SWIG_IsOK(res2)) {
27487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27488 }
27489 if (!argp2) {
27490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27491 }
27492 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27493 {
27494 PyThreadState* __tstate = wxPyBeginAllowThreads();
27495 {
27496 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27497 result = (wxDateTime *) &_result_ref;
27498 }
27499 wxPyEndAllowThreads(__tstate);
27500 if (PyErr_Occurred()) SWIG_fail;
27501 }
27502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27503 return resultobj;
27504 fail:
27505 return NULL;
27506 }
27507
27508
27509 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27510 PyObject *resultobj = 0;
27511 wxDateTime *arg1 = (wxDateTime *) 0 ;
27512 wxDateSpan *arg2 = 0 ;
27513 wxDateTime *result = 0 ;
27514 void *argp1 = 0 ;
27515 int res1 = 0 ;
27516 void *argp2 = 0 ;
27517 int res2 = 0 ;
27518
27519 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27521 if (!SWIG_IsOK(res1)) {
27522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27523 }
27524 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27525 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27526 if (!SWIG_IsOK(res2)) {
27527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27528 }
27529 if (!argp2) {
27530 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27531 }
27532 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27533 {
27534 PyThreadState* __tstate = wxPyBeginAllowThreads();
27535 {
27536 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27537 result = (wxDateTime *) &_result_ref;
27538 }
27539 wxPyEndAllowThreads(__tstate);
27540 if (PyErr_Occurred()) SWIG_fail;
27541 }
27542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27543 return resultobj;
27544 fail:
27545 return NULL;
27546 }
27547
27548
27549 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27550 int argc;
27551 PyObject *argv[3];
27552
27553 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27554 --argc;
27555 if (argc == 2) {
27556 int _v = 0;
27557 {
27558 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27559 _v = SWIG_CheckState(res);
27560 }
27561 if (!_v) goto check_1;
27562 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27563 }
27564 check_1:
27565
27566 if (argc == 2) {
27567 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27568 }
27569
27570 fail:
27571 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27572 return NULL;
27573 }
27574
27575
27576 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27577 PyObject *resultobj = 0;
27578 wxDateTime *arg1 = (wxDateTime *) 0 ;
27579 wxTimeSpan *arg2 = 0 ;
27580 wxDateTime result;
27581 void *argp1 = 0 ;
27582 int res1 = 0 ;
27583 void *argp2 = 0 ;
27584 int res2 = 0 ;
27585
27586 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27588 if (!SWIG_IsOK(res1)) {
27589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27590 }
27591 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27592 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27593 if (!SWIG_IsOK(res2)) {
27594 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27595 }
27596 if (!argp2) {
27597 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27598 }
27599 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27600 {
27601 PyThreadState* __tstate = wxPyBeginAllowThreads();
27602 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27603 wxPyEndAllowThreads(__tstate);
27604 if (PyErr_Occurred()) SWIG_fail;
27605 }
27606 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27607 return resultobj;
27608 fail:
27609 return NULL;
27610 }
27611
27612
27613 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27614 PyObject *resultobj = 0;
27615 wxDateTime *arg1 = (wxDateTime *) 0 ;
27616 wxDateSpan *arg2 = 0 ;
27617 wxDateTime result;
27618 void *argp1 = 0 ;
27619 int res1 = 0 ;
27620 void *argp2 = 0 ;
27621 int res2 = 0 ;
27622
27623 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27625 if (!SWIG_IsOK(res1)) {
27626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27627 }
27628 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27629 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27630 if (!SWIG_IsOK(res2)) {
27631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27632 }
27633 if (!argp2) {
27634 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27635 }
27636 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27637 {
27638 PyThreadState* __tstate = wxPyBeginAllowThreads();
27639 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27640 wxPyEndAllowThreads(__tstate);
27641 if (PyErr_Occurred()) SWIG_fail;
27642 }
27643 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27644 return resultobj;
27645 fail:
27646 return NULL;
27647 }
27648
27649
27650 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27651 int argc;
27652 PyObject *argv[3];
27653
27654 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27655 --argc;
27656 if (argc == 2) {
27657 int _v = 0;
27658 {
27659 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27660 _v = SWIG_CheckState(res);
27661 }
27662 if (!_v) goto check_1;
27663 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27664 }
27665 check_1:
27666
27667 if (argc == 2) {
27668 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27669 }
27670
27671 fail:
27672 Py_INCREF(Py_NotImplemented);
27673 return Py_NotImplemented;
27674 }
27675
27676
27677 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27678 PyObject *resultobj = 0;
27679 wxDateTime *arg1 = (wxDateTime *) 0 ;
27680 wxDateTime *arg2 = 0 ;
27681 wxTimeSpan result;
27682 void *argp1 = 0 ;
27683 int res1 = 0 ;
27684 void *argp2 = 0 ;
27685 int res2 = 0 ;
27686
27687 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27689 if (!SWIG_IsOK(res1)) {
27690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27691 }
27692 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27693 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27694 if (!SWIG_IsOK(res2)) {
27695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27696 }
27697 if (!argp2) {
27698 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27699 }
27700 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27701 {
27702 PyThreadState* __tstate = wxPyBeginAllowThreads();
27703 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27704 wxPyEndAllowThreads(__tstate);
27705 if (PyErr_Occurred()) SWIG_fail;
27706 }
27707 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27708 return resultobj;
27709 fail:
27710 return NULL;
27711 }
27712
27713
27714 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27715 PyObject *resultobj = 0;
27716 wxDateTime *arg1 = (wxDateTime *) 0 ;
27717 wxTimeSpan *arg2 = 0 ;
27718 wxDateTime result;
27719 void *argp1 = 0 ;
27720 int res1 = 0 ;
27721 void *argp2 = 0 ;
27722 int res2 = 0 ;
27723
27724 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27726 if (!SWIG_IsOK(res1)) {
27727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27728 }
27729 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27730 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27731 if (!SWIG_IsOK(res2)) {
27732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27733 }
27734 if (!argp2) {
27735 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27736 }
27737 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27738 {
27739 PyThreadState* __tstate = wxPyBeginAllowThreads();
27740 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27741 wxPyEndAllowThreads(__tstate);
27742 if (PyErr_Occurred()) SWIG_fail;
27743 }
27744 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27745 return resultobj;
27746 fail:
27747 return NULL;
27748 }
27749
27750
27751 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27752 PyObject *resultobj = 0;
27753 wxDateTime *arg1 = (wxDateTime *) 0 ;
27754 wxDateSpan *arg2 = 0 ;
27755 wxDateTime result;
27756 void *argp1 = 0 ;
27757 int res1 = 0 ;
27758 void *argp2 = 0 ;
27759 int res2 = 0 ;
27760
27761 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27763 if (!SWIG_IsOK(res1)) {
27764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27765 }
27766 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27767 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27768 if (!SWIG_IsOK(res2)) {
27769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27770 }
27771 if (!argp2) {
27772 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27773 }
27774 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27775 {
27776 PyThreadState* __tstate = wxPyBeginAllowThreads();
27777 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27778 wxPyEndAllowThreads(__tstate);
27779 if (PyErr_Occurred()) SWIG_fail;
27780 }
27781 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27782 return resultobj;
27783 fail:
27784 return NULL;
27785 }
27786
27787
27788 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27789 int argc;
27790 PyObject *argv[3];
27791
27792 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27793 --argc;
27794 if (argc == 2) {
27795 int _v = 0;
27796 {
27797 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27798 _v = SWIG_CheckState(res);
27799 }
27800 if (!_v) goto check_1;
27801 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27802 }
27803 check_1:
27804
27805 if (argc == 2) {
27806 int _v = 0;
27807 {
27808 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27809 _v = SWIG_CheckState(res);
27810 }
27811 if (!_v) goto check_2;
27812 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27813 }
27814 check_2:
27815
27816 if (argc == 2) {
27817 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27818 }
27819
27820 fail:
27821 Py_INCREF(Py_NotImplemented);
27822 return Py_NotImplemented;
27823 }
27824
27825
27826 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27827 PyObject *resultobj = 0;
27828 wxDateTime *arg1 = (wxDateTime *) 0 ;
27829 wxDateTime *arg2 = (wxDateTime *) 0 ;
27830 bool result;
27831 void *argp1 = 0 ;
27832 int res1 = 0 ;
27833 void *argp2 = 0 ;
27834 int res2 = 0 ;
27835 PyObject * obj0 = 0 ;
27836 PyObject * obj1 = 0 ;
27837 char * kwnames[] = {
27838 (char *) "self",(char *) "other", NULL
27839 };
27840
27841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27843 if (!SWIG_IsOK(res1)) {
27844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27845 }
27846 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27847 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27848 if (!SWIG_IsOK(res2)) {
27849 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27850 }
27851 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27852 {
27853 PyThreadState* __tstate = wxPyBeginAllowThreads();
27854 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27855 wxPyEndAllowThreads(__tstate);
27856 if (PyErr_Occurred()) SWIG_fail;
27857 }
27858 {
27859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27860 }
27861 return resultobj;
27862 fail:
27863 return NULL;
27864 }
27865
27866
27867 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27868 PyObject *resultobj = 0;
27869 wxDateTime *arg1 = (wxDateTime *) 0 ;
27870 wxDateTime *arg2 = (wxDateTime *) 0 ;
27871 bool result;
27872 void *argp1 = 0 ;
27873 int res1 = 0 ;
27874 void *argp2 = 0 ;
27875 int res2 = 0 ;
27876 PyObject * obj0 = 0 ;
27877 PyObject * obj1 = 0 ;
27878 char * kwnames[] = {
27879 (char *) "self",(char *) "other", NULL
27880 };
27881
27882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27884 if (!SWIG_IsOK(res1)) {
27885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27886 }
27887 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27888 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27889 if (!SWIG_IsOK(res2)) {
27890 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27891 }
27892 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27893 {
27894 PyThreadState* __tstate = wxPyBeginAllowThreads();
27895 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27896 wxPyEndAllowThreads(__tstate);
27897 if (PyErr_Occurred()) SWIG_fail;
27898 }
27899 {
27900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27901 }
27902 return resultobj;
27903 fail:
27904 return NULL;
27905 }
27906
27907
27908 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27909 PyObject *resultobj = 0;
27910 wxDateTime *arg1 = (wxDateTime *) 0 ;
27911 wxDateTime *arg2 = (wxDateTime *) 0 ;
27912 bool result;
27913 void *argp1 = 0 ;
27914 int res1 = 0 ;
27915 void *argp2 = 0 ;
27916 int res2 = 0 ;
27917 PyObject * obj0 = 0 ;
27918 PyObject * obj1 = 0 ;
27919 char * kwnames[] = {
27920 (char *) "self",(char *) "other", NULL
27921 };
27922
27923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
27924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27925 if (!SWIG_IsOK(res1)) {
27926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27927 }
27928 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27929 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27930 if (!SWIG_IsOK(res2)) {
27931 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27932 }
27933 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27934 {
27935 PyThreadState* __tstate = wxPyBeginAllowThreads();
27936 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
27937 wxPyEndAllowThreads(__tstate);
27938 if (PyErr_Occurred()) SWIG_fail;
27939 }
27940 {
27941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27942 }
27943 return resultobj;
27944 fail:
27945 return NULL;
27946 }
27947
27948
27949 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27950 PyObject *resultobj = 0;
27951 wxDateTime *arg1 = (wxDateTime *) 0 ;
27952 wxDateTime *arg2 = (wxDateTime *) 0 ;
27953 bool result;
27954 void *argp1 = 0 ;
27955 int res1 = 0 ;
27956 void *argp2 = 0 ;
27957 int res2 = 0 ;
27958 PyObject * obj0 = 0 ;
27959 PyObject * obj1 = 0 ;
27960 char * kwnames[] = {
27961 (char *) "self",(char *) "other", NULL
27962 };
27963
27964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
27965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27966 if (!SWIG_IsOK(res1)) {
27967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27968 }
27969 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27970 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27971 if (!SWIG_IsOK(res2)) {
27972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27973 }
27974 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27975 {
27976 PyThreadState* __tstate = wxPyBeginAllowThreads();
27977 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
27978 wxPyEndAllowThreads(__tstate);
27979 if (PyErr_Occurred()) SWIG_fail;
27980 }
27981 {
27982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27983 }
27984 return resultobj;
27985 fail:
27986 return NULL;
27987 }
27988
27989
27990 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27991 PyObject *resultobj = 0;
27992 wxDateTime *arg1 = (wxDateTime *) 0 ;
27993 wxDateTime *arg2 = (wxDateTime *) 0 ;
27994 bool result;
27995 void *argp1 = 0 ;
27996 int res1 = 0 ;
27997 void *argp2 = 0 ;
27998 int res2 = 0 ;
27999 PyObject * obj0 = 0 ;
28000 PyObject * obj1 = 0 ;
28001 char * kwnames[] = {
28002 (char *) "self",(char *) "other", NULL
28003 };
28004
28005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28007 if (!SWIG_IsOK(res1)) {
28008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28009 }
28010 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28011 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28012 if (!SWIG_IsOK(res2)) {
28013 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28014 }
28015 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28016 {
28017 PyThreadState* __tstate = wxPyBeginAllowThreads();
28018 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28019 wxPyEndAllowThreads(__tstate);
28020 if (PyErr_Occurred()) SWIG_fail;
28021 }
28022 {
28023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28024 }
28025 return resultobj;
28026 fail:
28027 return NULL;
28028 }
28029
28030
28031 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28032 PyObject *resultobj = 0;
28033 wxDateTime *arg1 = (wxDateTime *) 0 ;
28034 wxDateTime *arg2 = (wxDateTime *) 0 ;
28035 bool result;
28036 void *argp1 = 0 ;
28037 int res1 = 0 ;
28038 void *argp2 = 0 ;
28039 int res2 = 0 ;
28040 PyObject * obj0 = 0 ;
28041 PyObject * obj1 = 0 ;
28042 char * kwnames[] = {
28043 (char *) "self",(char *) "other", NULL
28044 };
28045
28046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28048 if (!SWIG_IsOK(res1)) {
28049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28050 }
28051 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28052 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28053 if (!SWIG_IsOK(res2)) {
28054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28055 }
28056 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28057 {
28058 PyThreadState* __tstate = wxPyBeginAllowThreads();
28059 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28060 wxPyEndAllowThreads(__tstate);
28061 if (PyErr_Occurred()) SWIG_fail;
28062 }
28063 {
28064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28065 }
28066 return resultobj;
28067 fail:
28068 return NULL;
28069 }
28070
28071
28072 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28073 PyObject *resultobj = 0;
28074 wxDateTime *arg1 = (wxDateTime *) 0 ;
28075 wxString *arg2 = 0 ;
28076 int result;
28077 void *argp1 = 0 ;
28078 int res1 = 0 ;
28079 bool temp2 = false ;
28080 PyObject * obj0 = 0 ;
28081 PyObject * obj1 = 0 ;
28082 char * kwnames[] = {
28083 (char *) "self",(char *) "date", NULL
28084 };
28085
28086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28088 if (!SWIG_IsOK(res1)) {
28089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28090 }
28091 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28092 {
28093 arg2 = wxString_in_helper(obj1);
28094 if (arg2 == NULL) SWIG_fail;
28095 temp2 = true;
28096 }
28097 {
28098 PyThreadState* __tstate = wxPyBeginAllowThreads();
28099 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28100 wxPyEndAllowThreads(__tstate);
28101 if (PyErr_Occurred()) SWIG_fail;
28102 }
28103 resultobj = SWIG_From_int(static_cast< int >(result));
28104 {
28105 if (temp2)
28106 delete arg2;
28107 }
28108 return resultobj;
28109 fail:
28110 {
28111 if (temp2)
28112 delete arg2;
28113 }
28114 return NULL;
28115 }
28116
28117
28118 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28119 PyObject *resultobj = 0;
28120 wxDateTime *arg1 = (wxDateTime *) 0 ;
28121 wxString *arg2 = 0 ;
28122 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28123 wxString *arg3 = (wxString *) &arg3_defvalue ;
28124 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28125 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28126 int result;
28127 void *argp1 = 0 ;
28128 int res1 = 0 ;
28129 bool temp2 = false ;
28130 bool temp3 = false ;
28131 void *argp4 = 0 ;
28132 int res4 = 0 ;
28133 PyObject * obj0 = 0 ;
28134 PyObject * obj1 = 0 ;
28135 PyObject * obj2 = 0 ;
28136 PyObject * obj3 = 0 ;
28137 char * kwnames[] = {
28138 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28139 };
28140
28141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28143 if (!SWIG_IsOK(res1)) {
28144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28145 }
28146 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28147 {
28148 arg2 = wxString_in_helper(obj1);
28149 if (arg2 == NULL) SWIG_fail;
28150 temp2 = true;
28151 }
28152 if (obj2) {
28153 {
28154 arg3 = wxString_in_helper(obj2);
28155 if (arg3 == NULL) SWIG_fail;
28156 temp3 = true;
28157 }
28158 }
28159 if (obj3) {
28160 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28161 if (!SWIG_IsOK(res4)) {
28162 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28163 }
28164 if (!argp4) {
28165 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28166 }
28167 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28168 }
28169 {
28170 PyThreadState* __tstate = wxPyBeginAllowThreads();
28171 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28172 wxPyEndAllowThreads(__tstate);
28173 if (PyErr_Occurred()) SWIG_fail;
28174 }
28175 resultobj = SWIG_From_int(static_cast< int >(result));
28176 {
28177 if (temp2)
28178 delete arg2;
28179 }
28180 {
28181 if (temp3)
28182 delete arg3;
28183 }
28184 return resultobj;
28185 fail:
28186 {
28187 if (temp2)
28188 delete arg2;
28189 }
28190 {
28191 if (temp3)
28192 delete arg3;
28193 }
28194 return NULL;
28195 }
28196
28197
28198 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28199 PyObject *resultobj = 0;
28200 wxDateTime *arg1 = (wxDateTime *) 0 ;
28201 wxString *arg2 = 0 ;
28202 int result;
28203 void *argp1 = 0 ;
28204 int res1 = 0 ;
28205 bool temp2 = false ;
28206 PyObject * obj0 = 0 ;
28207 PyObject * obj1 = 0 ;
28208 char * kwnames[] = {
28209 (char *) "self",(char *) "datetime", NULL
28210 };
28211
28212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28214 if (!SWIG_IsOK(res1)) {
28215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28216 }
28217 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28218 {
28219 arg2 = wxString_in_helper(obj1);
28220 if (arg2 == NULL) SWIG_fail;
28221 temp2 = true;
28222 }
28223 {
28224 PyThreadState* __tstate = wxPyBeginAllowThreads();
28225 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28226 wxPyEndAllowThreads(__tstate);
28227 if (PyErr_Occurred()) SWIG_fail;
28228 }
28229 resultobj = SWIG_From_int(static_cast< int >(result));
28230 {
28231 if (temp2)
28232 delete arg2;
28233 }
28234 return resultobj;
28235 fail:
28236 {
28237 if (temp2)
28238 delete arg2;
28239 }
28240 return NULL;
28241 }
28242
28243
28244 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28245 PyObject *resultobj = 0;
28246 wxDateTime *arg1 = (wxDateTime *) 0 ;
28247 wxString *arg2 = 0 ;
28248 int result;
28249 void *argp1 = 0 ;
28250 int res1 = 0 ;
28251 bool temp2 = false ;
28252 PyObject * obj0 = 0 ;
28253 PyObject * obj1 = 0 ;
28254 char * kwnames[] = {
28255 (char *) "self",(char *) "date", NULL
28256 };
28257
28258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28260 if (!SWIG_IsOK(res1)) {
28261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28262 }
28263 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28264 {
28265 arg2 = wxString_in_helper(obj1);
28266 if (arg2 == NULL) SWIG_fail;
28267 temp2 = true;
28268 }
28269 {
28270 PyThreadState* __tstate = wxPyBeginAllowThreads();
28271 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28272 wxPyEndAllowThreads(__tstate);
28273 if (PyErr_Occurred()) SWIG_fail;
28274 }
28275 resultobj = SWIG_From_int(static_cast< int >(result));
28276 {
28277 if (temp2)
28278 delete arg2;
28279 }
28280 return resultobj;
28281 fail:
28282 {
28283 if (temp2)
28284 delete arg2;
28285 }
28286 return NULL;
28287 }
28288
28289
28290 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28291 PyObject *resultobj = 0;
28292 wxDateTime *arg1 = (wxDateTime *) 0 ;
28293 wxString *arg2 = 0 ;
28294 int result;
28295 void *argp1 = 0 ;
28296 int res1 = 0 ;
28297 bool temp2 = false ;
28298 PyObject * obj0 = 0 ;
28299 PyObject * obj1 = 0 ;
28300 char * kwnames[] = {
28301 (char *) "self",(char *) "time", NULL
28302 };
28303
28304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28306 if (!SWIG_IsOK(res1)) {
28307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28308 }
28309 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28310 {
28311 arg2 = wxString_in_helper(obj1);
28312 if (arg2 == NULL) SWIG_fail;
28313 temp2 = true;
28314 }
28315 {
28316 PyThreadState* __tstate = wxPyBeginAllowThreads();
28317 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28318 wxPyEndAllowThreads(__tstate);
28319 if (PyErr_Occurred()) SWIG_fail;
28320 }
28321 resultobj = SWIG_From_int(static_cast< int >(result));
28322 {
28323 if (temp2)
28324 delete arg2;
28325 }
28326 return resultobj;
28327 fail:
28328 {
28329 if (temp2)
28330 delete arg2;
28331 }
28332 return NULL;
28333 }
28334
28335
28336 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28337 PyObject *resultobj = 0;
28338 wxDateTime *arg1 = (wxDateTime *) 0 ;
28339 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28340 wxString *arg2 = (wxString *) &arg2_defvalue ;
28341 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28342 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28343 wxString result;
28344 void *argp1 = 0 ;
28345 int res1 = 0 ;
28346 bool temp2 = false ;
28347 bool temp3 = false ;
28348 PyObject * obj0 = 0 ;
28349 PyObject * obj1 = 0 ;
28350 PyObject * obj2 = 0 ;
28351 char * kwnames[] = {
28352 (char *) "self",(char *) "format",(char *) "tz", NULL
28353 };
28354
28355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28357 if (!SWIG_IsOK(res1)) {
28358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28359 }
28360 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28361 if (obj1) {
28362 {
28363 arg2 = wxString_in_helper(obj1);
28364 if (arg2 == NULL) SWIG_fail;
28365 temp2 = true;
28366 }
28367 }
28368 if (obj2) {
28369 {
28370 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28371 temp3 = true;
28372 }
28373 }
28374 {
28375 PyThreadState* __tstate = wxPyBeginAllowThreads();
28376 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28377 wxPyEndAllowThreads(__tstate);
28378 if (PyErr_Occurred()) SWIG_fail;
28379 }
28380 {
28381 #if wxUSE_UNICODE
28382 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28383 #else
28384 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28385 #endif
28386 }
28387 {
28388 if (temp2)
28389 delete arg2;
28390 }
28391 {
28392 if (temp3) delete arg3;
28393 }
28394 return resultobj;
28395 fail:
28396 {
28397 if (temp2)
28398 delete arg2;
28399 }
28400 {
28401 if (temp3) delete arg3;
28402 }
28403 return NULL;
28404 }
28405
28406
28407 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28408 PyObject *resultobj = 0;
28409 wxDateTime *arg1 = (wxDateTime *) 0 ;
28410 wxString result;
28411 void *argp1 = 0 ;
28412 int res1 = 0 ;
28413 PyObject *swig_obj[1] ;
28414
28415 if (!args) SWIG_fail;
28416 swig_obj[0] = args;
28417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28418 if (!SWIG_IsOK(res1)) {
28419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28420 }
28421 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28422 {
28423 PyThreadState* __tstate = wxPyBeginAllowThreads();
28424 result = ((wxDateTime const *)arg1)->FormatDate();
28425 wxPyEndAllowThreads(__tstate);
28426 if (PyErr_Occurred()) SWIG_fail;
28427 }
28428 {
28429 #if wxUSE_UNICODE
28430 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28431 #else
28432 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28433 #endif
28434 }
28435 return resultobj;
28436 fail:
28437 return NULL;
28438 }
28439
28440
28441 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28442 PyObject *resultobj = 0;
28443 wxDateTime *arg1 = (wxDateTime *) 0 ;
28444 wxString result;
28445 void *argp1 = 0 ;
28446 int res1 = 0 ;
28447 PyObject *swig_obj[1] ;
28448
28449 if (!args) SWIG_fail;
28450 swig_obj[0] = args;
28451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28452 if (!SWIG_IsOK(res1)) {
28453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28454 }
28455 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28456 {
28457 PyThreadState* __tstate = wxPyBeginAllowThreads();
28458 result = ((wxDateTime const *)arg1)->FormatTime();
28459 wxPyEndAllowThreads(__tstate);
28460 if (PyErr_Occurred()) SWIG_fail;
28461 }
28462 {
28463 #if wxUSE_UNICODE
28464 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28465 #else
28466 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28467 #endif
28468 }
28469 return resultobj;
28470 fail:
28471 return NULL;
28472 }
28473
28474
28475 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28476 PyObject *resultobj = 0;
28477 wxDateTime *arg1 = (wxDateTime *) 0 ;
28478 wxString result;
28479 void *argp1 = 0 ;
28480 int res1 = 0 ;
28481 PyObject *swig_obj[1] ;
28482
28483 if (!args) SWIG_fail;
28484 swig_obj[0] = args;
28485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28486 if (!SWIG_IsOK(res1)) {
28487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28488 }
28489 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28490 {
28491 PyThreadState* __tstate = wxPyBeginAllowThreads();
28492 result = ((wxDateTime const *)arg1)->FormatISODate();
28493 wxPyEndAllowThreads(__tstate);
28494 if (PyErr_Occurred()) SWIG_fail;
28495 }
28496 {
28497 #if wxUSE_UNICODE
28498 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28499 #else
28500 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28501 #endif
28502 }
28503 return resultobj;
28504 fail:
28505 return NULL;
28506 }
28507
28508
28509 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28510 PyObject *resultobj = 0;
28511 wxDateTime *arg1 = (wxDateTime *) 0 ;
28512 wxString result;
28513 void *argp1 = 0 ;
28514 int res1 = 0 ;
28515 PyObject *swig_obj[1] ;
28516
28517 if (!args) SWIG_fail;
28518 swig_obj[0] = args;
28519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28520 if (!SWIG_IsOK(res1)) {
28521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28522 }
28523 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28524 {
28525 PyThreadState* __tstate = wxPyBeginAllowThreads();
28526 result = ((wxDateTime const *)arg1)->FormatISOTime();
28527 wxPyEndAllowThreads(__tstate);
28528 if (PyErr_Occurred()) SWIG_fail;
28529 }
28530 {
28531 #if wxUSE_UNICODE
28532 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28533 #else
28534 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28535 #endif
28536 }
28537 return resultobj;
28538 fail:
28539 return NULL;
28540 }
28541
28542
28543 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28544 PyObject *obj;
28545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28546 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28547 return SWIG_Py_Void();
28548 }
28549
28550 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28551 return SWIG_Python_InitShadowInstance(args);
28552 }
28553
28554 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28555 PyObject *resultobj = 0;
28556 long arg1 ;
28557 wxTimeSpan result;
28558 long val1 ;
28559 int ecode1 = 0 ;
28560 PyObject * obj0 = 0 ;
28561 char * kwnames[] = {
28562 (char *) "ms", NULL
28563 };
28564
28565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28566 ecode1 = SWIG_AsVal_long(obj0, &val1);
28567 if (!SWIG_IsOK(ecode1)) {
28568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28569 }
28570 arg1 = static_cast< long >(val1);
28571 {
28572 PyThreadState* __tstate = wxPyBeginAllowThreads();
28573 result = wxTimeSpan::Milliseconds(arg1);
28574 wxPyEndAllowThreads(__tstate);
28575 if (PyErr_Occurred()) SWIG_fail;
28576 }
28577 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28578 return resultobj;
28579 fail:
28580 return NULL;
28581 }
28582
28583
28584 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28585 PyObject *resultobj = 0;
28586 wxTimeSpan result;
28587
28588 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28589 {
28590 PyThreadState* __tstate = wxPyBeginAllowThreads();
28591 result = wxTimeSpan::Millisecond();
28592 wxPyEndAllowThreads(__tstate);
28593 if (PyErr_Occurred()) SWIG_fail;
28594 }
28595 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28596 return resultobj;
28597 fail:
28598 return NULL;
28599 }
28600
28601
28602 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28603 PyObject *resultobj = 0;
28604 long arg1 ;
28605 wxTimeSpan result;
28606 long val1 ;
28607 int ecode1 = 0 ;
28608 PyObject * obj0 = 0 ;
28609 char * kwnames[] = {
28610 (char *) "sec", NULL
28611 };
28612
28613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28614 ecode1 = SWIG_AsVal_long(obj0, &val1);
28615 if (!SWIG_IsOK(ecode1)) {
28616 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28617 }
28618 arg1 = static_cast< long >(val1);
28619 {
28620 PyThreadState* __tstate = wxPyBeginAllowThreads();
28621 result = wxTimeSpan::Seconds(arg1);
28622 wxPyEndAllowThreads(__tstate);
28623 if (PyErr_Occurred()) SWIG_fail;
28624 }
28625 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28626 return resultobj;
28627 fail:
28628 return NULL;
28629 }
28630
28631
28632 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28633 PyObject *resultobj = 0;
28634 wxTimeSpan result;
28635
28636 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28637 {
28638 PyThreadState* __tstate = wxPyBeginAllowThreads();
28639 result = wxTimeSpan::Second();
28640 wxPyEndAllowThreads(__tstate);
28641 if (PyErr_Occurred()) SWIG_fail;
28642 }
28643 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28644 return resultobj;
28645 fail:
28646 return NULL;
28647 }
28648
28649
28650 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28651 PyObject *resultobj = 0;
28652 long arg1 ;
28653 wxTimeSpan result;
28654 long val1 ;
28655 int ecode1 = 0 ;
28656 PyObject * obj0 = 0 ;
28657 char * kwnames[] = {
28658 (char *) "min", NULL
28659 };
28660
28661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28662 ecode1 = SWIG_AsVal_long(obj0, &val1);
28663 if (!SWIG_IsOK(ecode1)) {
28664 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28665 }
28666 arg1 = static_cast< long >(val1);
28667 {
28668 PyThreadState* __tstate = wxPyBeginAllowThreads();
28669 result = wxTimeSpan::Minutes(arg1);
28670 wxPyEndAllowThreads(__tstate);
28671 if (PyErr_Occurred()) SWIG_fail;
28672 }
28673 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28674 return resultobj;
28675 fail:
28676 return NULL;
28677 }
28678
28679
28680 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28681 PyObject *resultobj = 0;
28682 wxTimeSpan result;
28683
28684 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28685 {
28686 PyThreadState* __tstate = wxPyBeginAllowThreads();
28687 result = wxTimeSpan::Minute();
28688 wxPyEndAllowThreads(__tstate);
28689 if (PyErr_Occurred()) SWIG_fail;
28690 }
28691 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28692 return resultobj;
28693 fail:
28694 return NULL;
28695 }
28696
28697
28698 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28699 PyObject *resultobj = 0;
28700 long arg1 ;
28701 wxTimeSpan result;
28702 long val1 ;
28703 int ecode1 = 0 ;
28704 PyObject * obj0 = 0 ;
28705 char * kwnames[] = {
28706 (char *) "hours", NULL
28707 };
28708
28709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28710 ecode1 = SWIG_AsVal_long(obj0, &val1);
28711 if (!SWIG_IsOK(ecode1)) {
28712 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28713 }
28714 arg1 = static_cast< long >(val1);
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 result = wxTimeSpan::Hours(arg1);
28718 wxPyEndAllowThreads(__tstate);
28719 if (PyErr_Occurred()) SWIG_fail;
28720 }
28721 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28722 return resultobj;
28723 fail:
28724 return NULL;
28725 }
28726
28727
28728 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28729 PyObject *resultobj = 0;
28730 wxTimeSpan result;
28731
28732 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28733 {
28734 PyThreadState* __tstate = wxPyBeginAllowThreads();
28735 result = wxTimeSpan::Hour();
28736 wxPyEndAllowThreads(__tstate);
28737 if (PyErr_Occurred()) SWIG_fail;
28738 }
28739 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28740 return resultobj;
28741 fail:
28742 return NULL;
28743 }
28744
28745
28746 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28747 PyObject *resultobj = 0;
28748 long arg1 ;
28749 wxTimeSpan result;
28750 long val1 ;
28751 int ecode1 = 0 ;
28752 PyObject * obj0 = 0 ;
28753 char * kwnames[] = {
28754 (char *) "days", NULL
28755 };
28756
28757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28758 ecode1 = SWIG_AsVal_long(obj0, &val1);
28759 if (!SWIG_IsOK(ecode1)) {
28760 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28761 }
28762 arg1 = static_cast< long >(val1);
28763 {
28764 PyThreadState* __tstate = wxPyBeginAllowThreads();
28765 result = wxTimeSpan::Days(arg1);
28766 wxPyEndAllowThreads(__tstate);
28767 if (PyErr_Occurred()) SWIG_fail;
28768 }
28769 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28770 return resultobj;
28771 fail:
28772 return NULL;
28773 }
28774
28775
28776 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28777 PyObject *resultobj = 0;
28778 wxTimeSpan result;
28779
28780 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28781 {
28782 PyThreadState* __tstate = wxPyBeginAllowThreads();
28783 result = wxTimeSpan::Day();
28784 wxPyEndAllowThreads(__tstate);
28785 if (PyErr_Occurred()) SWIG_fail;
28786 }
28787 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28788 return resultobj;
28789 fail:
28790 return NULL;
28791 }
28792
28793
28794 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28795 PyObject *resultobj = 0;
28796 long arg1 ;
28797 wxTimeSpan result;
28798 long val1 ;
28799 int ecode1 = 0 ;
28800 PyObject * obj0 = 0 ;
28801 char * kwnames[] = {
28802 (char *) "days", NULL
28803 };
28804
28805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28806 ecode1 = SWIG_AsVal_long(obj0, &val1);
28807 if (!SWIG_IsOK(ecode1)) {
28808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28809 }
28810 arg1 = static_cast< long >(val1);
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 result = wxTimeSpan::Weeks(arg1);
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28825 PyObject *resultobj = 0;
28826 wxTimeSpan result;
28827
28828 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28829 {
28830 PyThreadState* __tstate = wxPyBeginAllowThreads();
28831 result = wxTimeSpan::Week();
28832 wxPyEndAllowThreads(__tstate);
28833 if (PyErr_Occurred()) SWIG_fail;
28834 }
28835 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28836 return resultobj;
28837 fail:
28838 return NULL;
28839 }
28840
28841
28842 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28843 PyObject *resultobj = 0;
28844 long arg1 = (long) 0 ;
28845 long arg2 = (long) 0 ;
28846 long arg3 = (long) 0 ;
28847 long arg4 = (long) 0 ;
28848 wxTimeSpan *result = 0 ;
28849 long val1 ;
28850 int ecode1 = 0 ;
28851 long val2 ;
28852 int ecode2 = 0 ;
28853 long val3 ;
28854 int ecode3 = 0 ;
28855 long val4 ;
28856 int ecode4 = 0 ;
28857 PyObject * obj0 = 0 ;
28858 PyObject * obj1 = 0 ;
28859 PyObject * obj2 = 0 ;
28860 PyObject * obj3 = 0 ;
28861 char * kwnames[] = {
28862 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28863 };
28864
28865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28866 if (obj0) {
28867 ecode1 = SWIG_AsVal_long(obj0, &val1);
28868 if (!SWIG_IsOK(ecode1)) {
28869 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28870 }
28871 arg1 = static_cast< long >(val1);
28872 }
28873 if (obj1) {
28874 ecode2 = SWIG_AsVal_long(obj1, &val2);
28875 if (!SWIG_IsOK(ecode2)) {
28876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28877 }
28878 arg2 = static_cast< long >(val2);
28879 }
28880 if (obj2) {
28881 ecode3 = SWIG_AsVal_long(obj2, &val3);
28882 if (!SWIG_IsOK(ecode3)) {
28883 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28884 }
28885 arg3 = static_cast< long >(val3);
28886 }
28887 if (obj3) {
28888 ecode4 = SWIG_AsVal_long(obj3, &val4);
28889 if (!SWIG_IsOK(ecode4)) {
28890 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28891 }
28892 arg4 = static_cast< long >(val4);
28893 }
28894 {
28895 PyThreadState* __tstate = wxPyBeginAllowThreads();
28896 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28897 wxPyEndAllowThreads(__tstate);
28898 if (PyErr_Occurred()) SWIG_fail;
28899 }
28900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28901 return resultobj;
28902 fail:
28903 return NULL;
28904 }
28905
28906
28907 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28908 PyObject *resultobj = 0;
28909 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28910 void *argp1 = 0 ;
28911 int res1 = 0 ;
28912 PyObject *swig_obj[1] ;
28913
28914 if (!args) SWIG_fail;
28915 swig_obj[0] = args;
28916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28917 if (!SWIG_IsOK(res1)) {
28918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28919 }
28920 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28921 {
28922 PyThreadState* __tstate = wxPyBeginAllowThreads();
28923 delete arg1;
28924
28925 wxPyEndAllowThreads(__tstate);
28926 if (PyErr_Occurred()) SWIG_fail;
28927 }
28928 resultobj = SWIG_Py_Void();
28929 return resultobj;
28930 fail:
28931 return NULL;
28932 }
28933
28934
28935 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28936 PyObject *resultobj = 0;
28937 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28938 wxTimeSpan *arg2 = 0 ;
28939 wxTimeSpan *result = 0 ;
28940 void *argp1 = 0 ;
28941 int res1 = 0 ;
28942 void *argp2 = 0 ;
28943 int res2 = 0 ;
28944 PyObject * obj0 = 0 ;
28945 PyObject * obj1 = 0 ;
28946 char * kwnames[] = {
28947 (char *) "self",(char *) "diff", NULL
28948 };
28949
28950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
28951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28952 if (!SWIG_IsOK(res1)) {
28953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28954 }
28955 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28956 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28957 if (!SWIG_IsOK(res2)) {
28958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28959 }
28960 if (!argp2) {
28961 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28962 }
28963 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28964 {
28965 PyThreadState* __tstate = wxPyBeginAllowThreads();
28966 {
28967 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
28968 result = (wxTimeSpan *) &_result_ref;
28969 }
28970 wxPyEndAllowThreads(__tstate);
28971 if (PyErr_Occurred()) SWIG_fail;
28972 }
28973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28974 return resultobj;
28975 fail:
28976 return NULL;
28977 }
28978
28979
28980 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28981 PyObject *resultobj = 0;
28982 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28983 wxTimeSpan *arg2 = 0 ;
28984 wxTimeSpan *result = 0 ;
28985 void *argp1 = 0 ;
28986 int res1 = 0 ;
28987 void *argp2 = 0 ;
28988 int res2 = 0 ;
28989 PyObject * obj0 = 0 ;
28990 PyObject * obj1 = 0 ;
28991 char * kwnames[] = {
28992 (char *) "self",(char *) "diff", NULL
28993 };
28994
28995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
28996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28997 if (!SWIG_IsOK(res1)) {
28998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28999 }
29000 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29001 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29002 if (!SWIG_IsOK(res2)) {
29003 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29004 }
29005 if (!argp2) {
29006 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29007 }
29008 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29009 {
29010 PyThreadState* __tstate = wxPyBeginAllowThreads();
29011 {
29012 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29013 result = (wxTimeSpan *) &_result_ref;
29014 }
29015 wxPyEndAllowThreads(__tstate);
29016 if (PyErr_Occurred()) SWIG_fail;
29017 }
29018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29019 return resultobj;
29020 fail:
29021 return NULL;
29022 }
29023
29024
29025 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29026 PyObject *resultobj = 0;
29027 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29028 int arg2 ;
29029 wxTimeSpan *result = 0 ;
29030 void *argp1 = 0 ;
29031 int res1 = 0 ;
29032 int val2 ;
29033 int ecode2 = 0 ;
29034 PyObject * obj0 = 0 ;
29035 PyObject * obj1 = 0 ;
29036 char * kwnames[] = {
29037 (char *) "self",(char *) "n", NULL
29038 };
29039
29040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29042 if (!SWIG_IsOK(res1)) {
29043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29044 }
29045 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29046 ecode2 = SWIG_AsVal_int(obj1, &val2);
29047 if (!SWIG_IsOK(ecode2)) {
29048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29049 }
29050 arg2 = static_cast< int >(val2);
29051 {
29052 PyThreadState* __tstate = wxPyBeginAllowThreads();
29053 {
29054 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29055 result = (wxTimeSpan *) &_result_ref;
29056 }
29057 wxPyEndAllowThreads(__tstate);
29058 if (PyErr_Occurred()) SWIG_fail;
29059 }
29060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29061 return resultobj;
29062 fail:
29063 return NULL;
29064 }
29065
29066
29067 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29068 PyObject *resultobj = 0;
29069 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29070 wxTimeSpan *result = 0 ;
29071 void *argp1 = 0 ;
29072 int res1 = 0 ;
29073 PyObject *swig_obj[1] ;
29074
29075 if (!args) SWIG_fail;
29076 swig_obj[0] = args;
29077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29078 if (!SWIG_IsOK(res1)) {
29079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29080 }
29081 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29082 {
29083 PyThreadState* __tstate = wxPyBeginAllowThreads();
29084 {
29085 wxTimeSpan &_result_ref = (arg1)->Neg();
29086 result = (wxTimeSpan *) &_result_ref;
29087 }
29088 wxPyEndAllowThreads(__tstate);
29089 if (PyErr_Occurred()) SWIG_fail;
29090 }
29091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29092 return resultobj;
29093 fail:
29094 return NULL;
29095 }
29096
29097
29098 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29099 PyObject *resultobj = 0;
29100 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29101 wxTimeSpan result;
29102 void *argp1 = 0 ;
29103 int res1 = 0 ;
29104 PyObject *swig_obj[1] ;
29105
29106 if (!args) SWIG_fail;
29107 swig_obj[0] = args;
29108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29109 if (!SWIG_IsOK(res1)) {
29110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29111 }
29112 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29113 {
29114 PyThreadState* __tstate = wxPyBeginAllowThreads();
29115 result = ((wxTimeSpan const *)arg1)->Abs();
29116 wxPyEndAllowThreads(__tstate);
29117 if (PyErr_Occurred()) SWIG_fail;
29118 }
29119 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29120 return resultobj;
29121 fail:
29122 return NULL;
29123 }
29124
29125
29126 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29127 PyObject *resultobj = 0;
29128 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29129 wxTimeSpan *arg2 = 0 ;
29130 wxTimeSpan *result = 0 ;
29131 void *argp1 = 0 ;
29132 int res1 = 0 ;
29133 void *argp2 = 0 ;
29134 int res2 = 0 ;
29135 PyObject * obj0 = 0 ;
29136 PyObject * obj1 = 0 ;
29137 char * kwnames[] = {
29138 (char *) "self",(char *) "diff", NULL
29139 };
29140
29141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29143 if (!SWIG_IsOK(res1)) {
29144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29145 }
29146 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29147 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29148 if (!SWIG_IsOK(res2)) {
29149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29150 }
29151 if (!argp2) {
29152 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29153 }
29154 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29155 {
29156 PyThreadState* __tstate = wxPyBeginAllowThreads();
29157 {
29158 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29159 result = (wxTimeSpan *) &_result_ref;
29160 }
29161 wxPyEndAllowThreads(__tstate);
29162 if (PyErr_Occurred()) SWIG_fail;
29163 }
29164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29165 return resultobj;
29166 fail:
29167 return NULL;
29168 }
29169
29170
29171 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29172 PyObject *resultobj = 0;
29173 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29174 wxTimeSpan *arg2 = 0 ;
29175 wxTimeSpan *result = 0 ;
29176 void *argp1 = 0 ;
29177 int res1 = 0 ;
29178 void *argp2 = 0 ;
29179 int res2 = 0 ;
29180 PyObject * obj0 = 0 ;
29181 PyObject * obj1 = 0 ;
29182 char * kwnames[] = {
29183 (char *) "self",(char *) "diff", NULL
29184 };
29185
29186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29188 if (!SWIG_IsOK(res1)) {
29189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29190 }
29191 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29192 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29193 if (!SWIG_IsOK(res2)) {
29194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29195 }
29196 if (!argp2) {
29197 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29198 }
29199 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29200 {
29201 PyThreadState* __tstate = wxPyBeginAllowThreads();
29202 {
29203 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29204 result = (wxTimeSpan *) &_result_ref;
29205 }
29206 wxPyEndAllowThreads(__tstate);
29207 if (PyErr_Occurred()) SWIG_fail;
29208 }
29209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29210 return resultobj;
29211 fail:
29212 return NULL;
29213 }
29214
29215
29216 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29217 PyObject *resultobj = 0;
29218 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29219 int arg2 ;
29220 wxTimeSpan *result = 0 ;
29221 void *argp1 = 0 ;
29222 int res1 = 0 ;
29223 int val2 ;
29224 int ecode2 = 0 ;
29225 PyObject * obj0 = 0 ;
29226 PyObject * obj1 = 0 ;
29227 char * kwnames[] = {
29228 (char *) "self",(char *) "n", NULL
29229 };
29230
29231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29233 if (!SWIG_IsOK(res1)) {
29234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29235 }
29236 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29237 ecode2 = SWIG_AsVal_int(obj1, &val2);
29238 if (!SWIG_IsOK(ecode2)) {
29239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29240 }
29241 arg2 = static_cast< int >(val2);
29242 {
29243 PyThreadState* __tstate = wxPyBeginAllowThreads();
29244 {
29245 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29246 result = (wxTimeSpan *) &_result_ref;
29247 }
29248 wxPyEndAllowThreads(__tstate);
29249 if (PyErr_Occurred()) SWIG_fail;
29250 }
29251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29252 return resultobj;
29253 fail:
29254 return NULL;
29255 }
29256
29257
29258 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29259 PyObject *resultobj = 0;
29260 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29261 wxTimeSpan *result = 0 ;
29262 void *argp1 = 0 ;
29263 int res1 = 0 ;
29264 PyObject *swig_obj[1] ;
29265
29266 if (!args) SWIG_fail;
29267 swig_obj[0] = args;
29268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29269 if (!SWIG_IsOK(res1)) {
29270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29271 }
29272 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29273 {
29274 PyThreadState* __tstate = wxPyBeginAllowThreads();
29275 {
29276 wxTimeSpan &_result_ref = (arg1)->operator -();
29277 result = (wxTimeSpan *) &_result_ref;
29278 }
29279 wxPyEndAllowThreads(__tstate);
29280 if (PyErr_Occurred()) SWIG_fail;
29281 }
29282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29283 return resultobj;
29284 fail:
29285 return NULL;
29286 }
29287
29288
29289 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29290 PyObject *resultobj = 0;
29291 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29292 wxTimeSpan *arg2 = 0 ;
29293 wxTimeSpan result;
29294 void *argp1 = 0 ;
29295 int res1 = 0 ;
29296 void *argp2 = 0 ;
29297 int res2 = 0 ;
29298 PyObject * obj0 = 0 ;
29299 PyObject * obj1 = 0 ;
29300 char * kwnames[] = {
29301 (char *) "self",(char *) "other", NULL
29302 };
29303
29304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29306 if (!SWIG_IsOK(res1)) {
29307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29308 }
29309 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29310 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29311 if (!SWIG_IsOK(res2)) {
29312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29313 }
29314 if (!argp2) {
29315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29316 }
29317 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29318 {
29319 PyThreadState* __tstate = wxPyBeginAllowThreads();
29320 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29321 wxPyEndAllowThreads(__tstate);
29322 if (PyErr_Occurred()) SWIG_fail;
29323 }
29324 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29325 return resultobj;
29326 fail:
29327 return NULL;
29328 }
29329
29330
29331 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29332 PyObject *resultobj = 0;
29333 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29334 wxTimeSpan *arg2 = 0 ;
29335 wxTimeSpan result;
29336 void *argp1 = 0 ;
29337 int res1 = 0 ;
29338 void *argp2 = 0 ;
29339 int res2 = 0 ;
29340 PyObject * obj0 = 0 ;
29341 PyObject * obj1 = 0 ;
29342 char * kwnames[] = {
29343 (char *) "self",(char *) "other", NULL
29344 };
29345
29346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29348 if (!SWIG_IsOK(res1)) {
29349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29350 }
29351 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29352 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29353 if (!SWIG_IsOK(res2)) {
29354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29355 }
29356 if (!argp2) {
29357 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29358 }
29359 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29360 {
29361 PyThreadState* __tstate = wxPyBeginAllowThreads();
29362 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29363 wxPyEndAllowThreads(__tstate);
29364 if (PyErr_Occurred()) SWIG_fail;
29365 }
29366 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29367 return resultobj;
29368 fail:
29369 return NULL;
29370 }
29371
29372
29373 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29374 PyObject *resultobj = 0;
29375 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29376 int arg2 ;
29377 wxTimeSpan result;
29378 void *argp1 = 0 ;
29379 int res1 = 0 ;
29380 int val2 ;
29381 int ecode2 = 0 ;
29382 PyObject * obj0 = 0 ;
29383 PyObject * obj1 = 0 ;
29384 char * kwnames[] = {
29385 (char *) "self",(char *) "n", NULL
29386 };
29387
29388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29390 if (!SWIG_IsOK(res1)) {
29391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29392 }
29393 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29394 ecode2 = SWIG_AsVal_int(obj1, &val2);
29395 if (!SWIG_IsOK(ecode2)) {
29396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29397 }
29398 arg2 = static_cast< int >(val2);
29399 {
29400 PyThreadState* __tstate = wxPyBeginAllowThreads();
29401 result = wxTimeSpan___mul__(arg1,arg2);
29402 wxPyEndAllowThreads(__tstate);
29403 if (PyErr_Occurred()) SWIG_fail;
29404 }
29405 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29406 return resultobj;
29407 fail:
29408 return NULL;
29409 }
29410
29411
29412 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29413 PyObject *resultobj = 0;
29414 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29415 int arg2 ;
29416 wxTimeSpan result;
29417 void *argp1 = 0 ;
29418 int res1 = 0 ;
29419 int val2 ;
29420 int ecode2 = 0 ;
29421 PyObject * obj0 = 0 ;
29422 PyObject * obj1 = 0 ;
29423 char * kwnames[] = {
29424 (char *) "self",(char *) "n", NULL
29425 };
29426
29427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29429 if (!SWIG_IsOK(res1)) {
29430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29431 }
29432 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29433 ecode2 = SWIG_AsVal_int(obj1, &val2);
29434 if (!SWIG_IsOK(ecode2)) {
29435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29436 }
29437 arg2 = static_cast< int >(val2);
29438 {
29439 PyThreadState* __tstate = wxPyBeginAllowThreads();
29440 result = wxTimeSpan___rmul__(arg1,arg2);
29441 wxPyEndAllowThreads(__tstate);
29442 if (PyErr_Occurred()) SWIG_fail;
29443 }
29444 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29445 return resultobj;
29446 fail:
29447 return NULL;
29448 }
29449
29450
29451 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29452 PyObject *resultobj = 0;
29453 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29454 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29455 bool result;
29456 void *argp1 = 0 ;
29457 int res1 = 0 ;
29458 void *argp2 = 0 ;
29459 int res2 = 0 ;
29460 PyObject * obj0 = 0 ;
29461 PyObject * obj1 = 0 ;
29462 char * kwnames[] = {
29463 (char *) "self",(char *) "other", NULL
29464 };
29465
29466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29468 if (!SWIG_IsOK(res1)) {
29469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29470 }
29471 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29472 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29473 if (!SWIG_IsOK(res2)) {
29474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29475 }
29476 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29477 {
29478 PyThreadState* __tstate = wxPyBeginAllowThreads();
29479 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29480 wxPyEndAllowThreads(__tstate);
29481 if (PyErr_Occurred()) SWIG_fail;
29482 }
29483 {
29484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29485 }
29486 return resultobj;
29487 fail:
29488 return NULL;
29489 }
29490
29491
29492 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29493 PyObject *resultobj = 0;
29494 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29495 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29496 bool result;
29497 void *argp1 = 0 ;
29498 int res1 = 0 ;
29499 void *argp2 = 0 ;
29500 int res2 = 0 ;
29501 PyObject * obj0 = 0 ;
29502 PyObject * obj1 = 0 ;
29503 char * kwnames[] = {
29504 (char *) "self",(char *) "other", NULL
29505 };
29506
29507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29509 if (!SWIG_IsOK(res1)) {
29510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29511 }
29512 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29513 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29514 if (!SWIG_IsOK(res2)) {
29515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29516 }
29517 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29518 {
29519 PyThreadState* __tstate = wxPyBeginAllowThreads();
29520 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29521 wxPyEndAllowThreads(__tstate);
29522 if (PyErr_Occurred()) SWIG_fail;
29523 }
29524 {
29525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29526 }
29527 return resultobj;
29528 fail:
29529 return NULL;
29530 }
29531
29532
29533 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29534 PyObject *resultobj = 0;
29535 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29536 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29537 bool result;
29538 void *argp1 = 0 ;
29539 int res1 = 0 ;
29540 void *argp2 = 0 ;
29541 int res2 = 0 ;
29542 PyObject * obj0 = 0 ;
29543 PyObject * obj1 = 0 ;
29544 char * kwnames[] = {
29545 (char *) "self",(char *) "other", NULL
29546 };
29547
29548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29550 if (!SWIG_IsOK(res1)) {
29551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29552 }
29553 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29554 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29555 if (!SWIG_IsOK(res2)) {
29556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29557 }
29558 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29559 {
29560 PyThreadState* __tstate = wxPyBeginAllowThreads();
29561 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29562 wxPyEndAllowThreads(__tstate);
29563 if (PyErr_Occurred()) SWIG_fail;
29564 }
29565 {
29566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29567 }
29568 return resultobj;
29569 fail:
29570 return NULL;
29571 }
29572
29573
29574 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29575 PyObject *resultobj = 0;
29576 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29577 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29578 bool result;
29579 void *argp1 = 0 ;
29580 int res1 = 0 ;
29581 void *argp2 = 0 ;
29582 int res2 = 0 ;
29583 PyObject * obj0 = 0 ;
29584 PyObject * obj1 = 0 ;
29585 char * kwnames[] = {
29586 (char *) "self",(char *) "other", NULL
29587 };
29588
29589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29591 if (!SWIG_IsOK(res1)) {
29592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29593 }
29594 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29595 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29596 if (!SWIG_IsOK(res2)) {
29597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29598 }
29599 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29600 {
29601 PyThreadState* __tstate = wxPyBeginAllowThreads();
29602 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29603 wxPyEndAllowThreads(__tstate);
29604 if (PyErr_Occurred()) SWIG_fail;
29605 }
29606 {
29607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29608 }
29609 return resultobj;
29610 fail:
29611 return NULL;
29612 }
29613
29614
29615 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29616 PyObject *resultobj = 0;
29617 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29618 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29619 bool result;
29620 void *argp1 = 0 ;
29621 int res1 = 0 ;
29622 void *argp2 = 0 ;
29623 int res2 = 0 ;
29624 PyObject * obj0 = 0 ;
29625 PyObject * obj1 = 0 ;
29626 char * kwnames[] = {
29627 (char *) "self",(char *) "other", NULL
29628 };
29629
29630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29632 if (!SWIG_IsOK(res1)) {
29633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29634 }
29635 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29636 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29637 if (!SWIG_IsOK(res2)) {
29638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29639 }
29640 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29641 {
29642 PyThreadState* __tstate = wxPyBeginAllowThreads();
29643 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29644 wxPyEndAllowThreads(__tstate);
29645 if (PyErr_Occurred()) SWIG_fail;
29646 }
29647 {
29648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29649 }
29650 return resultobj;
29651 fail:
29652 return NULL;
29653 }
29654
29655
29656 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29657 PyObject *resultobj = 0;
29658 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29659 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29660 bool result;
29661 void *argp1 = 0 ;
29662 int res1 = 0 ;
29663 void *argp2 = 0 ;
29664 int res2 = 0 ;
29665 PyObject * obj0 = 0 ;
29666 PyObject * obj1 = 0 ;
29667 char * kwnames[] = {
29668 (char *) "self",(char *) "other", NULL
29669 };
29670
29671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29673 if (!SWIG_IsOK(res1)) {
29674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29675 }
29676 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29677 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29678 if (!SWIG_IsOK(res2)) {
29679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29680 }
29681 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29682 {
29683 PyThreadState* __tstate = wxPyBeginAllowThreads();
29684 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29685 wxPyEndAllowThreads(__tstate);
29686 if (PyErr_Occurred()) SWIG_fail;
29687 }
29688 {
29689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29690 }
29691 return resultobj;
29692 fail:
29693 return NULL;
29694 }
29695
29696
29697 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29698 PyObject *resultobj = 0;
29699 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29700 bool result;
29701 void *argp1 = 0 ;
29702 int res1 = 0 ;
29703 PyObject *swig_obj[1] ;
29704
29705 if (!args) SWIG_fail;
29706 swig_obj[0] = args;
29707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29708 if (!SWIG_IsOK(res1)) {
29709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29710 }
29711 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29712 {
29713 PyThreadState* __tstate = wxPyBeginAllowThreads();
29714 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29715 wxPyEndAllowThreads(__tstate);
29716 if (PyErr_Occurred()) SWIG_fail;
29717 }
29718 {
29719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29720 }
29721 return resultobj;
29722 fail:
29723 return NULL;
29724 }
29725
29726
29727 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29728 PyObject *resultobj = 0;
29729 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29730 bool result;
29731 void *argp1 = 0 ;
29732 int res1 = 0 ;
29733 PyObject *swig_obj[1] ;
29734
29735 if (!args) SWIG_fail;
29736 swig_obj[0] = args;
29737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29738 if (!SWIG_IsOK(res1)) {
29739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29740 }
29741 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29742 {
29743 PyThreadState* __tstate = wxPyBeginAllowThreads();
29744 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29745 wxPyEndAllowThreads(__tstate);
29746 if (PyErr_Occurred()) SWIG_fail;
29747 }
29748 {
29749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29750 }
29751 return resultobj;
29752 fail:
29753 return NULL;
29754 }
29755
29756
29757 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29758 PyObject *resultobj = 0;
29759 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29760 bool result;
29761 void *argp1 = 0 ;
29762 int res1 = 0 ;
29763 PyObject *swig_obj[1] ;
29764
29765 if (!args) SWIG_fail;
29766 swig_obj[0] = args;
29767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29768 if (!SWIG_IsOK(res1)) {
29769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29770 }
29771 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29772 {
29773 PyThreadState* __tstate = wxPyBeginAllowThreads();
29774 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29775 wxPyEndAllowThreads(__tstate);
29776 if (PyErr_Occurred()) SWIG_fail;
29777 }
29778 {
29779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29780 }
29781 return resultobj;
29782 fail:
29783 return NULL;
29784 }
29785
29786
29787 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29788 PyObject *resultobj = 0;
29789 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29790 wxTimeSpan *arg2 = 0 ;
29791 bool result;
29792 void *argp1 = 0 ;
29793 int res1 = 0 ;
29794 void *argp2 = 0 ;
29795 int res2 = 0 ;
29796 PyObject * obj0 = 0 ;
29797 PyObject * obj1 = 0 ;
29798 char * kwnames[] = {
29799 (char *) "self",(char *) "ts", NULL
29800 };
29801
29802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29804 if (!SWIG_IsOK(res1)) {
29805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29806 }
29807 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29808 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29809 if (!SWIG_IsOK(res2)) {
29810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29811 }
29812 if (!argp2) {
29813 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29814 }
29815 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29816 {
29817 PyThreadState* __tstate = wxPyBeginAllowThreads();
29818 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29819 wxPyEndAllowThreads(__tstate);
29820 if (PyErr_Occurred()) SWIG_fail;
29821 }
29822 {
29823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29824 }
29825 return resultobj;
29826 fail:
29827 return NULL;
29828 }
29829
29830
29831 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29832 PyObject *resultobj = 0;
29833 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29834 wxTimeSpan *arg2 = 0 ;
29835 bool result;
29836 void *argp1 = 0 ;
29837 int res1 = 0 ;
29838 void *argp2 = 0 ;
29839 int res2 = 0 ;
29840 PyObject * obj0 = 0 ;
29841 PyObject * obj1 = 0 ;
29842 char * kwnames[] = {
29843 (char *) "self",(char *) "ts", NULL
29844 };
29845
29846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29848 if (!SWIG_IsOK(res1)) {
29849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29850 }
29851 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29852 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29853 if (!SWIG_IsOK(res2)) {
29854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29855 }
29856 if (!argp2) {
29857 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29858 }
29859 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29860 {
29861 PyThreadState* __tstate = wxPyBeginAllowThreads();
29862 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29863 wxPyEndAllowThreads(__tstate);
29864 if (PyErr_Occurred()) SWIG_fail;
29865 }
29866 {
29867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29868 }
29869 return resultobj;
29870 fail:
29871 return NULL;
29872 }
29873
29874
29875 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29876 PyObject *resultobj = 0;
29877 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29878 wxTimeSpan *arg2 = 0 ;
29879 bool result;
29880 void *argp1 = 0 ;
29881 int res1 = 0 ;
29882 void *argp2 = 0 ;
29883 int res2 = 0 ;
29884 PyObject * obj0 = 0 ;
29885 PyObject * obj1 = 0 ;
29886 char * kwnames[] = {
29887 (char *) "self",(char *) "t", NULL
29888 };
29889
29890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29892 if (!SWIG_IsOK(res1)) {
29893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29894 }
29895 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29896 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29897 if (!SWIG_IsOK(res2)) {
29898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29899 }
29900 if (!argp2) {
29901 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29902 }
29903 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29904 {
29905 PyThreadState* __tstate = wxPyBeginAllowThreads();
29906 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
29907 wxPyEndAllowThreads(__tstate);
29908 if (PyErr_Occurred()) SWIG_fail;
29909 }
29910 {
29911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29912 }
29913 return resultobj;
29914 fail:
29915 return NULL;
29916 }
29917
29918
29919 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29920 PyObject *resultobj = 0;
29921 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29922 int result;
29923 void *argp1 = 0 ;
29924 int res1 = 0 ;
29925 PyObject *swig_obj[1] ;
29926
29927 if (!args) SWIG_fail;
29928 swig_obj[0] = args;
29929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29930 if (!SWIG_IsOK(res1)) {
29931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29932 }
29933 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29934 {
29935 PyThreadState* __tstate = wxPyBeginAllowThreads();
29936 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
29937 wxPyEndAllowThreads(__tstate);
29938 if (PyErr_Occurred()) SWIG_fail;
29939 }
29940 resultobj = SWIG_From_int(static_cast< int >(result));
29941 return resultobj;
29942 fail:
29943 return NULL;
29944 }
29945
29946
29947 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29948 PyObject *resultobj = 0;
29949 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29950 int result;
29951 void *argp1 = 0 ;
29952 int res1 = 0 ;
29953 PyObject *swig_obj[1] ;
29954
29955 if (!args) SWIG_fail;
29956 swig_obj[0] = args;
29957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29958 if (!SWIG_IsOK(res1)) {
29959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29960 }
29961 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29962 {
29963 PyThreadState* __tstate = wxPyBeginAllowThreads();
29964 result = (int)((wxTimeSpan const *)arg1)->GetDays();
29965 wxPyEndAllowThreads(__tstate);
29966 if (PyErr_Occurred()) SWIG_fail;
29967 }
29968 resultobj = SWIG_From_int(static_cast< int >(result));
29969 return resultobj;
29970 fail:
29971 return NULL;
29972 }
29973
29974
29975 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29976 PyObject *resultobj = 0;
29977 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29978 int result;
29979 void *argp1 = 0 ;
29980 int res1 = 0 ;
29981 PyObject *swig_obj[1] ;
29982
29983 if (!args) SWIG_fail;
29984 swig_obj[0] = args;
29985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29986 if (!SWIG_IsOK(res1)) {
29987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29988 }
29989 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29990 {
29991 PyThreadState* __tstate = wxPyBeginAllowThreads();
29992 result = (int)((wxTimeSpan const *)arg1)->GetHours();
29993 wxPyEndAllowThreads(__tstate);
29994 if (PyErr_Occurred()) SWIG_fail;
29995 }
29996 resultobj = SWIG_From_int(static_cast< int >(result));
29997 return resultobj;
29998 fail:
29999 return NULL;
30000 }
30001
30002
30003 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30004 PyObject *resultobj = 0;
30005 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30006 int result;
30007 void *argp1 = 0 ;
30008 int res1 = 0 ;
30009 PyObject *swig_obj[1] ;
30010
30011 if (!args) SWIG_fail;
30012 swig_obj[0] = args;
30013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30014 if (!SWIG_IsOK(res1)) {
30015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30016 }
30017 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30018 {
30019 PyThreadState* __tstate = wxPyBeginAllowThreads();
30020 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30021 wxPyEndAllowThreads(__tstate);
30022 if (PyErr_Occurred()) SWIG_fail;
30023 }
30024 resultobj = SWIG_From_int(static_cast< int >(result));
30025 return resultobj;
30026 fail:
30027 return NULL;
30028 }
30029
30030
30031 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30032 PyObject *resultobj = 0;
30033 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30034 wxLongLong result;
30035 void *argp1 = 0 ;
30036 int res1 = 0 ;
30037 PyObject *swig_obj[1] ;
30038
30039 if (!args) SWIG_fail;
30040 swig_obj[0] = args;
30041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30042 if (!SWIG_IsOK(res1)) {
30043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30044 }
30045 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30046 {
30047 PyThreadState* __tstate = wxPyBeginAllowThreads();
30048 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30049 wxPyEndAllowThreads(__tstate);
30050 if (PyErr_Occurred()) SWIG_fail;
30051 }
30052 {
30053 PyObject *hi, *lo, *shifter, *shifted;
30054 hi = PyLong_FromLong( (&result)->GetHi() );
30055 lo = PyLong_FromLong( (&result)->GetLo() );
30056 shifter = PyLong_FromLong(32);
30057 shifted = PyNumber_Lshift(hi, shifter);
30058 resultobj = PyNumber_Or(shifted, lo);
30059 Py_DECREF(hi);
30060 Py_DECREF(lo);
30061 Py_DECREF(shifter);
30062 Py_DECREF(shifted);
30063 }
30064 return resultobj;
30065 fail:
30066 return NULL;
30067 }
30068
30069
30070 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30071 PyObject *resultobj = 0;
30072 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30073 wxLongLong result;
30074 void *argp1 = 0 ;
30075 int res1 = 0 ;
30076 PyObject *swig_obj[1] ;
30077
30078 if (!args) SWIG_fail;
30079 swig_obj[0] = args;
30080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30081 if (!SWIG_IsOK(res1)) {
30082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30083 }
30084 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30085 {
30086 PyThreadState* __tstate = wxPyBeginAllowThreads();
30087 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30088 wxPyEndAllowThreads(__tstate);
30089 if (PyErr_Occurred()) SWIG_fail;
30090 }
30091 {
30092 PyObject *hi, *lo, *shifter, *shifted;
30093 hi = PyLong_FromLong( (&result)->GetHi() );
30094 lo = PyLong_FromLong( (&result)->GetLo() );
30095 shifter = PyLong_FromLong(32);
30096 shifted = PyNumber_Lshift(hi, shifter);
30097 resultobj = PyNumber_Or(shifted, lo);
30098 Py_DECREF(hi);
30099 Py_DECREF(lo);
30100 Py_DECREF(shifter);
30101 Py_DECREF(shifted);
30102 }
30103 return resultobj;
30104 fail:
30105 return NULL;
30106 }
30107
30108
30109 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30110 PyObject *resultobj = 0;
30111 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30112 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30113 wxString *arg2 = (wxString *) &arg2_defvalue ;
30114 wxString result;
30115 void *argp1 = 0 ;
30116 int res1 = 0 ;
30117 bool temp2 = false ;
30118 PyObject * obj0 = 0 ;
30119 PyObject * obj1 = 0 ;
30120 char * kwnames[] = {
30121 (char *) "self",(char *) "format", NULL
30122 };
30123
30124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30126 if (!SWIG_IsOK(res1)) {
30127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30128 }
30129 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30130 if (obj1) {
30131 {
30132 arg2 = wxString_in_helper(obj1);
30133 if (arg2 == NULL) SWIG_fail;
30134 temp2 = true;
30135 }
30136 }
30137 {
30138 PyThreadState* __tstate = wxPyBeginAllowThreads();
30139 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30140 wxPyEndAllowThreads(__tstate);
30141 if (PyErr_Occurred()) SWIG_fail;
30142 }
30143 {
30144 #if wxUSE_UNICODE
30145 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30146 #else
30147 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30148 #endif
30149 }
30150 {
30151 if (temp2)
30152 delete arg2;
30153 }
30154 return resultobj;
30155 fail:
30156 {
30157 if (temp2)
30158 delete arg2;
30159 }
30160 return NULL;
30161 }
30162
30163
30164 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30165 PyObject *obj;
30166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30167 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30168 return SWIG_Py_Void();
30169 }
30170
30171 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30172 return SWIG_Python_InitShadowInstance(args);
30173 }
30174
30175 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30176 PyObject *resultobj = 0;
30177 int arg1 = (int) 0 ;
30178 int arg2 = (int) 0 ;
30179 int arg3 = (int) 0 ;
30180 int arg4 = (int) 0 ;
30181 wxDateSpan *result = 0 ;
30182 int val1 ;
30183 int ecode1 = 0 ;
30184 int val2 ;
30185 int ecode2 = 0 ;
30186 int val3 ;
30187 int ecode3 = 0 ;
30188 int val4 ;
30189 int ecode4 = 0 ;
30190 PyObject * obj0 = 0 ;
30191 PyObject * obj1 = 0 ;
30192 PyObject * obj2 = 0 ;
30193 PyObject * obj3 = 0 ;
30194 char * kwnames[] = {
30195 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30196 };
30197
30198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30199 if (obj0) {
30200 ecode1 = SWIG_AsVal_int(obj0, &val1);
30201 if (!SWIG_IsOK(ecode1)) {
30202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30203 }
30204 arg1 = static_cast< int >(val1);
30205 }
30206 if (obj1) {
30207 ecode2 = SWIG_AsVal_int(obj1, &val2);
30208 if (!SWIG_IsOK(ecode2)) {
30209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30210 }
30211 arg2 = static_cast< int >(val2);
30212 }
30213 if (obj2) {
30214 ecode3 = SWIG_AsVal_int(obj2, &val3);
30215 if (!SWIG_IsOK(ecode3)) {
30216 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30217 }
30218 arg3 = static_cast< int >(val3);
30219 }
30220 if (obj3) {
30221 ecode4 = SWIG_AsVal_int(obj3, &val4);
30222 if (!SWIG_IsOK(ecode4)) {
30223 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30224 }
30225 arg4 = static_cast< int >(val4);
30226 }
30227 {
30228 PyThreadState* __tstate = wxPyBeginAllowThreads();
30229 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30230 wxPyEndAllowThreads(__tstate);
30231 if (PyErr_Occurred()) SWIG_fail;
30232 }
30233 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30234 return resultobj;
30235 fail:
30236 return NULL;
30237 }
30238
30239
30240 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30241 PyObject *resultobj = 0;
30242 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30243 void *argp1 = 0 ;
30244 int res1 = 0 ;
30245 PyObject *swig_obj[1] ;
30246
30247 if (!args) SWIG_fail;
30248 swig_obj[0] = args;
30249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30250 if (!SWIG_IsOK(res1)) {
30251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30252 }
30253 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30254 {
30255 PyThreadState* __tstate = wxPyBeginAllowThreads();
30256 delete arg1;
30257
30258 wxPyEndAllowThreads(__tstate);
30259 if (PyErr_Occurred()) SWIG_fail;
30260 }
30261 resultobj = SWIG_Py_Void();
30262 return resultobj;
30263 fail:
30264 return NULL;
30265 }
30266
30267
30268 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30269 PyObject *resultobj = 0;
30270 int arg1 ;
30271 wxDateSpan result;
30272 int val1 ;
30273 int ecode1 = 0 ;
30274 PyObject * obj0 = 0 ;
30275 char * kwnames[] = {
30276 (char *) "days", NULL
30277 };
30278
30279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30280 ecode1 = SWIG_AsVal_int(obj0, &val1);
30281 if (!SWIG_IsOK(ecode1)) {
30282 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30283 }
30284 arg1 = static_cast< int >(val1);
30285 {
30286 PyThreadState* __tstate = wxPyBeginAllowThreads();
30287 result = wxDateSpan::Days(arg1);
30288 wxPyEndAllowThreads(__tstate);
30289 if (PyErr_Occurred()) SWIG_fail;
30290 }
30291 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30292 return resultobj;
30293 fail:
30294 return NULL;
30295 }
30296
30297
30298 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30299 PyObject *resultobj = 0;
30300 wxDateSpan result;
30301
30302 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30303 {
30304 PyThreadState* __tstate = wxPyBeginAllowThreads();
30305 result = wxDateSpan::Day();
30306 wxPyEndAllowThreads(__tstate);
30307 if (PyErr_Occurred()) SWIG_fail;
30308 }
30309 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30310 return resultobj;
30311 fail:
30312 return NULL;
30313 }
30314
30315
30316 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30317 PyObject *resultobj = 0;
30318 int arg1 ;
30319 wxDateSpan result;
30320 int val1 ;
30321 int ecode1 = 0 ;
30322 PyObject * obj0 = 0 ;
30323 char * kwnames[] = {
30324 (char *) "weeks", NULL
30325 };
30326
30327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30328 ecode1 = SWIG_AsVal_int(obj0, &val1);
30329 if (!SWIG_IsOK(ecode1)) {
30330 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30331 }
30332 arg1 = static_cast< int >(val1);
30333 {
30334 PyThreadState* __tstate = wxPyBeginAllowThreads();
30335 result = wxDateSpan::Weeks(arg1);
30336 wxPyEndAllowThreads(__tstate);
30337 if (PyErr_Occurred()) SWIG_fail;
30338 }
30339 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30340 return resultobj;
30341 fail:
30342 return NULL;
30343 }
30344
30345
30346 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30347 PyObject *resultobj = 0;
30348 wxDateSpan result;
30349
30350 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30351 {
30352 PyThreadState* __tstate = wxPyBeginAllowThreads();
30353 result = wxDateSpan::Week();
30354 wxPyEndAllowThreads(__tstate);
30355 if (PyErr_Occurred()) SWIG_fail;
30356 }
30357 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30358 return resultobj;
30359 fail:
30360 return NULL;
30361 }
30362
30363
30364 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30365 PyObject *resultobj = 0;
30366 int arg1 ;
30367 wxDateSpan result;
30368 int val1 ;
30369 int ecode1 = 0 ;
30370 PyObject * obj0 = 0 ;
30371 char * kwnames[] = {
30372 (char *) "mon", NULL
30373 };
30374
30375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30376 ecode1 = SWIG_AsVal_int(obj0, &val1);
30377 if (!SWIG_IsOK(ecode1)) {
30378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30379 }
30380 arg1 = static_cast< int >(val1);
30381 {
30382 PyThreadState* __tstate = wxPyBeginAllowThreads();
30383 result = wxDateSpan::Months(arg1);
30384 wxPyEndAllowThreads(__tstate);
30385 if (PyErr_Occurred()) SWIG_fail;
30386 }
30387 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30388 return resultobj;
30389 fail:
30390 return NULL;
30391 }
30392
30393
30394 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30395 PyObject *resultobj = 0;
30396 wxDateSpan result;
30397
30398 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30399 {
30400 PyThreadState* __tstate = wxPyBeginAllowThreads();
30401 result = wxDateSpan::Month();
30402 wxPyEndAllowThreads(__tstate);
30403 if (PyErr_Occurred()) SWIG_fail;
30404 }
30405 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30406 return resultobj;
30407 fail:
30408 return NULL;
30409 }
30410
30411
30412 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30413 PyObject *resultobj = 0;
30414 int arg1 ;
30415 wxDateSpan result;
30416 int val1 ;
30417 int ecode1 = 0 ;
30418 PyObject * obj0 = 0 ;
30419 char * kwnames[] = {
30420 (char *) "years", NULL
30421 };
30422
30423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30424 ecode1 = SWIG_AsVal_int(obj0, &val1);
30425 if (!SWIG_IsOK(ecode1)) {
30426 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30427 }
30428 arg1 = static_cast< int >(val1);
30429 {
30430 PyThreadState* __tstate = wxPyBeginAllowThreads();
30431 result = wxDateSpan::Years(arg1);
30432 wxPyEndAllowThreads(__tstate);
30433 if (PyErr_Occurred()) SWIG_fail;
30434 }
30435 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30436 return resultobj;
30437 fail:
30438 return NULL;
30439 }
30440
30441
30442 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30443 PyObject *resultobj = 0;
30444 wxDateSpan result;
30445
30446 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30447 {
30448 PyThreadState* __tstate = wxPyBeginAllowThreads();
30449 result = wxDateSpan::Year();
30450 wxPyEndAllowThreads(__tstate);
30451 if (PyErr_Occurred()) SWIG_fail;
30452 }
30453 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30454 return resultobj;
30455 fail:
30456 return NULL;
30457 }
30458
30459
30460 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30461 PyObject *resultobj = 0;
30462 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30463 int arg2 ;
30464 wxDateSpan *result = 0 ;
30465 void *argp1 = 0 ;
30466 int res1 = 0 ;
30467 int val2 ;
30468 int ecode2 = 0 ;
30469 PyObject * obj0 = 0 ;
30470 PyObject * obj1 = 0 ;
30471 char * kwnames[] = {
30472 (char *) "self",(char *) "n", NULL
30473 };
30474
30475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30477 if (!SWIG_IsOK(res1)) {
30478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30479 }
30480 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30481 ecode2 = SWIG_AsVal_int(obj1, &val2);
30482 if (!SWIG_IsOK(ecode2)) {
30483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30484 }
30485 arg2 = static_cast< int >(val2);
30486 {
30487 PyThreadState* __tstate = wxPyBeginAllowThreads();
30488 {
30489 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30490 result = (wxDateSpan *) &_result_ref;
30491 }
30492 wxPyEndAllowThreads(__tstate);
30493 if (PyErr_Occurred()) SWIG_fail;
30494 }
30495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30496 return resultobj;
30497 fail:
30498 return NULL;
30499 }
30500
30501
30502 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30503 PyObject *resultobj = 0;
30504 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30505 int arg2 ;
30506 wxDateSpan *result = 0 ;
30507 void *argp1 = 0 ;
30508 int res1 = 0 ;
30509 int val2 ;
30510 int ecode2 = 0 ;
30511 PyObject * obj0 = 0 ;
30512 PyObject * obj1 = 0 ;
30513 char * kwnames[] = {
30514 (char *) "self",(char *) "n", NULL
30515 };
30516
30517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30519 if (!SWIG_IsOK(res1)) {
30520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30521 }
30522 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30523 ecode2 = SWIG_AsVal_int(obj1, &val2);
30524 if (!SWIG_IsOK(ecode2)) {
30525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30526 }
30527 arg2 = static_cast< int >(val2);
30528 {
30529 PyThreadState* __tstate = wxPyBeginAllowThreads();
30530 {
30531 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30532 result = (wxDateSpan *) &_result_ref;
30533 }
30534 wxPyEndAllowThreads(__tstate);
30535 if (PyErr_Occurred()) SWIG_fail;
30536 }
30537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30538 return resultobj;
30539 fail:
30540 return NULL;
30541 }
30542
30543
30544 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30545 PyObject *resultobj = 0;
30546 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30547 int arg2 ;
30548 wxDateSpan *result = 0 ;
30549 void *argp1 = 0 ;
30550 int res1 = 0 ;
30551 int val2 ;
30552 int ecode2 = 0 ;
30553 PyObject * obj0 = 0 ;
30554 PyObject * obj1 = 0 ;
30555 char * kwnames[] = {
30556 (char *) "self",(char *) "n", NULL
30557 };
30558
30559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30561 if (!SWIG_IsOK(res1)) {
30562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30563 }
30564 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30565 ecode2 = SWIG_AsVal_int(obj1, &val2);
30566 if (!SWIG_IsOK(ecode2)) {
30567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30568 }
30569 arg2 = static_cast< int >(val2);
30570 {
30571 PyThreadState* __tstate = wxPyBeginAllowThreads();
30572 {
30573 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30574 result = (wxDateSpan *) &_result_ref;
30575 }
30576 wxPyEndAllowThreads(__tstate);
30577 if (PyErr_Occurred()) SWIG_fail;
30578 }
30579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30580 return resultobj;
30581 fail:
30582 return NULL;
30583 }
30584
30585
30586 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30587 PyObject *resultobj = 0;
30588 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30589 int arg2 ;
30590 wxDateSpan *result = 0 ;
30591 void *argp1 = 0 ;
30592 int res1 = 0 ;
30593 int val2 ;
30594 int ecode2 = 0 ;
30595 PyObject * obj0 = 0 ;
30596 PyObject * obj1 = 0 ;
30597 char * kwnames[] = {
30598 (char *) "self",(char *) "n", NULL
30599 };
30600
30601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30603 if (!SWIG_IsOK(res1)) {
30604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30605 }
30606 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30607 ecode2 = SWIG_AsVal_int(obj1, &val2);
30608 if (!SWIG_IsOK(ecode2)) {
30609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30610 }
30611 arg2 = static_cast< int >(val2);
30612 {
30613 PyThreadState* __tstate = wxPyBeginAllowThreads();
30614 {
30615 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30616 result = (wxDateSpan *) &_result_ref;
30617 }
30618 wxPyEndAllowThreads(__tstate);
30619 if (PyErr_Occurred()) SWIG_fail;
30620 }
30621 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30622 return resultobj;
30623 fail:
30624 return NULL;
30625 }
30626
30627
30628 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30629 PyObject *resultobj = 0;
30630 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30631 int result;
30632 void *argp1 = 0 ;
30633 int res1 = 0 ;
30634 PyObject *swig_obj[1] ;
30635
30636 if (!args) SWIG_fail;
30637 swig_obj[0] = args;
30638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30639 if (!SWIG_IsOK(res1)) {
30640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30641 }
30642 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30643 {
30644 PyThreadState* __tstate = wxPyBeginAllowThreads();
30645 result = (int)((wxDateSpan const *)arg1)->GetYears();
30646 wxPyEndAllowThreads(__tstate);
30647 if (PyErr_Occurred()) SWIG_fail;
30648 }
30649 resultobj = SWIG_From_int(static_cast< int >(result));
30650 return resultobj;
30651 fail:
30652 return NULL;
30653 }
30654
30655
30656 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30657 PyObject *resultobj = 0;
30658 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30659 int result;
30660 void *argp1 = 0 ;
30661 int res1 = 0 ;
30662 PyObject *swig_obj[1] ;
30663
30664 if (!args) SWIG_fail;
30665 swig_obj[0] = args;
30666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30667 if (!SWIG_IsOK(res1)) {
30668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30669 }
30670 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30671 {
30672 PyThreadState* __tstate = wxPyBeginAllowThreads();
30673 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30674 wxPyEndAllowThreads(__tstate);
30675 if (PyErr_Occurred()) SWIG_fail;
30676 }
30677 resultobj = SWIG_From_int(static_cast< int >(result));
30678 return resultobj;
30679 fail:
30680 return NULL;
30681 }
30682
30683
30684 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30685 PyObject *resultobj = 0;
30686 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30687 int result;
30688 void *argp1 = 0 ;
30689 int res1 = 0 ;
30690 PyObject *swig_obj[1] ;
30691
30692 if (!args) SWIG_fail;
30693 swig_obj[0] = args;
30694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30695 if (!SWIG_IsOK(res1)) {
30696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30697 }
30698 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30699 {
30700 PyThreadState* __tstate = wxPyBeginAllowThreads();
30701 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30702 wxPyEndAllowThreads(__tstate);
30703 if (PyErr_Occurred()) SWIG_fail;
30704 }
30705 resultobj = SWIG_From_int(static_cast< int >(result));
30706 return resultobj;
30707 fail:
30708 return NULL;
30709 }
30710
30711
30712 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30713 PyObject *resultobj = 0;
30714 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30715 int result;
30716 void *argp1 = 0 ;
30717 int res1 = 0 ;
30718 PyObject *swig_obj[1] ;
30719
30720 if (!args) SWIG_fail;
30721 swig_obj[0] = args;
30722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30723 if (!SWIG_IsOK(res1)) {
30724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30725 }
30726 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30727 {
30728 PyThreadState* __tstate = wxPyBeginAllowThreads();
30729 result = (int)((wxDateSpan const *)arg1)->GetDays();
30730 wxPyEndAllowThreads(__tstate);
30731 if (PyErr_Occurred()) SWIG_fail;
30732 }
30733 resultobj = SWIG_From_int(static_cast< int >(result));
30734 return resultobj;
30735 fail:
30736 return NULL;
30737 }
30738
30739
30740 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30741 PyObject *resultobj = 0;
30742 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30743 int result;
30744 void *argp1 = 0 ;
30745 int res1 = 0 ;
30746 PyObject *swig_obj[1] ;
30747
30748 if (!args) SWIG_fail;
30749 swig_obj[0] = args;
30750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30751 if (!SWIG_IsOK(res1)) {
30752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30753 }
30754 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30755 {
30756 PyThreadState* __tstate = wxPyBeginAllowThreads();
30757 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30758 wxPyEndAllowThreads(__tstate);
30759 if (PyErr_Occurred()) SWIG_fail;
30760 }
30761 resultobj = SWIG_From_int(static_cast< int >(result));
30762 return resultobj;
30763 fail:
30764 return NULL;
30765 }
30766
30767
30768 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30769 PyObject *resultobj = 0;
30770 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30771 wxDateSpan *arg2 = 0 ;
30772 wxDateSpan *result = 0 ;
30773 void *argp1 = 0 ;
30774 int res1 = 0 ;
30775 void *argp2 = 0 ;
30776 int res2 = 0 ;
30777 PyObject * obj0 = 0 ;
30778 PyObject * obj1 = 0 ;
30779 char * kwnames[] = {
30780 (char *) "self",(char *) "other", NULL
30781 };
30782
30783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30785 if (!SWIG_IsOK(res1)) {
30786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30787 }
30788 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30789 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30790 if (!SWIG_IsOK(res2)) {
30791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30792 }
30793 if (!argp2) {
30794 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30795 }
30796 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30797 {
30798 PyThreadState* __tstate = wxPyBeginAllowThreads();
30799 {
30800 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30801 result = (wxDateSpan *) &_result_ref;
30802 }
30803 wxPyEndAllowThreads(__tstate);
30804 if (PyErr_Occurred()) SWIG_fail;
30805 }
30806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30807 return resultobj;
30808 fail:
30809 return NULL;
30810 }
30811
30812
30813 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30814 PyObject *resultobj = 0;
30815 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30816 wxDateSpan *arg2 = 0 ;
30817 wxDateSpan *result = 0 ;
30818 void *argp1 = 0 ;
30819 int res1 = 0 ;
30820 void *argp2 = 0 ;
30821 int res2 = 0 ;
30822 PyObject * obj0 = 0 ;
30823 PyObject * obj1 = 0 ;
30824 char * kwnames[] = {
30825 (char *) "self",(char *) "other", NULL
30826 };
30827
30828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30830 if (!SWIG_IsOK(res1)) {
30831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30832 }
30833 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30834 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30835 if (!SWIG_IsOK(res2)) {
30836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30837 }
30838 if (!argp2) {
30839 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30840 }
30841 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30842 {
30843 PyThreadState* __tstate = wxPyBeginAllowThreads();
30844 {
30845 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30846 result = (wxDateSpan *) &_result_ref;
30847 }
30848 wxPyEndAllowThreads(__tstate);
30849 if (PyErr_Occurred()) SWIG_fail;
30850 }
30851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30852 return resultobj;
30853 fail:
30854 return NULL;
30855 }
30856
30857
30858 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30859 PyObject *resultobj = 0;
30860 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30861 wxDateSpan *result = 0 ;
30862 void *argp1 = 0 ;
30863 int res1 = 0 ;
30864 PyObject *swig_obj[1] ;
30865
30866 if (!args) SWIG_fail;
30867 swig_obj[0] = args;
30868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30869 if (!SWIG_IsOK(res1)) {
30870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30871 }
30872 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30873 {
30874 PyThreadState* __tstate = wxPyBeginAllowThreads();
30875 {
30876 wxDateSpan &_result_ref = (arg1)->Neg();
30877 result = (wxDateSpan *) &_result_ref;
30878 }
30879 wxPyEndAllowThreads(__tstate);
30880 if (PyErr_Occurred()) SWIG_fail;
30881 }
30882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30883 return resultobj;
30884 fail:
30885 return NULL;
30886 }
30887
30888
30889 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30890 PyObject *resultobj = 0;
30891 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30892 int arg2 ;
30893 wxDateSpan *result = 0 ;
30894 void *argp1 = 0 ;
30895 int res1 = 0 ;
30896 int val2 ;
30897 int ecode2 = 0 ;
30898 PyObject * obj0 = 0 ;
30899 PyObject * obj1 = 0 ;
30900 char * kwnames[] = {
30901 (char *) "self",(char *) "factor", NULL
30902 };
30903
30904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
30905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30906 if (!SWIG_IsOK(res1)) {
30907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30908 }
30909 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30910 ecode2 = SWIG_AsVal_int(obj1, &val2);
30911 if (!SWIG_IsOK(ecode2)) {
30912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
30913 }
30914 arg2 = static_cast< int >(val2);
30915 {
30916 PyThreadState* __tstate = wxPyBeginAllowThreads();
30917 {
30918 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
30919 result = (wxDateSpan *) &_result_ref;
30920 }
30921 wxPyEndAllowThreads(__tstate);
30922 if (PyErr_Occurred()) SWIG_fail;
30923 }
30924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30925 return resultobj;
30926 fail:
30927 return NULL;
30928 }
30929
30930
30931 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30932 PyObject *resultobj = 0;
30933 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30934 wxDateSpan *arg2 = 0 ;
30935 wxDateSpan *result = 0 ;
30936 void *argp1 = 0 ;
30937 int res1 = 0 ;
30938 void *argp2 = 0 ;
30939 int res2 = 0 ;
30940 PyObject * obj0 = 0 ;
30941 PyObject * obj1 = 0 ;
30942 char * kwnames[] = {
30943 (char *) "self",(char *) "other", NULL
30944 };
30945
30946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
30947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30948 if (!SWIG_IsOK(res1)) {
30949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30950 }
30951 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30952 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30953 if (!SWIG_IsOK(res2)) {
30954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30955 }
30956 if (!argp2) {
30957 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30958 }
30959 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30960 {
30961 PyThreadState* __tstate = wxPyBeginAllowThreads();
30962 {
30963 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
30964 result = (wxDateSpan *) &_result_ref;
30965 }
30966 wxPyEndAllowThreads(__tstate);
30967 if (PyErr_Occurred()) SWIG_fail;
30968 }
30969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30970 return resultobj;
30971 fail:
30972 return NULL;
30973 }
30974
30975
30976 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30977 PyObject *resultobj = 0;
30978 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30979 wxDateSpan *arg2 = 0 ;
30980 wxDateSpan *result = 0 ;
30981 void *argp1 = 0 ;
30982 int res1 = 0 ;
30983 void *argp2 = 0 ;
30984 int res2 = 0 ;
30985 PyObject * obj0 = 0 ;
30986 PyObject * obj1 = 0 ;
30987 char * kwnames[] = {
30988 (char *) "self",(char *) "other", NULL
30989 };
30990
30991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
30992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30993 if (!SWIG_IsOK(res1)) {
30994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30995 }
30996 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30997 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30998 if (!SWIG_IsOK(res2)) {
30999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31000 }
31001 if (!argp2) {
31002 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31003 }
31004 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31005 {
31006 PyThreadState* __tstate = wxPyBeginAllowThreads();
31007 {
31008 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31009 result = (wxDateSpan *) &_result_ref;
31010 }
31011 wxPyEndAllowThreads(__tstate);
31012 if (PyErr_Occurred()) SWIG_fail;
31013 }
31014 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31015 return resultobj;
31016 fail:
31017 return NULL;
31018 }
31019
31020
31021 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31022 PyObject *resultobj = 0;
31023 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31024 wxDateSpan *result = 0 ;
31025 void *argp1 = 0 ;
31026 int res1 = 0 ;
31027 PyObject *swig_obj[1] ;
31028
31029 if (!args) SWIG_fail;
31030 swig_obj[0] = args;
31031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31032 if (!SWIG_IsOK(res1)) {
31033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31034 }
31035 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31036 {
31037 PyThreadState* __tstate = wxPyBeginAllowThreads();
31038 {
31039 wxDateSpan &_result_ref = (arg1)->operator -();
31040 result = (wxDateSpan *) &_result_ref;
31041 }
31042 wxPyEndAllowThreads(__tstate);
31043 if (PyErr_Occurred()) SWIG_fail;
31044 }
31045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31046 return resultobj;
31047 fail:
31048 return NULL;
31049 }
31050
31051
31052 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31053 PyObject *resultobj = 0;
31054 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31055 int arg2 ;
31056 wxDateSpan *result = 0 ;
31057 void *argp1 = 0 ;
31058 int res1 = 0 ;
31059 int val2 ;
31060 int ecode2 = 0 ;
31061 PyObject * obj0 = 0 ;
31062 PyObject * obj1 = 0 ;
31063 char * kwnames[] = {
31064 (char *) "self",(char *) "factor", NULL
31065 };
31066
31067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31069 if (!SWIG_IsOK(res1)) {
31070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31071 }
31072 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31073 ecode2 = SWIG_AsVal_int(obj1, &val2);
31074 if (!SWIG_IsOK(ecode2)) {
31075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31076 }
31077 arg2 = static_cast< int >(val2);
31078 {
31079 PyThreadState* __tstate = wxPyBeginAllowThreads();
31080 {
31081 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31082 result = (wxDateSpan *) &_result_ref;
31083 }
31084 wxPyEndAllowThreads(__tstate);
31085 if (PyErr_Occurred()) SWIG_fail;
31086 }
31087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31088 return resultobj;
31089 fail:
31090 return NULL;
31091 }
31092
31093
31094 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31095 PyObject *resultobj = 0;
31096 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31097 wxDateSpan *arg2 = 0 ;
31098 wxDateSpan result;
31099 void *argp1 = 0 ;
31100 int res1 = 0 ;
31101 void *argp2 = 0 ;
31102 int res2 = 0 ;
31103 PyObject * obj0 = 0 ;
31104 PyObject * obj1 = 0 ;
31105 char * kwnames[] = {
31106 (char *) "self",(char *) "other", NULL
31107 };
31108
31109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31111 if (!SWIG_IsOK(res1)) {
31112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31113 }
31114 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31115 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31116 if (!SWIG_IsOK(res2)) {
31117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31118 }
31119 if (!argp2) {
31120 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31121 }
31122 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31123 {
31124 PyThreadState* __tstate = wxPyBeginAllowThreads();
31125 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31126 wxPyEndAllowThreads(__tstate);
31127 if (PyErr_Occurred()) SWIG_fail;
31128 }
31129 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31130 return resultobj;
31131 fail:
31132 return NULL;
31133 }
31134
31135
31136 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31137 PyObject *resultobj = 0;
31138 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31139 wxDateSpan *arg2 = 0 ;
31140 wxDateSpan result;
31141 void *argp1 = 0 ;
31142 int res1 = 0 ;
31143 void *argp2 = 0 ;
31144 int res2 = 0 ;
31145 PyObject * obj0 = 0 ;
31146 PyObject * obj1 = 0 ;
31147 char * kwnames[] = {
31148 (char *) "self",(char *) "other", NULL
31149 };
31150
31151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31153 if (!SWIG_IsOK(res1)) {
31154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31155 }
31156 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31157 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31158 if (!SWIG_IsOK(res2)) {
31159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31160 }
31161 if (!argp2) {
31162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31163 }
31164 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31165 {
31166 PyThreadState* __tstate = wxPyBeginAllowThreads();
31167 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31168 wxPyEndAllowThreads(__tstate);
31169 if (PyErr_Occurred()) SWIG_fail;
31170 }
31171 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31172 return resultobj;
31173 fail:
31174 return NULL;
31175 }
31176
31177
31178 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31179 PyObject *resultobj = 0;
31180 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31181 int arg2 ;
31182 wxDateSpan result;
31183 void *argp1 = 0 ;
31184 int res1 = 0 ;
31185 int val2 ;
31186 int ecode2 = 0 ;
31187 PyObject * obj0 = 0 ;
31188 PyObject * obj1 = 0 ;
31189 char * kwnames[] = {
31190 (char *) "self",(char *) "n", NULL
31191 };
31192
31193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31195 if (!SWIG_IsOK(res1)) {
31196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31197 }
31198 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31199 ecode2 = SWIG_AsVal_int(obj1, &val2);
31200 if (!SWIG_IsOK(ecode2)) {
31201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31202 }
31203 arg2 = static_cast< int >(val2);
31204 {
31205 PyThreadState* __tstate = wxPyBeginAllowThreads();
31206 result = wxDateSpan___mul__(arg1,arg2);
31207 wxPyEndAllowThreads(__tstate);
31208 if (PyErr_Occurred()) SWIG_fail;
31209 }
31210 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31211 return resultobj;
31212 fail:
31213 return NULL;
31214 }
31215
31216
31217 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31218 PyObject *resultobj = 0;
31219 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31220 int arg2 ;
31221 wxDateSpan result;
31222 void *argp1 = 0 ;
31223 int res1 = 0 ;
31224 int val2 ;
31225 int ecode2 = 0 ;
31226 PyObject * obj0 = 0 ;
31227 PyObject * obj1 = 0 ;
31228 char * kwnames[] = {
31229 (char *) "self",(char *) "n", NULL
31230 };
31231
31232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31234 if (!SWIG_IsOK(res1)) {
31235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31236 }
31237 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31238 ecode2 = SWIG_AsVal_int(obj1, &val2);
31239 if (!SWIG_IsOK(ecode2)) {
31240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31241 }
31242 arg2 = static_cast< int >(val2);
31243 {
31244 PyThreadState* __tstate = wxPyBeginAllowThreads();
31245 result = wxDateSpan___rmul__(arg1,arg2);
31246 wxPyEndAllowThreads(__tstate);
31247 if (PyErr_Occurred()) SWIG_fail;
31248 }
31249 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31250 return resultobj;
31251 fail:
31252 return NULL;
31253 }
31254
31255
31256 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31257 PyObject *resultobj = 0;
31258 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31259 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31260 bool result;
31261 void *argp1 = 0 ;
31262 int res1 = 0 ;
31263 void *argp2 = 0 ;
31264 int res2 = 0 ;
31265 PyObject * obj0 = 0 ;
31266 PyObject * obj1 = 0 ;
31267 char * kwnames[] = {
31268 (char *) "self",(char *) "other", NULL
31269 };
31270
31271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31273 if (!SWIG_IsOK(res1)) {
31274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31275 }
31276 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31277 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31278 if (!SWIG_IsOK(res2)) {
31279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31280 }
31281 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31282 {
31283 PyThreadState* __tstate = wxPyBeginAllowThreads();
31284 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31285 wxPyEndAllowThreads(__tstate);
31286 if (PyErr_Occurred()) SWIG_fail;
31287 }
31288 {
31289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31290 }
31291 return resultobj;
31292 fail:
31293 return NULL;
31294 }
31295
31296
31297 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31298 PyObject *resultobj = 0;
31299 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31300 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31301 bool result;
31302 void *argp1 = 0 ;
31303 int res1 = 0 ;
31304 void *argp2 = 0 ;
31305 int res2 = 0 ;
31306 PyObject * obj0 = 0 ;
31307 PyObject * obj1 = 0 ;
31308 char * kwnames[] = {
31309 (char *) "self",(char *) "other", NULL
31310 };
31311
31312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31314 if (!SWIG_IsOK(res1)) {
31315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31316 }
31317 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31318 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31319 if (!SWIG_IsOK(res2)) {
31320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31321 }
31322 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31323 {
31324 PyThreadState* __tstate = wxPyBeginAllowThreads();
31325 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31326 wxPyEndAllowThreads(__tstate);
31327 if (PyErr_Occurred()) SWIG_fail;
31328 }
31329 {
31330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31331 }
31332 return resultobj;
31333 fail:
31334 return NULL;
31335 }
31336
31337
31338 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31339 PyObject *obj;
31340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31341 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31342 return SWIG_Py_Void();
31343 }
31344
31345 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31346 return SWIG_Python_InitShadowInstance(args);
31347 }
31348
31349 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31350 PyObject *resultobj = 0;
31351 long result;
31352
31353 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31354 {
31355 PyThreadState* __tstate = wxPyBeginAllowThreads();
31356 result = (long)wxGetLocalTime();
31357 wxPyEndAllowThreads(__tstate);
31358 if (PyErr_Occurred()) SWIG_fail;
31359 }
31360 resultobj = SWIG_From_long(static_cast< long >(result));
31361 return resultobj;
31362 fail:
31363 return NULL;
31364 }
31365
31366
31367 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31368 PyObject *resultobj = 0;
31369 long result;
31370
31371 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31372 {
31373 PyThreadState* __tstate = wxPyBeginAllowThreads();
31374 result = (long)wxGetUTCTime();
31375 wxPyEndAllowThreads(__tstate);
31376 if (PyErr_Occurred()) SWIG_fail;
31377 }
31378 resultobj = SWIG_From_long(static_cast< long >(result));
31379 return resultobj;
31380 fail:
31381 return NULL;
31382 }
31383
31384
31385 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31386 PyObject *resultobj = 0;
31387 long result;
31388
31389 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31390 {
31391 PyThreadState* __tstate = wxPyBeginAllowThreads();
31392 result = (long)wxGetCurrentTime();
31393 wxPyEndAllowThreads(__tstate);
31394 if (PyErr_Occurred()) SWIG_fail;
31395 }
31396 resultobj = SWIG_From_long(static_cast< long >(result));
31397 return resultobj;
31398 fail:
31399 return NULL;
31400 }
31401
31402
31403 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31404 PyObject *resultobj = 0;
31405 wxLongLong result;
31406
31407 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31408 {
31409 PyThreadState* __tstate = wxPyBeginAllowThreads();
31410 result = wxGetLocalTimeMillis();
31411 wxPyEndAllowThreads(__tstate);
31412 if (PyErr_Occurred()) SWIG_fail;
31413 }
31414 {
31415 PyObject *hi, *lo, *shifter, *shifted;
31416 hi = PyLong_FromLong( (&result)->GetHi() );
31417 lo = PyLong_FromLong( (&result)->GetLo() );
31418 shifter = PyLong_FromLong(32);
31419 shifted = PyNumber_Lshift(hi, shifter);
31420 resultobj = PyNumber_Or(shifted, lo);
31421 Py_DECREF(hi);
31422 Py_DECREF(lo);
31423 Py_DECREF(shifter);
31424 Py_DECREF(shifted);
31425 }
31426 return resultobj;
31427 fail:
31428 return NULL;
31429 }
31430
31431
31432 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31433 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31434 return 1;
31435 }
31436
31437
31438 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31439 PyObject *pyobj = 0;
31440
31441 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31442 return pyobj;
31443 }
31444
31445
31446 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31447 PyObject *resultobj = 0;
31448 wxDataFormatId arg1 ;
31449 wxDataFormat *result = 0 ;
31450 int val1 ;
31451 int ecode1 = 0 ;
31452 PyObject * obj0 = 0 ;
31453 char * kwnames[] = {
31454 (char *) "type", NULL
31455 };
31456
31457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31458 ecode1 = SWIG_AsVal_int(obj0, &val1);
31459 if (!SWIG_IsOK(ecode1)) {
31460 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31461 }
31462 arg1 = static_cast< wxDataFormatId >(val1);
31463 {
31464 PyThreadState* __tstate = wxPyBeginAllowThreads();
31465 result = (wxDataFormat *)new wxDataFormat(arg1);
31466 wxPyEndAllowThreads(__tstate);
31467 if (PyErr_Occurred()) SWIG_fail;
31468 }
31469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31470 return resultobj;
31471 fail:
31472 return NULL;
31473 }
31474
31475
31476 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31477 PyObject *resultobj = 0;
31478 wxString *arg1 = 0 ;
31479 wxDataFormat *result = 0 ;
31480 bool temp1 = false ;
31481 PyObject * obj0 = 0 ;
31482 char * kwnames[] = {
31483 (char *) "format", NULL
31484 };
31485
31486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31487 {
31488 arg1 = wxString_in_helper(obj0);
31489 if (arg1 == NULL) SWIG_fail;
31490 temp1 = true;
31491 }
31492 {
31493 PyThreadState* __tstate = wxPyBeginAllowThreads();
31494 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31495 wxPyEndAllowThreads(__tstate);
31496 if (PyErr_Occurred()) SWIG_fail;
31497 }
31498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31499 {
31500 if (temp1)
31501 delete arg1;
31502 }
31503 return resultobj;
31504 fail:
31505 {
31506 if (temp1)
31507 delete arg1;
31508 }
31509 return NULL;
31510 }
31511
31512
31513 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31514 PyObject *resultobj = 0;
31515 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31516 void *argp1 = 0 ;
31517 int res1 = 0 ;
31518 PyObject *swig_obj[1] ;
31519
31520 if (!args) SWIG_fail;
31521 swig_obj[0] = args;
31522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31523 if (!SWIG_IsOK(res1)) {
31524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31525 }
31526 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31527 {
31528 PyThreadState* __tstate = wxPyBeginAllowThreads();
31529 delete arg1;
31530
31531 wxPyEndAllowThreads(__tstate);
31532 if (PyErr_Occurred()) SWIG_fail;
31533 }
31534 resultobj = SWIG_Py_Void();
31535 return resultobj;
31536 fail:
31537 return NULL;
31538 }
31539
31540
31541 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31542 PyObject *resultobj = 0;
31543 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31544 wxDataFormatId arg2 ;
31545 bool result;
31546 void *argp1 = 0 ;
31547 int res1 = 0 ;
31548 int val2 ;
31549 int ecode2 = 0 ;
31550
31551 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31553 if (!SWIG_IsOK(res1)) {
31554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31555 }
31556 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31557 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31558 if (!SWIG_IsOK(ecode2)) {
31559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31560 }
31561 arg2 = static_cast< wxDataFormatId >(val2);
31562 {
31563 PyThreadState* __tstate = wxPyBeginAllowThreads();
31564 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31565 wxPyEndAllowThreads(__tstate);
31566 if (PyErr_Occurred()) SWIG_fail;
31567 }
31568 {
31569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31570 }
31571 return resultobj;
31572 fail:
31573 return NULL;
31574 }
31575
31576
31577 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31578 PyObject *resultobj = 0;
31579 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31580 wxDataFormatId arg2 ;
31581 bool result;
31582 void *argp1 = 0 ;
31583 int res1 = 0 ;
31584 int val2 ;
31585 int ecode2 = 0 ;
31586
31587 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31589 if (!SWIG_IsOK(res1)) {
31590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31591 }
31592 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31593 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31594 if (!SWIG_IsOK(ecode2)) {
31595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31596 }
31597 arg2 = static_cast< wxDataFormatId >(val2);
31598 {
31599 PyThreadState* __tstate = wxPyBeginAllowThreads();
31600 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31601 wxPyEndAllowThreads(__tstate);
31602 if (PyErr_Occurred()) SWIG_fail;
31603 }
31604 {
31605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31606 }
31607 return resultobj;
31608 fail:
31609 return NULL;
31610 }
31611
31612
31613 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31614 PyObject *resultobj = 0;
31615 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31616 wxDataFormat *arg2 = 0 ;
31617 bool result;
31618 void *argp1 = 0 ;
31619 int res1 = 0 ;
31620 void *argp2 = 0 ;
31621 int res2 = 0 ;
31622
31623 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31625 if (!SWIG_IsOK(res1)) {
31626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31627 }
31628 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31629 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31630 if (!SWIG_IsOK(res2)) {
31631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31632 }
31633 if (!argp2) {
31634 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31635 }
31636 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31637 {
31638 PyThreadState* __tstate = wxPyBeginAllowThreads();
31639 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31640 wxPyEndAllowThreads(__tstate);
31641 if (PyErr_Occurred()) SWIG_fail;
31642 }
31643 {
31644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31645 }
31646 return resultobj;
31647 fail:
31648 return NULL;
31649 }
31650
31651
31652 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31653 int argc;
31654 PyObject *argv[3];
31655
31656 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31657 --argc;
31658 if (argc == 2) {
31659 int _v = 0;
31660 {
31661 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31662 _v = SWIG_CheckState(res);
31663 }
31664 if (!_v) goto check_1;
31665 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31666 }
31667 check_1:
31668
31669 if (argc == 2) {
31670 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31671 }
31672
31673 fail:
31674 Py_INCREF(Py_NotImplemented);
31675 return Py_NotImplemented;
31676 }
31677
31678
31679 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31680 PyObject *resultobj = 0;
31681 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31682 wxDataFormat *arg2 = 0 ;
31683 bool result;
31684 void *argp1 = 0 ;
31685 int res1 = 0 ;
31686 void *argp2 = 0 ;
31687 int res2 = 0 ;
31688
31689 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31691 if (!SWIG_IsOK(res1)) {
31692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31693 }
31694 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31695 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31696 if (!SWIG_IsOK(res2)) {
31697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31698 }
31699 if (!argp2) {
31700 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31701 }
31702 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31703 {
31704 PyThreadState* __tstate = wxPyBeginAllowThreads();
31705 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31706 wxPyEndAllowThreads(__tstate);
31707 if (PyErr_Occurred()) SWIG_fail;
31708 }
31709 {
31710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31711 }
31712 return resultobj;
31713 fail:
31714 return NULL;
31715 }
31716
31717
31718 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31719 int argc;
31720 PyObject *argv[3];
31721
31722 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31723 --argc;
31724 if (argc == 2) {
31725 int _v = 0;
31726 {
31727 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31728 _v = SWIG_CheckState(res);
31729 }
31730 if (!_v) goto check_1;
31731 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31732 }
31733 check_1:
31734
31735 if (argc == 2) {
31736 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31737 }
31738
31739 fail:
31740 Py_INCREF(Py_NotImplemented);
31741 return Py_NotImplemented;
31742 }
31743
31744
31745 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31746 PyObject *resultobj = 0;
31747 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31748 wxDataFormatId arg2 ;
31749 void *argp1 = 0 ;
31750 int res1 = 0 ;
31751 int val2 ;
31752 int ecode2 = 0 ;
31753 PyObject * obj0 = 0 ;
31754 PyObject * obj1 = 0 ;
31755 char * kwnames[] = {
31756 (char *) "self",(char *) "format", NULL
31757 };
31758
31759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31761 if (!SWIG_IsOK(res1)) {
31762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31763 }
31764 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31765 ecode2 = SWIG_AsVal_int(obj1, &val2);
31766 if (!SWIG_IsOK(ecode2)) {
31767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31768 }
31769 arg2 = static_cast< wxDataFormatId >(val2);
31770 {
31771 PyThreadState* __tstate = wxPyBeginAllowThreads();
31772 (arg1)->SetType(arg2);
31773 wxPyEndAllowThreads(__tstate);
31774 if (PyErr_Occurred()) SWIG_fail;
31775 }
31776 resultobj = SWIG_Py_Void();
31777 return resultobj;
31778 fail:
31779 return NULL;
31780 }
31781
31782
31783 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31784 PyObject *resultobj = 0;
31785 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31786 wxDataFormatId result;
31787 void *argp1 = 0 ;
31788 int res1 = 0 ;
31789 PyObject *swig_obj[1] ;
31790
31791 if (!args) SWIG_fail;
31792 swig_obj[0] = args;
31793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31794 if (!SWIG_IsOK(res1)) {
31795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31796 }
31797 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31798 {
31799 PyThreadState* __tstate = wxPyBeginAllowThreads();
31800 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31801 wxPyEndAllowThreads(__tstate);
31802 if (PyErr_Occurred()) SWIG_fail;
31803 }
31804 resultobj = SWIG_From_int(static_cast< int >(result));
31805 return resultobj;
31806 fail:
31807 return NULL;
31808 }
31809
31810
31811 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31812 PyObject *resultobj = 0;
31813 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31814 wxString result;
31815 void *argp1 = 0 ;
31816 int res1 = 0 ;
31817 PyObject *swig_obj[1] ;
31818
31819 if (!args) SWIG_fail;
31820 swig_obj[0] = args;
31821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31822 if (!SWIG_IsOK(res1)) {
31823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31824 }
31825 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31826 {
31827 PyThreadState* __tstate = wxPyBeginAllowThreads();
31828 result = ((wxDataFormat const *)arg1)->GetId();
31829 wxPyEndAllowThreads(__tstate);
31830 if (PyErr_Occurred()) SWIG_fail;
31831 }
31832 {
31833 #if wxUSE_UNICODE
31834 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31835 #else
31836 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31837 #endif
31838 }
31839 return resultobj;
31840 fail:
31841 return NULL;
31842 }
31843
31844
31845 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31846 PyObject *resultobj = 0;
31847 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31848 wxString *arg2 = 0 ;
31849 void *argp1 = 0 ;
31850 int res1 = 0 ;
31851 bool temp2 = false ;
31852 PyObject * obj0 = 0 ;
31853 PyObject * obj1 = 0 ;
31854 char * kwnames[] = {
31855 (char *) "self",(char *) "format", NULL
31856 };
31857
31858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31860 if (!SWIG_IsOK(res1)) {
31861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31862 }
31863 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31864 {
31865 arg2 = wxString_in_helper(obj1);
31866 if (arg2 == NULL) SWIG_fail;
31867 temp2 = true;
31868 }
31869 {
31870 PyThreadState* __tstate = wxPyBeginAllowThreads();
31871 (arg1)->SetId((wxString const &)*arg2);
31872 wxPyEndAllowThreads(__tstate);
31873 if (PyErr_Occurred()) SWIG_fail;
31874 }
31875 resultobj = SWIG_Py_Void();
31876 {
31877 if (temp2)
31878 delete arg2;
31879 }
31880 return resultobj;
31881 fail:
31882 {
31883 if (temp2)
31884 delete arg2;
31885 }
31886 return NULL;
31887 }
31888
31889
31890 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31891 PyObject *obj;
31892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31893 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31894 return SWIG_Py_Void();
31895 }
31896
31897 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31898 return SWIG_Python_InitShadowInstance(args);
31899 }
31900
31901 SWIGINTERN int FormatInvalid_set(PyObject *) {
31902 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31903 return 1;
31904 }
31905
31906
31907 SWIGINTERN PyObject *FormatInvalid_get(void) {
31908 PyObject *pyobj = 0;
31909
31910 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
31911 return pyobj;
31912 }
31913
31914
31915 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31916 PyObject *resultobj = 0;
31917 wxDataObject *arg1 = (wxDataObject *) 0 ;
31918 void *argp1 = 0 ;
31919 int res1 = 0 ;
31920 PyObject *swig_obj[1] ;
31921
31922 if (!args) SWIG_fail;
31923 swig_obj[0] = args;
31924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
31925 if (!SWIG_IsOK(res1)) {
31926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
31927 }
31928 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31929 {
31930 PyThreadState* __tstate = wxPyBeginAllowThreads();
31931 delete arg1;
31932
31933 wxPyEndAllowThreads(__tstate);
31934 if (PyErr_Occurred()) SWIG_fail;
31935 }
31936 resultobj = SWIG_Py_Void();
31937 return resultobj;
31938 fail:
31939 return NULL;
31940 }
31941
31942
31943 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31944 PyObject *resultobj = 0;
31945 wxDataObject *arg1 = (wxDataObject *) 0 ;
31946 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31947 SwigValueWrapper<wxDataFormat > result;
31948 void *argp1 = 0 ;
31949 int res1 = 0 ;
31950 int val2 ;
31951 int ecode2 = 0 ;
31952 PyObject * obj0 = 0 ;
31953 PyObject * obj1 = 0 ;
31954 char * kwnames[] = {
31955 (char *) "self",(char *) "dir", NULL
31956 };
31957
31958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31960 if (!SWIG_IsOK(res1)) {
31961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31962 }
31963 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31964 if (obj1) {
31965 ecode2 = SWIG_AsVal_int(obj1, &val2);
31966 if (!SWIG_IsOK(ecode2)) {
31967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31968 }
31969 arg2 = static_cast< wxDataObject::Direction >(val2);
31970 }
31971 {
31972 PyThreadState* __tstate = wxPyBeginAllowThreads();
31973 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
31974 wxPyEndAllowThreads(__tstate);
31975 if (PyErr_Occurred()) SWIG_fail;
31976 }
31977 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31978 return resultobj;
31979 fail:
31980 return NULL;
31981 }
31982
31983
31984 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31985 PyObject *resultobj = 0;
31986 wxDataObject *arg1 = (wxDataObject *) 0 ;
31987 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31988 size_t result;
31989 void *argp1 = 0 ;
31990 int res1 = 0 ;
31991 int val2 ;
31992 int ecode2 = 0 ;
31993 PyObject * obj0 = 0 ;
31994 PyObject * obj1 = 0 ;
31995 char * kwnames[] = {
31996 (char *) "self",(char *) "dir", NULL
31997 };
31998
31999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32001 if (!SWIG_IsOK(res1)) {
32002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32003 }
32004 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32005 if (obj1) {
32006 ecode2 = SWIG_AsVal_int(obj1, &val2);
32007 if (!SWIG_IsOK(ecode2)) {
32008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32009 }
32010 arg2 = static_cast< wxDataObject::Direction >(val2);
32011 }
32012 {
32013 PyThreadState* __tstate = wxPyBeginAllowThreads();
32014 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32015 wxPyEndAllowThreads(__tstate);
32016 if (PyErr_Occurred()) SWIG_fail;
32017 }
32018 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32019 return resultobj;
32020 fail:
32021 return NULL;
32022 }
32023
32024
32025 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32026 PyObject *resultobj = 0;
32027 wxDataObject *arg1 = (wxDataObject *) 0 ;
32028 wxDataFormat *arg2 = 0 ;
32029 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32030 bool result;
32031 void *argp1 = 0 ;
32032 int res1 = 0 ;
32033 void *argp2 = 0 ;
32034 int res2 = 0 ;
32035 int val3 ;
32036 int ecode3 = 0 ;
32037 PyObject * obj0 = 0 ;
32038 PyObject * obj1 = 0 ;
32039 PyObject * obj2 = 0 ;
32040 char * kwnames[] = {
32041 (char *) "self",(char *) "format",(char *) "dir", NULL
32042 };
32043
32044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32046 if (!SWIG_IsOK(res1)) {
32047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32048 }
32049 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32050 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32051 if (!SWIG_IsOK(res2)) {
32052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32053 }
32054 if (!argp2) {
32055 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32056 }
32057 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32058 if (obj2) {
32059 ecode3 = SWIG_AsVal_int(obj2, &val3);
32060 if (!SWIG_IsOK(ecode3)) {
32061 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32062 }
32063 arg3 = static_cast< wxDataObject::Direction >(val3);
32064 }
32065 {
32066 PyThreadState* __tstate = wxPyBeginAllowThreads();
32067 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32068 wxPyEndAllowThreads(__tstate);
32069 if (PyErr_Occurred()) SWIG_fail;
32070 }
32071 {
32072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32073 }
32074 return resultobj;
32075 fail:
32076 return NULL;
32077 }
32078
32079
32080 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32081 PyObject *resultobj = 0;
32082 wxDataObject *arg1 = (wxDataObject *) 0 ;
32083 wxDataFormat *arg2 = 0 ;
32084 size_t result;
32085 void *argp1 = 0 ;
32086 int res1 = 0 ;
32087 void *argp2 = 0 ;
32088 int res2 = 0 ;
32089 PyObject * obj0 = 0 ;
32090 PyObject * obj1 = 0 ;
32091 char * kwnames[] = {
32092 (char *) "self",(char *) "format", NULL
32093 };
32094
32095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32097 if (!SWIG_IsOK(res1)) {
32098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32099 }
32100 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32101 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32102 if (!SWIG_IsOK(res2)) {
32103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32104 }
32105 if (!argp2) {
32106 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32107 }
32108 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32109 {
32110 PyThreadState* __tstate = wxPyBeginAllowThreads();
32111 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32112 wxPyEndAllowThreads(__tstate);
32113 if (PyErr_Occurred()) SWIG_fail;
32114 }
32115 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32116 return resultobj;
32117 fail:
32118 return NULL;
32119 }
32120
32121
32122 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32123 PyObject *resultobj = 0;
32124 wxDataObject *arg1 = (wxDataObject *) 0 ;
32125 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32126 PyObject *result = 0 ;
32127 void *argp1 = 0 ;
32128 int res1 = 0 ;
32129 int val2 ;
32130 int ecode2 = 0 ;
32131 PyObject * obj0 = 0 ;
32132 PyObject * obj1 = 0 ;
32133 char * kwnames[] = {
32134 (char *) "self",(char *) "dir", NULL
32135 };
32136
32137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32139 if (!SWIG_IsOK(res1)) {
32140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32141 }
32142 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32143 if (obj1) {
32144 ecode2 = SWIG_AsVal_int(obj1, &val2);
32145 if (!SWIG_IsOK(ecode2)) {
32146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32147 }
32148 arg2 = static_cast< wxDataObject::Direction >(val2);
32149 }
32150 {
32151 PyThreadState* __tstate = wxPyBeginAllowThreads();
32152 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32153 wxPyEndAllowThreads(__tstate);
32154 if (PyErr_Occurred()) SWIG_fail;
32155 }
32156 resultobj = result;
32157 return resultobj;
32158 fail:
32159 return NULL;
32160 }
32161
32162
32163 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32164 PyObject *resultobj = 0;
32165 wxDataObject *arg1 = (wxDataObject *) 0 ;
32166 wxDataFormat *arg2 = 0 ;
32167 PyObject *result = 0 ;
32168 void *argp1 = 0 ;
32169 int res1 = 0 ;
32170 void *argp2 = 0 ;
32171 int res2 = 0 ;
32172 PyObject * obj0 = 0 ;
32173 PyObject * obj1 = 0 ;
32174 char * kwnames[] = {
32175 (char *) "self",(char *) "format", NULL
32176 };
32177
32178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32180 if (!SWIG_IsOK(res1)) {
32181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32182 }
32183 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32184 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32185 if (!SWIG_IsOK(res2)) {
32186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32187 }
32188 if (!argp2) {
32189 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32190 }
32191 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32192 {
32193 PyThreadState* __tstate = wxPyBeginAllowThreads();
32194 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32195 wxPyEndAllowThreads(__tstate);
32196 if (PyErr_Occurred()) SWIG_fail;
32197 }
32198 resultobj = result;
32199 return resultobj;
32200 fail:
32201 return NULL;
32202 }
32203
32204
32205 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32206 PyObject *resultobj = 0;
32207 wxDataObject *arg1 = (wxDataObject *) 0 ;
32208 wxDataFormat *arg2 = 0 ;
32209 PyObject *arg3 = (PyObject *) 0 ;
32210 bool result;
32211 void *argp1 = 0 ;
32212 int res1 = 0 ;
32213 void *argp2 = 0 ;
32214 int res2 = 0 ;
32215 PyObject * obj0 = 0 ;
32216 PyObject * obj1 = 0 ;
32217 PyObject * obj2 = 0 ;
32218 char * kwnames[] = {
32219 (char *) "self",(char *) "format",(char *) "data", NULL
32220 };
32221
32222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32224 if (!SWIG_IsOK(res1)) {
32225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32226 }
32227 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32228 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32229 if (!SWIG_IsOK(res2)) {
32230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32231 }
32232 if (!argp2) {
32233 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32234 }
32235 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32236 arg3 = obj2;
32237 {
32238 PyThreadState* __tstate = wxPyBeginAllowThreads();
32239 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32240 wxPyEndAllowThreads(__tstate);
32241 if (PyErr_Occurred()) SWIG_fail;
32242 }
32243 {
32244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32245 }
32246 return resultobj;
32247 fail:
32248 return NULL;
32249 }
32250
32251
32252 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32253 PyObject *obj;
32254 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32255 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32256 return SWIG_Py_Void();
32257 }
32258
32259 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32260 PyObject *resultobj = 0;
32261 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32262 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32263 wxDataObjectSimple *result = 0 ;
32264 void *argp1 = 0 ;
32265 int res1 = 0 ;
32266 PyObject * obj0 = 0 ;
32267 char * kwnames[] = {
32268 (char *) "format", NULL
32269 };
32270
32271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32272 if (obj0) {
32273 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32274 if (!SWIG_IsOK(res1)) {
32275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32276 }
32277 if (!argp1) {
32278 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32279 }
32280 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32281 }
32282 {
32283 PyThreadState* __tstate = wxPyBeginAllowThreads();
32284 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32285 wxPyEndAllowThreads(__tstate);
32286 if (PyErr_Occurred()) SWIG_fail;
32287 }
32288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32289 return resultobj;
32290 fail:
32291 return NULL;
32292 }
32293
32294
32295 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32296 PyObject *resultobj = 0;
32297 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32298 wxDataFormat *result = 0 ;
32299 void *argp1 = 0 ;
32300 int res1 = 0 ;
32301 PyObject *swig_obj[1] ;
32302
32303 if (!args) SWIG_fail;
32304 swig_obj[0] = args;
32305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32306 if (!SWIG_IsOK(res1)) {
32307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32308 }
32309 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32310 {
32311 PyThreadState* __tstate = wxPyBeginAllowThreads();
32312 {
32313 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32314 result = (wxDataFormat *) &_result_ref;
32315 }
32316 wxPyEndAllowThreads(__tstate);
32317 if (PyErr_Occurred()) SWIG_fail;
32318 }
32319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32320 return resultobj;
32321 fail:
32322 return NULL;
32323 }
32324
32325
32326 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32327 PyObject *resultobj = 0;
32328 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32329 wxDataFormat *arg2 = 0 ;
32330 void *argp1 = 0 ;
32331 int res1 = 0 ;
32332 void *argp2 = 0 ;
32333 int res2 = 0 ;
32334 PyObject * obj0 = 0 ;
32335 PyObject * obj1 = 0 ;
32336 char * kwnames[] = {
32337 (char *) "self",(char *) "format", NULL
32338 };
32339
32340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32342 if (!SWIG_IsOK(res1)) {
32343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32344 }
32345 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32346 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32347 if (!SWIG_IsOK(res2)) {
32348 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32349 }
32350 if (!argp2) {
32351 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32352 }
32353 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32354 {
32355 PyThreadState* __tstate = wxPyBeginAllowThreads();
32356 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32357 wxPyEndAllowThreads(__tstate);
32358 if (PyErr_Occurred()) SWIG_fail;
32359 }
32360 resultobj = SWIG_Py_Void();
32361 return resultobj;
32362 fail:
32363 return NULL;
32364 }
32365
32366
32367 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32368 PyObject *resultobj = 0;
32369 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32370 size_t result;
32371 void *argp1 = 0 ;
32372 int res1 = 0 ;
32373 PyObject *swig_obj[1] ;
32374
32375 if (!args) SWIG_fail;
32376 swig_obj[0] = args;
32377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32378 if (!SWIG_IsOK(res1)) {
32379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32380 }
32381 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32382 {
32383 PyThreadState* __tstate = wxPyBeginAllowThreads();
32384 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32385 wxPyEndAllowThreads(__tstate);
32386 if (PyErr_Occurred()) SWIG_fail;
32387 }
32388 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32389 return resultobj;
32390 fail:
32391 return NULL;
32392 }
32393
32394
32395 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32396 PyObject *resultobj = 0;
32397 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32398 PyObject *result = 0 ;
32399 void *argp1 = 0 ;
32400 int res1 = 0 ;
32401 PyObject *swig_obj[1] ;
32402
32403 if (!args) SWIG_fail;
32404 swig_obj[0] = args;
32405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32406 if (!SWIG_IsOK(res1)) {
32407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32408 }
32409 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32410 {
32411 PyThreadState* __tstate = wxPyBeginAllowThreads();
32412 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32413 wxPyEndAllowThreads(__tstate);
32414 if (PyErr_Occurred()) SWIG_fail;
32415 }
32416 resultobj = result;
32417 return resultobj;
32418 fail:
32419 return NULL;
32420 }
32421
32422
32423 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32424 PyObject *resultobj = 0;
32425 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32426 PyObject *arg2 = (PyObject *) 0 ;
32427 bool result;
32428 void *argp1 = 0 ;
32429 int res1 = 0 ;
32430 PyObject * obj0 = 0 ;
32431 PyObject * obj1 = 0 ;
32432 char * kwnames[] = {
32433 (char *) "self",(char *) "data", NULL
32434 };
32435
32436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32438 if (!SWIG_IsOK(res1)) {
32439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32440 }
32441 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32442 arg2 = obj1;
32443 {
32444 PyThreadState* __tstate = wxPyBeginAllowThreads();
32445 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32446 wxPyEndAllowThreads(__tstate);
32447 if (PyErr_Occurred()) SWIG_fail;
32448 }
32449 {
32450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32451 }
32452 return resultobj;
32453 fail:
32454 return NULL;
32455 }
32456
32457
32458 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32459 PyObject *obj;
32460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32461 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32462 return SWIG_Py_Void();
32463 }
32464
32465 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32466 return SWIG_Python_InitShadowInstance(args);
32467 }
32468
32469 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32470 PyObject *resultobj = 0;
32471 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32472 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32473 wxPyDataObjectSimple *result = 0 ;
32474 void *argp1 = 0 ;
32475 int res1 = 0 ;
32476 PyObject * obj0 = 0 ;
32477 char * kwnames[] = {
32478 (char *) "format", NULL
32479 };
32480
32481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32482 if (obj0) {
32483 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32484 if (!SWIG_IsOK(res1)) {
32485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32486 }
32487 if (!argp1) {
32488 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32489 }
32490 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32491 }
32492 {
32493 PyThreadState* __tstate = wxPyBeginAllowThreads();
32494 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32495 wxPyEndAllowThreads(__tstate);
32496 if (PyErr_Occurred()) SWIG_fail;
32497 }
32498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32499 return resultobj;
32500 fail:
32501 return NULL;
32502 }
32503
32504
32505 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32506 PyObject *resultobj = 0;
32507 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32508 PyObject *arg2 = (PyObject *) 0 ;
32509 PyObject *arg3 = (PyObject *) 0 ;
32510 void *argp1 = 0 ;
32511 int res1 = 0 ;
32512 PyObject * obj0 = 0 ;
32513 PyObject * obj1 = 0 ;
32514 PyObject * obj2 = 0 ;
32515 char * kwnames[] = {
32516 (char *) "self",(char *) "self",(char *) "_class", NULL
32517 };
32518
32519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32521 if (!SWIG_IsOK(res1)) {
32522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32523 }
32524 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32525 arg2 = obj1;
32526 arg3 = obj2;
32527 {
32528 PyThreadState* __tstate = wxPyBeginAllowThreads();
32529 (arg1)->_setCallbackInfo(arg2,arg3);
32530 wxPyEndAllowThreads(__tstate);
32531 if (PyErr_Occurred()) SWIG_fail;
32532 }
32533 resultobj = SWIG_Py_Void();
32534 return resultobj;
32535 fail:
32536 return NULL;
32537 }
32538
32539
32540 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32541 PyObject *obj;
32542 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32543 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32544 return SWIG_Py_Void();
32545 }
32546
32547 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32548 return SWIG_Python_InitShadowInstance(args);
32549 }
32550
32551 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32552 PyObject *resultobj = 0;
32553 wxDataObjectComposite *result = 0 ;
32554
32555 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32556 {
32557 PyThreadState* __tstate = wxPyBeginAllowThreads();
32558 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32559 wxPyEndAllowThreads(__tstate);
32560 if (PyErr_Occurred()) SWIG_fail;
32561 }
32562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32563 return resultobj;
32564 fail:
32565 return NULL;
32566 }
32567
32568
32569 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32570 PyObject *resultobj = 0;
32571 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32572 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32573 bool arg3 = (bool) false ;
32574 void *argp1 = 0 ;
32575 int res1 = 0 ;
32576 int res2 = 0 ;
32577 bool val3 ;
32578 int ecode3 = 0 ;
32579 PyObject * obj0 = 0 ;
32580 PyObject * obj1 = 0 ;
32581 PyObject * obj2 = 0 ;
32582 char * kwnames[] = {
32583 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32584 };
32585
32586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32588 if (!SWIG_IsOK(res1)) {
32589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32590 }
32591 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32592 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32593 if (!SWIG_IsOK(res2)) {
32594 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32595 }
32596 if (obj2) {
32597 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32598 if (!SWIG_IsOK(ecode3)) {
32599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32600 }
32601 arg3 = static_cast< bool >(val3);
32602 }
32603 {
32604 PyThreadState* __tstate = wxPyBeginAllowThreads();
32605 (arg1)->Add(arg2,arg3);
32606 wxPyEndAllowThreads(__tstate);
32607 if (PyErr_Occurred()) SWIG_fail;
32608 }
32609 resultobj = SWIG_Py_Void();
32610 return resultobj;
32611 fail:
32612 return NULL;
32613 }
32614
32615
32616 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32617 PyObject *resultobj = 0;
32618 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32619 SwigValueWrapper<wxDataFormat > result;
32620 void *argp1 = 0 ;
32621 int res1 = 0 ;
32622 PyObject *swig_obj[1] ;
32623
32624 if (!args) SWIG_fail;
32625 swig_obj[0] = args;
32626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32627 if (!SWIG_IsOK(res1)) {
32628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32629 }
32630 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32631 {
32632 PyThreadState* __tstate = wxPyBeginAllowThreads();
32633 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32634 wxPyEndAllowThreads(__tstate);
32635 if (PyErr_Occurred()) SWIG_fail;
32636 }
32637 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32638 return resultobj;
32639 fail:
32640 return NULL;
32641 }
32642
32643
32644 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32645 PyObject *obj;
32646 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32647 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32648 return SWIG_Py_Void();
32649 }
32650
32651 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32652 return SWIG_Python_InitShadowInstance(args);
32653 }
32654
32655 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32656 PyObject *resultobj = 0;
32657 wxString const &arg1_defvalue = wxPyEmptyString ;
32658 wxString *arg1 = (wxString *) &arg1_defvalue ;
32659 wxTextDataObject *result = 0 ;
32660 bool temp1 = false ;
32661 PyObject * obj0 = 0 ;
32662 char * kwnames[] = {
32663 (char *) "text", NULL
32664 };
32665
32666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32667 if (obj0) {
32668 {
32669 arg1 = wxString_in_helper(obj0);
32670 if (arg1 == NULL) SWIG_fail;
32671 temp1 = true;
32672 }
32673 }
32674 {
32675 PyThreadState* __tstate = wxPyBeginAllowThreads();
32676 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32677 wxPyEndAllowThreads(__tstate);
32678 if (PyErr_Occurred()) SWIG_fail;
32679 }
32680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32681 {
32682 if (temp1)
32683 delete arg1;
32684 }
32685 return resultobj;
32686 fail:
32687 {
32688 if (temp1)
32689 delete arg1;
32690 }
32691 return NULL;
32692 }
32693
32694
32695 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32696 PyObject *resultobj = 0;
32697 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32698 size_t result;
32699 void *argp1 = 0 ;
32700 int res1 = 0 ;
32701 PyObject *swig_obj[1] ;
32702
32703 if (!args) SWIG_fail;
32704 swig_obj[0] = args;
32705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32706 if (!SWIG_IsOK(res1)) {
32707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32708 }
32709 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32710 {
32711 PyThreadState* __tstate = wxPyBeginAllowThreads();
32712 result = (size_t)(arg1)->GetTextLength();
32713 wxPyEndAllowThreads(__tstate);
32714 if (PyErr_Occurred()) SWIG_fail;
32715 }
32716 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32717 return resultobj;
32718 fail:
32719 return NULL;
32720 }
32721
32722
32723 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32724 PyObject *resultobj = 0;
32725 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32726 wxString result;
32727 void *argp1 = 0 ;
32728 int res1 = 0 ;
32729 PyObject *swig_obj[1] ;
32730
32731 if (!args) SWIG_fail;
32732 swig_obj[0] = args;
32733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32734 if (!SWIG_IsOK(res1)) {
32735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32736 }
32737 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32738 {
32739 PyThreadState* __tstate = wxPyBeginAllowThreads();
32740 result = (arg1)->GetText();
32741 wxPyEndAllowThreads(__tstate);
32742 if (PyErr_Occurred()) SWIG_fail;
32743 }
32744 {
32745 #if wxUSE_UNICODE
32746 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32747 #else
32748 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32749 #endif
32750 }
32751 return resultobj;
32752 fail:
32753 return NULL;
32754 }
32755
32756
32757 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32758 PyObject *resultobj = 0;
32759 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32760 wxString *arg2 = 0 ;
32761 void *argp1 = 0 ;
32762 int res1 = 0 ;
32763 bool temp2 = false ;
32764 PyObject * obj0 = 0 ;
32765 PyObject * obj1 = 0 ;
32766 char * kwnames[] = {
32767 (char *) "self",(char *) "text", NULL
32768 };
32769
32770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32772 if (!SWIG_IsOK(res1)) {
32773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32774 }
32775 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32776 {
32777 arg2 = wxString_in_helper(obj1);
32778 if (arg2 == NULL) SWIG_fail;
32779 temp2 = true;
32780 }
32781 {
32782 PyThreadState* __tstate = wxPyBeginAllowThreads();
32783 (arg1)->SetText((wxString const &)*arg2);
32784 wxPyEndAllowThreads(__tstate);
32785 if (PyErr_Occurred()) SWIG_fail;
32786 }
32787 resultobj = SWIG_Py_Void();
32788 {
32789 if (temp2)
32790 delete arg2;
32791 }
32792 return resultobj;
32793 fail:
32794 {
32795 if (temp2)
32796 delete arg2;
32797 }
32798 return NULL;
32799 }
32800
32801
32802 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32803 PyObject *obj;
32804 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32805 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32806 return SWIG_Py_Void();
32807 }
32808
32809 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32810 return SWIG_Python_InitShadowInstance(args);
32811 }
32812
32813 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32814 PyObject *resultobj = 0;
32815 wxString const &arg1_defvalue = wxPyEmptyString ;
32816 wxString *arg1 = (wxString *) &arg1_defvalue ;
32817 wxPyTextDataObject *result = 0 ;
32818 bool temp1 = false ;
32819 PyObject * obj0 = 0 ;
32820 char * kwnames[] = {
32821 (char *) "text", NULL
32822 };
32823
32824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32825 if (obj0) {
32826 {
32827 arg1 = wxString_in_helper(obj0);
32828 if (arg1 == NULL) SWIG_fail;
32829 temp1 = true;
32830 }
32831 }
32832 {
32833 PyThreadState* __tstate = wxPyBeginAllowThreads();
32834 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32835 wxPyEndAllowThreads(__tstate);
32836 if (PyErr_Occurred()) SWIG_fail;
32837 }
32838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32839 {
32840 if (temp1)
32841 delete arg1;
32842 }
32843 return resultobj;
32844 fail:
32845 {
32846 if (temp1)
32847 delete arg1;
32848 }
32849 return NULL;
32850 }
32851
32852
32853 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32854 PyObject *resultobj = 0;
32855 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32856 PyObject *arg2 = (PyObject *) 0 ;
32857 PyObject *arg3 = (PyObject *) 0 ;
32858 void *argp1 = 0 ;
32859 int res1 = 0 ;
32860 PyObject * obj0 = 0 ;
32861 PyObject * obj1 = 0 ;
32862 PyObject * obj2 = 0 ;
32863 char * kwnames[] = {
32864 (char *) "self",(char *) "self",(char *) "_class", NULL
32865 };
32866
32867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32869 if (!SWIG_IsOK(res1)) {
32870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32871 }
32872 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32873 arg2 = obj1;
32874 arg3 = obj2;
32875 {
32876 PyThreadState* __tstate = wxPyBeginAllowThreads();
32877 (arg1)->_setCallbackInfo(arg2,arg3);
32878 wxPyEndAllowThreads(__tstate);
32879 if (PyErr_Occurred()) SWIG_fail;
32880 }
32881 resultobj = SWIG_Py_Void();
32882 return resultobj;
32883 fail:
32884 return NULL;
32885 }
32886
32887
32888 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32889 PyObject *obj;
32890 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32891 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32892 return SWIG_Py_Void();
32893 }
32894
32895 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32896 return SWIG_Python_InitShadowInstance(args);
32897 }
32898
32899 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32900 PyObject *resultobj = 0;
32901 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32902 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32903 wxBitmapDataObject *result = 0 ;
32904 void *argp1 = 0 ;
32905 int res1 = 0 ;
32906 PyObject * obj0 = 0 ;
32907 char * kwnames[] = {
32908 (char *) "bitmap", NULL
32909 };
32910
32911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
32912 if (obj0) {
32913 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32914 if (!SWIG_IsOK(res1)) {
32915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32916 }
32917 if (!argp1) {
32918 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32919 }
32920 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32921 }
32922 {
32923 PyThreadState* __tstate = wxPyBeginAllowThreads();
32924 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
32925 wxPyEndAllowThreads(__tstate);
32926 if (PyErr_Occurred()) SWIG_fail;
32927 }
32928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
32929 return resultobj;
32930 fail:
32931 return NULL;
32932 }
32933
32934
32935 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32936 PyObject *resultobj = 0;
32937 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32938 wxBitmap result;
32939 void *argp1 = 0 ;
32940 int res1 = 0 ;
32941 PyObject *swig_obj[1] ;
32942
32943 if (!args) SWIG_fail;
32944 swig_obj[0] = args;
32945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32946 if (!SWIG_IsOK(res1)) {
32947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
32948 }
32949 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32950 {
32951 PyThreadState* __tstate = wxPyBeginAllowThreads();
32952 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
32953 wxPyEndAllowThreads(__tstate);
32954 if (PyErr_Occurred()) SWIG_fail;
32955 }
32956 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
32957 return resultobj;
32958 fail:
32959 return NULL;
32960 }
32961
32962
32963 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32964 PyObject *resultobj = 0;
32965 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32966 wxBitmap *arg2 = 0 ;
32967 void *argp1 = 0 ;
32968 int res1 = 0 ;
32969 void *argp2 = 0 ;
32970 int res2 = 0 ;
32971 PyObject * obj0 = 0 ;
32972 PyObject * obj1 = 0 ;
32973 char * kwnames[] = {
32974 (char *) "self",(char *) "bitmap", NULL
32975 };
32976
32977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
32978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32979 if (!SWIG_IsOK(res1)) {
32980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
32981 }
32982 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32983 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
32984 if (!SWIG_IsOK(res2)) {
32985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32986 }
32987 if (!argp2) {
32988 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32989 }
32990 arg2 = reinterpret_cast< wxBitmap * >(argp2);
32991 {
32992 PyThreadState* __tstate = wxPyBeginAllowThreads();
32993 (arg1)->SetBitmap((wxBitmap const &)*arg2);
32994 wxPyEndAllowThreads(__tstate);
32995 if (PyErr_Occurred()) SWIG_fail;
32996 }
32997 resultobj = SWIG_Py_Void();
32998 return resultobj;
32999 fail:
33000 return NULL;
33001 }
33002
33003
33004 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33005 PyObject *obj;
33006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33007 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33008 return SWIG_Py_Void();
33009 }
33010
33011 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33012 return SWIG_Python_InitShadowInstance(args);
33013 }
33014
33015 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33016 PyObject *resultobj = 0;
33017 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33018 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33019 wxPyBitmapDataObject *result = 0 ;
33020 void *argp1 = 0 ;
33021 int res1 = 0 ;
33022 PyObject * obj0 = 0 ;
33023 char * kwnames[] = {
33024 (char *) "bitmap", NULL
33025 };
33026
33027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33028 if (obj0) {
33029 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33030 if (!SWIG_IsOK(res1)) {
33031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33032 }
33033 if (!argp1) {
33034 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33035 }
33036 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33037 }
33038 {
33039 PyThreadState* __tstate = wxPyBeginAllowThreads();
33040 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33041 wxPyEndAllowThreads(__tstate);
33042 if (PyErr_Occurred()) SWIG_fail;
33043 }
33044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33045 return resultobj;
33046 fail:
33047 return NULL;
33048 }
33049
33050
33051 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33052 PyObject *resultobj = 0;
33053 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33054 PyObject *arg2 = (PyObject *) 0 ;
33055 PyObject *arg3 = (PyObject *) 0 ;
33056 void *argp1 = 0 ;
33057 int res1 = 0 ;
33058 PyObject * obj0 = 0 ;
33059 PyObject * obj1 = 0 ;
33060 PyObject * obj2 = 0 ;
33061 char * kwnames[] = {
33062 (char *) "self",(char *) "self",(char *) "_class", NULL
33063 };
33064
33065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33067 if (!SWIG_IsOK(res1)) {
33068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33069 }
33070 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33071 arg2 = obj1;
33072 arg3 = obj2;
33073 {
33074 PyThreadState* __tstate = wxPyBeginAllowThreads();
33075 (arg1)->_setCallbackInfo(arg2,arg3);
33076 wxPyEndAllowThreads(__tstate);
33077 if (PyErr_Occurred()) SWIG_fail;
33078 }
33079 resultobj = SWIG_Py_Void();
33080 return resultobj;
33081 fail:
33082 return NULL;
33083 }
33084
33085
33086 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33087 PyObject *obj;
33088 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33089 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33090 return SWIG_Py_Void();
33091 }
33092
33093 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33094 return SWIG_Python_InitShadowInstance(args);
33095 }
33096
33097 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33098 PyObject *resultobj = 0;
33099 wxFileDataObject *result = 0 ;
33100
33101 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33102 {
33103 PyThreadState* __tstate = wxPyBeginAllowThreads();
33104 result = (wxFileDataObject *)new wxFileDataObject();
33105 wxPyEndAllowThreads(__tstate);
33106 if (PyErr_Occurred()) SWIG_fail;
33107 }
33108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33109 return resultobj;
33110 fail:
33111 return NULL;
33112 }
33113
33114
33115 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33116 PyObject *resultobj = 0;
33117 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33118 wxArrayString *result = 0 ;
33119 void *argp1 = 0 ;
33120 int res1 = 0 ;
33121 PyObject *swig_obj[1] ;
33122
33123 if (!args) SWIG_fail;
33124 swig_obj[0] = args;
33125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33126 if (!SWIG_IsOK(res1)) {
33127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33128 }
33129 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33130 {
33131 PyThreadState* __tstate = wxPyBeginAllowThreads();
33132 {
33133 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33134 result = (wxArrayString *) &_result_ref;
33135 }
33136 wxPyEndAllowThreads(__tstate);
33137 if (PyErr_Occurred()) SWIG_fail;
33138 }
33139 {
33140 resultobj = wxArrayString2PyList_helper(*result);
33141 }
33142 return resultobj;
33143 fail:
33144 return NULL;
33145 }
33146
33147
33148 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33149 PyObject *resultobj = 0;
33150 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33151 wxString *arg2 = 0 ;
33152 void *argp1 = 0 ;
33153 int res1 = 0 ;
33154 bool temp2 = false ;
33155 PyObject * obj0 = 0 ;
33156 PyObject * obj1 = 0 ;
33157 char * kwnames[] = {
33158 (char *) "self",(char *) "filename", NULL
33159 };
33160
33161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33163 if (!SWIG_IsOK(res1)) {
33164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33165 }
33166 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33167 {
33168 arg2 = wxString_in_helper(obj1);
33169 if (arg2 == NULL) SWIG_fail;
33170 temp2 = true;
33171 }
33172 {
33173 PyThreadState* __tstate = wxPyBeginAllowThreads();
33174 (arg1)->AddFile((wxString const &)*arg2);
33175 wxPyEndAllowThreads(__tstate);
33176 if (PyErr_Occurred()) SWIG_fail;
33177 }
33178 resultobj = SWIG_Py_Void();
33179 {
33180 if (temp2)
33181 delete arg2;
33182 }
33183 return resultobj;
33184 fail:
33185 {
33186 if (temp2)
33187 delete arg2;
33188 }
33189 return NULL;
33190 }
33191
33192
33193 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33194 PyObject *obj;
33195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33196 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33197 return SWIG_Py_Void();
33198 }
33199
33200 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33201 return SWIG_Python_InitShadowInstance(args);
33202 }
33203
33204 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33205 PyObject *resultobj = 0;
33206 wxDataFormat *arg1 = 0 ;
33207 wxCustomDataObject *result = 0 ;
33208 void *argp1 = 0 ;
33209 int res1 = 0 ;
33210
33211 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33213 if (!SWIG_IsOK(res1)) {
33214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33215 }
33216 if (!argp1) {
33217 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33218 }
33219 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33220 {
33221 PyThreadState* __tstate = wxPyBeginAllowThreads();
33222 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33223 wxPyEndAllowThreads(__tstate);
33224 if (PyErr_Occurred()) SWIG_fail;
33225 }
33226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33227 return resultobj;
33228 fail:
33229 return NULL;
33230 }
33231
33232
33233 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33234 PyObject *resultobj = 0;
33235 wxString *arg1 = 0 ;
33236 wxCustomDataObject *result = 0 ;
33237 bool temp1 = false ;
33238
33239 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33240 {
33241 arg1 = wxString_in_helper(swig_obj[0]);
33242 if (arg1 == NULL) SWIG_fail;
33243 temp1 = true;
33244 }
33245 {
33246 PyThreadState* __tstate = wxPyBeginAllowThreads();
33247 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33248 wxPyEndAllowThreads(__tstate);
33249 if (PyErr_Occurred()) SWIG_fail;
33250 }
33251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33252 {
33253 if (temp1)
33254 delete arg1;
33255 }
33256 return resultobj;
33257 fail:
33258 {
33259 if (temp1)
33260 delete arg1;
33261 }
33262 return NULL;
33263 }
33264
33265
33266 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33267 PyObject *resultobj = 0;
33268 wxCustomDataObject *result = 0 ;
33269
33270 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33271 {
33272 PyThreadState* __tstate = wxPyBeginAllowThreads();
33273 result = (wxCustomDataObject *)new wxCustomDataObject();
33274 wxPyEndAllowThreads(__tstate);
33275 if (PyErr_Occurred()) SWIG_fail;
33276 }
33277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33278 return resultobj;
33279 fail:
33280 return NULL;
33281 }
33282
33283
33284 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33285 int argc;
33286 PyObject *argv[2];
33287
33288 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33289 --argc;
33290 if (argc == 0) {
33291 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33292 }
33293 if (argc == 1) {
33294 int _v = 0;
33295 {
33296 {
33297 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33298 }
33299 }
33300 if (!_v) goto check_2;
33301 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33302 }
33303 check_2:
33304
33305 if (argc == 1) {
33306 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33307 }
33308
33309 fail:
33310 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33311 return NULL;
33312 }
33313
33314
33315 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33316 PyObject *resultobj = 0;
33317 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33318 PyObject *arg2 = (PyObject *) 0 ;
33319 bool result;
33320 void *argp1 = 0 ;
33321 int res1 = 0 ;
33322 PyObject * obj0 = 0 ;
33323 PyObject * obj1 = 0 ;
33324 char * kwnames[] = {
33325 (char *) "self",(char *) "data", NULL
33326 };
33327
33328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33330 if (!SWIG_IsOK(res1)) {
33331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33332 }
33333 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33334 arg2 = obj1;
33335 {
33336 PyThreadState* __tstate = wxPyBeginAllowThreads();
33337 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33338 wxPyEndAllowThreads(__tstate);
33339 if (PyErr_Occurred()) SWIG_fail;
33340 }
33341 {
33342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33343 }
33344 return resultobj;
33345 fail:
33346 return NULL;
33347 }
33348
33349
33350 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33351 PyObject *resultobj = 0;
33352 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33353 size_t result;
33354 void *argp1 = 0 ;
33355 int res1 = 0 ;
33356 PyObject *swig_obj[1] ;
33357
33358 if (!args) SWIG_fail;
33359 swig_obj[0] = args;
33360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33361 if (!SWIG_IsOK(res1)) {
33362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33363 }
33364 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33365 {
33366 PyThreadState* __tstate = wxPyBeginAllowThreads();
33367 result = (size_t)(arg1)->GetSize();
33368 wxPyEndAllowThreads(__tstate);
33369 if (PyErr_Occurred()) SWIG_fail;
33370 }
33371 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33372 return resultobj;
33373 fail:
33374 return NULL;
33375 }
33376
33377
33378 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33379 PyObject *resultobj = 0;
33380 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33381 PyObject *result = 0 ;
33382 void *argp1 = 0 ;
33383 int res1 = 0 ;
33384 PyObject *swig_obj[1] ;
33385
33386 if (!args) SWIG_fail;
33387 swig_obj[0] = args;
33388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33389 if (!SWIG_IsOK(res1)) {
33390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33391 }
33392 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33393 {
33394 PyThreadState* __tstate = wxPyBeginAllowThreads();
33395 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33396 wxPyEndAllowThreads(__tstate);
33397 if (PyErr_Occurred()) SWIG_fail;
33398 }
33399 resultobj = result;
33400 return resultobj;
33401 fail:
33402 return NULL;
33403 }
33404
33405
33406 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33407 PyObject *obj;
33408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33409 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33410 return SWIG_Py_Void();
33411 }
33412
33413 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33414 return SWIG_Python_InitShadowInstance(args);
33415 }
33416
33417 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33418 PyObject *resultobj = 0;
33419 wxString const &arg1_defvalue = wxPyEmptyString ;
33420 wxString *arg1 = (wxString *) &arg1_defvalue ;
33421 wxURLDataObject *result = 0 ;
33422 bool temp1 = false ;
33423 PyObject * obj0 = 0 ;
33424 char * kwnames[] = {
33425 (char *) "url", NULL
33426 };
33427
33428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33429 if (obj0) {
33430 {
33431 arg1 = wxString_in_helper(obj0);
33432 if (arg1 == NULL) SWIG_fail;
33433 temp1 = true;
33434 }
33435 }
33436 {
33437 PyThreadState* __tstate = wxPyBeginAllowThreads();
33438 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33439 wxPyEndAllowThreads(__tstate);
33440 if (PyErr_Occurred()) SWIG_fail;
33441 }
33442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33443 {
33444 if (temp1)
33445 delete arg1;
33446 }
33447 return resultobj;
33448 fail:
33449 {
33450 if (temp1)
33451 delete arg1;
33452 }
33453 return NULL;
33454 }
33455
33456
33457 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33458 PyObject *resultobj = 0;
33459 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33460 wxString result;
33461 void *argp1 = 0 ;
33462 int res1 = 0 ;
33463 PyObject *swig_obj[1] ;
33464
33465 if (!args) SWIG_fail;
33466 swig_obj[0] = args;
33467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33468 if (!SWIG_IsOK(res1)) {
33469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33470 }
33471 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33472 {
33473 PyThreadState* __tstate = wxPyBeginAllowThreads();
33474 result = (arg1)->GetURL();
33475 wxPyEndAllowThreads(__tstate);
33476 if (PyErr_Occurred()) SWIG_fail;
33477 }
33478 {
33479 #if wxUSE_UNICODE
33480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33481 #else
33482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33483 #endif
33484 }
33485 return resultobj;
33486 fail:
33487 return NULL;
33488 }
33489
33490
33491 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33492 PyObject *resultobj = 0;
33493 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33494 wxString *arg2 = 0 ;
33495 void *argp1 = 0 ;
33496 int res1 = 0 ;
33497 bool temp2 = false ;
33498 PyObject * obj0 = 0 ;
33499 PyObject * obj1 = 0 ;
33500 char * kwnames[] = {
33501 (char *) "self",(char *) "url", NULL
33502 };
33503
33504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33506 if (!SWIG_IsOK(res1)) {
33507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33508 }
33509 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33510 {
33511 arg2 = wxString_in_helper(obj1);
33512 if (arg2 == NULL) SWIG_fail;
33513 temp2 = true;
33514 }
33515 {
33516 PyThreadState* __tstate = wxPyBeginAllowThreads();
33517 (arg1)->SetURL((wxString const &)*arg2);
33518 wxPyEndAllowThreads(__tstate);
33519 if (PyErr_Occurred()) SWIG_fail;
33520 }
33521 resultobj = SWIG_Py_Void();
33522 {
33523 if (temp2)
33524 delete arg2;
33525 }
33526 return resultobj;
33527 fail:
33528 {
33529 if (temp2)
33530 delete arg2;
33531 }
33532 return NULL;
33533 }
33534
33535
33536 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33537 PyObject *obj;
33538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33539 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33540 return SWIG_Py_Void();
33541 }
33542
33543 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33544 return SWIG_Python_InitShadowInstance(args);
33545 }
33546
33547 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33548 PyObject *resultobj = 0;
33549 wxMetafileDataObject *result = 0 ;
33550
33551 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33552 {
33553 PyThreadState* __tstate = wxPyBeginAllowThreads();
33554 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33555 wxPyEndAllowThreads(__tstate);
33556 if (PyErr_Occurred()) SWIG_fail;
33557 }
33558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33559 return resultobj;
33560 fail:
33561 return NULL;
33562 }
33563
33564
33565 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33566 PyObject *resultobj = 0;
33567 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33568 wxMetafile *arg2 = 0 ;
33569 void *argp1 = 0 ;
33570 int res1 = 0 ;
33571 void *argp2 = 0 ;
33572 int res2 = 0 ;
33573 PyObject * obj0 = 0 ;
33574 PyObject * obj1 = 0 ;
33575 char * kwnames[] = {
33576 (char *) "self",(char *) "metafile", NULL
33577 };
33578
33579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
33580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33581 if (!SWIG_IsOK(res1)) {
33582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
33583 }
33584 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33585 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
33586 if (!SWIG_IsOK(res2)) {
33587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33588 }
33589 if (!argp2) {
33590 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33591 }
33592 arg2 = reinterpret_cast< wxMetafile * >(argp2);
33593 {
33594 PyThreadState* __tstate = wxPyBeginAllowThreads();
33595 (arg1)->SetMetafile((wxMetafile const &)*arg2);
33596 wxPyEndAllowThreads(__tstate);
33597 if (PyErr_Occurred()) SWIG_fail;
33598 }
33599 resultobj = SWIG_Py_Void();
33600 return resultobj;
33601 fail:
33602 return NULL;
33603 }
33604
33605
33606 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33607 PyObject *resultobj = 0;
33608 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33609 wxMetafile result;
33610 void *argp1 = 0 ;
33611 int res1 = 0 ;
33612 PyObject *swig_obj[1] ;
33613
33614 if (!args) SWIG_fail;
33615 swig_obj[0] = args;
33616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33617 if (!SWIG_IsOK(res1)) {
33618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
33619 }
33620 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33621 {
33622 PyThreadState* __tstate = wxPyBeginAllowThreads();
33623 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
33624 wxPyEndAllowThreads(__tstate);
33625 if (PyErr_Occurred()) SWIG_fail;
33626 }
33627 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
33628 return resultobj;
33629 fail:
33630 return NULL;
33631 }
33632
33633
33634 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33635 PyObject *obj;
33636 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33637 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33638 return SWIG_Py_Void();
33639 }
33640
33641 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33642 return SWIG_Python_InitShadowInstance(args);
33643 }
33644
33645 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33646 PyObject *resultobj = 0;
33647 wxDragResult arg1 ;
33648 bool result;
33649 int val1 ;
33650 int ecode1 = 0 ;
33651 PyObject * obj0 = 0 ;
33652 char * kwnames[] = {
33653 (char *) "res", NULL
33654 };
33655
33656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33657 ecode1 = SWIG_AsVal_int(obj0, &val1);
33658 if (!SWIG_IsOK(ecode1)) {
33659 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33660 }
33661 arg1 = static_cast< wxDragResult >(val1);
33662 {
33663 PyThreadState* __tstate = wxPyBeginAllowThreads();
33664 result = (bool)wxIsDragResultOk(arg1);
33665 wxPyEndAllowThreads(__tstate);
33666 if (PyErr_Occurred()) SWIG_fail;
33667 }
33668 {
33669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33670 }
33671 return resultobj;
33672 fail:
33673 return NULL;
33674 }
33675
33676
33677 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33678 PyObject *resultobj = 0;
33679 wxWindow *arg1 = (wxWindow *) 0 ;
33680 wxCursor const &arg2_defvalue = wxNullCursor ;
33681 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
33682 wxCursor const &arg3_defvalue = wxNullCursor ;
33683 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
33684 wxCursor const &arg4_defvalue = wxNullCursor ;
33685 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
33686 wxPyDropSource *result = 0 ;
33687 void *argp1 = 0 ;
33688 int res1 = 0 ;
33689 void *argp2 = 0 ;
33690 int res2 = 0 ;
33691 void *argp3 = 0 ;
33692 int res3 = 0 ;
33693 void *argp4 = 0 ;
33694 int res4 = 0 ;
33695 PyObject * obj0 = 0 ;
33696 PyObject * obj1 = 0 ;
33697 PyObject * obj2 = 0 ;
33698 PyObject * obj3 = 0 ;
33699 char * kwnames[] = {
33700 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33701 };
33702
33703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33705 if (!SWIG_IsOK(res1)) {
33706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33707 }
33708 arg1 = reinterpret_cast< wxWindow * >(argp1);
33709 if (obj1) {
33710 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
33711 if (!SWIG_IsOK(res2)) {
33712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33713 }
33714 if (!argp2) {
33715 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33716 }
33717 arg2 = reinterpret_cast< wxCursor * >(argp2);
33718 }
33719 if (obj2) {
33720 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33721 if (!SWIG_IsOK(res3)) {
33722 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33723 }
33724 if (!argp3) {
33725 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33726 }
33727 arg3 = reinterpret_cast< wxCursor * >(argp3);
33728 }
33729 if (obj3) {
33730 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
33731 if (!SWIG_IsOK(res4)) {
33732 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33733 }
33734 if (!argp4) {
33735 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33736 }
33737 arg4 = reinterpret_cast< wxCursor * >(argp4);
33738 }
33739 {
33740 PyThreadState* __tstate = wxPyBeginAllowThreads();
33741 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
33742 wxPyEndAllowThreads(__tstate);
33743 if (PyErr_Occurred()) SWIG_fail;
33744 }
33745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33746 return resultobj;
33747 fail:
33748 return NULL;
33749 }
33750
33751
33752 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33753 PyObject *resultobj = 0;
33754 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33755 PyObject *arg2 = (PyObject *) 0 ;
33756 PyObject *arg3 = (PyObject *) 0 ;
33757 int arg4 ;
33758 void *argp1 = 0 ;
33759 int res1 = 0 ;
33760 int val4 ;
33761 int ecode4 = 0 ;
33762 PyObject * obj0 = 0 ;
33763 PyObject * obj1 = 0 ;
33764 PyObject * obj2 = 0 ;
33765 PyObject * obj3 = 0 ;
33766 char * kwnames[] = {
33767 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33768 };
33769
33770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33772 if (!SWIG_IsOK(res1)) {
33773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33774 }
33775 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33776 arg2 = obj1;
33777 arg3 = obj2;
33778 ecode4 = SWIG_AsVal_int(obj3, &val4);
33779 if (!SWIG_IsOK(ecode4)) {
33780 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33781 }
33782 arg4 = static_cast< int >(val4);
33783 {
33784 PyThreadState* __tstate = wxPyBeginAllowThreads();
33785 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33786 wxPyEndAllowThreads(__tstate);
33787 if (PyErr_Occurred()) SWIG_fail;
33788 }
33789 resultobj = SWIG_Py_Void();
33790 return resultobj;
33791 fail:
33792 return NULL;
33793 }
33794
33795
33796 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33797 PyObject *resultobj = 0;
33798 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33799 void *argp1 = 0 ;
33800 int res1 = 0 ;
33801 PyObject *swig_obj[1] ;
33802
33803 if (!args) SWIG_fail;
33804 swig_obj[0] = args;
33805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33806 if (!SWIG_IsOK(res1)) {
33807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33808 }
33809 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33810 {
33811 PyThreadState* __tstate = wxPyBeginAllowThreads();
33812 delete arg1;
33813
33814 wxPyEndAllowThreads(__tstate);
33815 if (PyErr_Occurred()) SWIG_fail;
33816 }
33817 resultobj = SWIG_Py_Void();
33818 return resultobj;
33819 fail:
33820 return NULL;
33821 }
33822
33823
33824 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33825 PyObject *resultobj = 0;
33826 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33827 wxDataObject *arg2 = 0 ;
33828 void *argp1 = 0 ;
33829 int res1 = 0 ;
33830 void *argp2 = 0 ;
33831 int res2 = 0 ;
33832 PyObject * obj0 = 0 ;
33833 PyObject * obj1 = 0 ;
33834 char * kwnames[] = {
33835 (char *) "self",(char *) "data", NULL
33836 };
33837
33838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33840 if (!SWIG_IsOK(res1)) {
33841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33842 }
33843 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33844 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33845 if (!SWIG_IsOK(res2)) {
33846 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33847 }
33848 if (!argp2) {
33849 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33850 }
33851 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33852 {
33853 PyThreadState* __tstate = wxPyBeginAllowThreads();
33854 (arg1)->SetData(*arg2);
33855 wxPyEndAllowThreads(__tstate);
33856 if (PyErr_Occurred()) SWIG_fail;
33857 }
33858 resultobj = SWIG_Py_Void();
33859 return resultobj;
33860 fail:
33861 return NULL;
33862 }
33863
33864
33865 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33866 PyObject *resultobj = 0;
33867 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33868 wxDataObject *result = 0 ;
33869 void *argp1 = 0 ;
33870 int res1 = 0 ;
33871 PyObject *swig_obj[1] ;
33872
33873 if (!args) SWIG_fail;
33874 swig_obj[0] = args;
33875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33876 if (!SWIG_IsOK(res1)) {
33877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33878 }
33879 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33880 {
33881 PyThreadState* __tstate = wxPyBeginAllowThreads();
33882 result = (wxDataObject *)(arg1)->GetDataObject();
33883 wxPyEndAllowThreads(__tstate);
33884 if (PyErr_Occurred()) SWIG_fail;
33885 }
33886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33887 return resultobj;
33888 fail:
33889 return NULL;
33890 }
33891
33892
33893 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33894 PyObject *resultobj = 0;
33895 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33896 wxDragResult arg2 ;
33897 wxCursor *arg3 = 0 ;
33898 void *argp1 = 0 ;
33899 int res1 = 0 ;
33900 int val2 ;
33901 int ecode2 = 0 ;
33902 void *argp3 = 0 ;
33903 int res3 = 0 ;
33904 PyObject * obj0 = 0 ;
33905 PyObject * obj1 = 0 ;
33906 PyObject * obj2 = 0 ;
33907 char * kwnames[] = {
33908 (char *) "self",(char *) "res",(char *) "cursor", NULL
33909 };
33910
33911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33913 if (!SWIG_IsOK(res1)) {
33914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33915 }
33916 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33917 ecode2 = SWIG_AsVal_int(obj1, &val2);
33918 if (!SWIG_IsOK(ecode2)) {
33919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33920 }
33921 arg2 = static_cast< wxDragResult >(val2);
33922 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33923 if (!SWIG_IsOK(res3)) {
33924 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33925 }
33926 if (!argp3) {
33927 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33928 }
33929 arg3 = reinterpret_cast< wxCursor * >(argp3);
33930 {
33931 PyThreadState* __tstate = wxPyBeginAllowThreads();
33932 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33933 wxPyEndAllowThreads(__tstate);
33934 if (PyErr_Occurred()) SWIG_fail;
33935 }
33936 resultobj = SWIG_Py_Void();
33937 return resultobj;
33938 fail:
33939 return NULL;
33940 }
33941
33942
33943 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33944 PyObject *resultobj = 0;
33945 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33946 int arg2 = (int) wxDrag_CopyOnly ;
33947 wxDragResult result;
33948 void *argp1 = 0 ;
33949 int res1 = 0 ;
33950 int val2 ;
33951 int ecode2 = 0 ;
33952 PyObject * obj0 = 0 ;
33953 PyObject * obj1 = 0 ;
33954 char * kwnames[] = {
33955 (char *) "self",(char *) "flags", NULL
33956 };
33957
33958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
33959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33960 if (!SWIG_IsOK(res1)) {
33961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33962 }
33963 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33964 if (obj1) {
33965 ecode2 = SWIG_AsVal_int(obj1, &val2);
33966 if (!SWIG_IsOK(ecode2)) {
33967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
33968 }
33969 arg2 = static_cast< int >(val2);
33970 }
33971 {
33972 PyThreadState* __tstate = wxPyBeginAllowThreads();
33973 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
33974 wxPyEndAllowThreads(__tstate);
33975 if (PyErr_Occurred()) SWIG_fail;
33976 }
33977 resultobj = SWIG_From_int(static_cast< int >(result));
33978 return resultobj;
33979 fail:
33980 return NULL;
33981 }
33982
33983
33984 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33985 PyObject *resultobj = 0;
33986 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33987 wxDragResult arg2 ;
33988 bool result;
33989 void *argp1 = 0 ;
33990 int res1 = 0 ;
33991 int val2 ;
33992 int ecode2 = 0 ;
33993 PyObject * obj0 = 0 ;
33994 PyObject * obj1 = 0 ;
33995 char * kwnames[] = {
33996 (char *) "self",(char *) "effect", NULL
33997 };
33998
33999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34001 if (!SWIG_IsOK(res1)) {
34002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34003 }
34004 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34005 ecode2 = SWIG_AsVal_int(obj1, &val2);
34006 if (!SWIG_IsOK(ecode2)) {
34007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34008 }
34009 arg2 = static_cast< wxDragResult >(val2);
34010 {
34011 PyThreadState* __tstate = wxPyBeginAllowThreads();
34012 result = (bool)(arg1)->GiveFeedback(arg2);
34013 wxPyEndAllowThreads(__tstate);
34014 if (PyErr_Occurred()) SWIG_fail;
34015 }
34016 {
34017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34018 }
34019 return resultobj;
34020 fail:
34021 return NULL;
34022 }
34023
34024
34025 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34026 PyObject *obj;
34027 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34028 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34029 return SWIG_Py_Void();
34030 }
34031
34032 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34033 return SWIG_Python_InitShadowInstance(args);
34034 }
34035
34036 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34037 PyObject *resultobj = 0;
34038 wxDataObject *arg1 = (wxDataObject *) NULL ;
34039 wxPyDropTarget *result = 0 ;
34040 int res1 = 0 ;
34041 PyObject * obj0 = 0 ;
34042 char * kwnames[] = {
34043 (char *) "dataObject", NULL
34044 };
34045
34046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34047 if (obj0) {
34048 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34049 if (!SWIG_IsOK(res1)) {
34050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34051 }
34052 }
34053 {
34054 PyThreadState* __tstate = wxPyBeginAllowThreads();
34055 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34056 wxPyEndAllowThreads(__tstate);
34057 if (PyErr_Occurred()) SWIG_fail;
34058 }
34059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34060 return resultobj;
34061 fail:
34062 return NULL;
34063 }
34064
34065
34066 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34067 PyObject *resultobj = 0;
34068 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34069 PyObject *arg2 = (PyObject *) 0 ;
34070 PyObject *arg3 = (PyObject *) 0 ;
34071 void *argp1 = 0 ;
34072 int res1 = 0 ;
34073 PyObject * obj0 = 0 ;
34074 PyObject * obj1 = 0 ;
34075 PyObject * obj2 = 0 ;
34076 char * kwnames[] = {
34077 (char *) "self",(char *) "self",(char *) "_class", NULL
34078 };
34079
34080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34082 if (!SWIG_IsOK(res1)) {
34083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34084 }
34085 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34086 arg2 = obj1;
34087 arg3 = obj2;
34088 {
34089 PyThreadState* __tstate = wxPyBeginAllowThreads();
34090 (arg1)->_setCallbackInfo(arg2,arg3);
34091 wxPyEndAllowThreads(__tstate);
34092 if (PyErr_Occurred()) SWIG_fail;
34093 }
34094 resultobj = SWIG_Py_Void();
34095 return resultobj;
34096 fail:
34097 return NULL;
34098 }
34099
34100
34101 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34102 PyObject *resultobj = 0;
34103 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34104 void *argp1 = 0 ;
34105 int res1 = 0 ;
34106 PyObject *swig_obj[1] ;
34107
34108 if (!args) SWIG_fail;
34109 swig_obj[0] = args;
34110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34111 if (!SWIG_IsOK(res1)) {
34112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34113 }
34114 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34115 {
34116 PyThreadState* __tstate = wxPyBeginAllowThreads();
34117 delete arg1;
34118
34119 wxPyEndAllowThreads(__tstate);
34120 if (PyErr_Occurred()) SWIG_fail;
34121 }
34122 resultobj = SWIG_Py_Void();
34123 return resultobj;
34124 fail:
34125 return NULL;
34126 }
34127
34128
34129 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34130 PyObject *resultobj = 0;
34131 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34132 wxDataObject *result = 0 ;
34133 void *argp1 = 0 ;
34134 int res1 = 0 ;
34135 PyObject *swig_obj[1] ;
34136
34137 if (!args) SWIG_fail;
34138 swig_obj[0] = args;
34139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34140 if (!SWIG_IsOK(res1)) {
34141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34142 }
34143 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34144 {
34145 PyThreadState* __tstate = wxPyBeginAllowThreads();
34146 result = (wxDataObject *)(arg1)->GetDataObject();
34147 wxPyEndAllowThreads(__tstate);
34148 if (PyErr_Occurred()) SWIG_fail;
34149 }
34150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34151 return resultobj;
34152 fail:
34153 return NULL;
34154 }
34155
34156
34157 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34158 PyObject *resultobj = 0;
34159 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34160 wxDataObject *arg2 = (wxDataObject *) 0 ;
34161 void *argp1 = 0 ;
34162 int res1 = 0 ;
34163 int res2 = 0 ;
34164 PyObject * obj0 = 0 ;
34165 PyObject * obj1 = 0 ;
34166 char * kwnames[] = {
34167 (char *) "self",(char *) "dataObject", NULL
34168 };
34169
34170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34172 if (!SWIG_IsOK(res1)) {
34173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34174 }
34175 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34176 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34177 if (!SWIG_IsOK(res2)) {
34178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34179 }
34180 {
34181 PyThreadState* __tstate = wxPyBeginAllowThreads();
34182 (arg1)->SetDataObject(arg2);
34183 wxPyEndAllowThreads(__tstate);
34184 if (PyErr_Occurred()) SWIG_fail;
34185 }
34186 resultobj = SWIG_Py_Void();
34187 return resultobj;
34188 fail:
34189 return NULL;
34190 }
34191
34192
34193 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34194 PyObject *resultobj = 0;
34195 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34196 int arg2 ;
34197 int arg3 ;
34198 wxDragResult arg4 ;
34199 wxDragResult result;
34200 void *argp1 = 0 ;
34201 int res1 = 0 ;
34202 int val2 ;
34203 int ecode2 = 0 ;
34204 int val3 ;
34205 int ecode3 = 0 ;
34206 int val4 ;
34207 int ecode4 = 0 ;
34208 PyObject * obj0 = 0 ;
34209 PyObject * obj1 = 0 ;
34210 PyObject * obj2 = 0 ;
34211 PyObject * obj3 = 0 ;
34212 char * kwnames[] = {
34213 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34214 };
34215
34216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34218 if (!SWIG_IsOK(res1)) {
34219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34220 }
34221 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34222 ecode2 = SWIG_AsVal_int(obj1, &val2);
34223 if (!SWIG_IsOK(ecode2)) {
34224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34225 }
34226 arg2 = static_cast< int >(val2);
34227 ecode3 = SWIG_AsVal_int(obj2, &val3);
34228 if (!SWIG_IsOK(ecode3)) {
34229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34230 }
34231 arg3 = static_cast< int >(val3);
34232 ecode4 = SWIG_AsVal_int(obj3, &val4);
34233 if (!SWIG_IsOK(ecode4)) {
34234 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34235 }
34236 arg4 = static_cast< wxDragResult >(val4);
34237 {
34238 PyThreadState* __tstate = wxPyBeginAllowThreads();
34239 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34240 wxPyEndAllowThreads(__tstate);
34241 if (PyErr_Occurred()) SWIG_fail;
34242 }
34243 resultobj = SWIG_From_int(static_cast< int >(result));
34244 return resultobj;
34245 fail:
34246 return NULL;
34247 }
34248
34249
34250 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34251 PyObject *resultobj = 0;
34252 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34253 int arg2 ;
34254 int arg3 ;
34255 wxDragResult arg4 ;
34256 wxDragResult result;
34257 void *argp1 = 0 ;
34258 int res1 = 0 ;
34259 int val2 ;
34260 int ecode2 = 0 ;
34261 int val3 ;
34262 int ecode3 = 0 ;
34263 int val4 ;
34264 int ecode4 = 0 ;
34265 PyObject * obj0 = 0 ;
34266 PyObject * obj1 = 0 ;
34267 PyObject * obj2 = 0 ;
34268 PyObject * obj3 = 0 ;
34269 char * kwnames[] = {
34270 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34271 };
34272
34273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34275 if (!SWIG_IsOK(res1)) {
34276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34277 }
34278 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34279 ecode2 = SWIG_AsVal_int(obj1, &val2);
34280 if (!SWIG_IsOK(ecode2)) {
34281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34282 }
34283 arg2 = static_cast< int >(val2);
34284 ecode3 = SWIG_AsVal_int(obj2, &val3);
34285 if (!SWIG_IsOK(ecode3)) {
34286 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34287 }
34288 arg3 = static_cast< int >(val3);
34289 ecode4 = SWIG_AsVal_int(obj3, &val4);
34290 if (!SWIG_IsOK(ecode4)) {
34291 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34292 }
34293 arg4 = static_cast< wxDragResult >(val4);
34294 {
34295 PyThreadState* __tstate = wxPyBeginAllowThreads();
34296 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34297 wxPyEndAllowThreads(__tstate);
34298 if (PyErr_Occurred()) SWIG_fail;
34299 }
34300 resultobj = SWIG_From_int(static_cast< int >(result));
34301 return resultobj;
34302 fail:
34303 return NULL;
34304 }
34305
34306
34307 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34308 PyObject *resultobj = 0;
34309 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34310 void *argp1 = 0 ;
34311 int res1 = 0 ;
34312 PyObject *swig_obj[1] ;
34313
34314 if (!args) SWIG_fail;
34315 swig_obj[0] = args;
34316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34317 if (!SWIG_IsOK(res1)) {
34318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34319 }
34320 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34321 {
34322 PyThreadState* __tstate = wxPyBeginAllowThreads();
34323 (arg1)->OnLeave();
34324 wxPyEndAllowThreads(__tstate);
34325 if (PyErr_Occurred()) SWIG_fail;
34326 }
34327 resultobj = SWIG_Py_Void();
34328 return resultobj;
34329 fail:
34330 return NULL;
34331 }
34332
34333
34334 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34335 PyObject *resultobj = 0;
34336 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34337 int arg2 ;
34338 int arg3 ;
34339 bool result;
34340 void *argp1 = 0 ;
34341 int res1 = 0 ;
34342 int val2 ;
34343 int ecode2 = 0 ;
34344 int val3 ;
34345 int ecode3 = 0 ;
34346 PyObject * obj0 = 0 ;
34347 PyObject * obj1 = 0 ;
34348 PyObject * obj2 = 0 ;
34349 char * kwnames[] = {
34350 (char *) "self",(char *) "x",(char *) "y", NULL
34351 };
34352
34353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34355 if (!SWIG_IsOK(res1)) {
34356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34357 }
34358 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34359 ecode2 = SWIG_AsVal_int(obj1, &val2);
34360 if (!SWIG_IsOK(ecode2)) {
34361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34362 }
34363 arg2 = static_cast< int >(val2);
34364 ecode3 = SWIG_AsVal_int(obj2, &val3);
34365 if (!SWIG_IsOK(ecode3)) {
34366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34367 }
34368 arg3 = static_cast< int >(val3);
34369 {
34370 PyThreadState* __tstate = wxPyBeginAllowThreads();
34371 result = (bool)(arg1)->OnDrop(arg2,arg3);
34372 wxPyEndAllowThreads(__tstate);
34373 if (PyErr_Occurred()) SWIG_fail;
34374 }
34375 {
34376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34377 }
34378 return resultobj;
34379 fail:
34380 return NULL;
34381 }
34382
34383
34384 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34385 PyObject *resultobj = 0;
34386 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34387 bool result;
34388 void *argp1 = 0 ;
34389 int res1 = 0 ;
34390 PyObject *swig_obj[1] ;
34391
34392 if (!args) SWIG_fail;
34393 swig_obj[0] = args;
34394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34395 if (!SWIG_IsOK(res1)) {
34396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34397 }
34398 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34399 {
34400 PyThreadState* __tstate = wxPyBeginAllowThreads();
34401 result = (bool)(arg1)->GetData();
34402 wxPyEndAllowThreads(__tstate);
34403 if (PyErr_Occurred()) SWIG_fail;
34404 }
34405 {
34406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34407 }
34408 return resultobj;
34409 fail:
34410 return NULL;
34411 }
34412
34413
34414 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34415 PyObject *resultobj = 0;
34416 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34417 wxDragResult arg2 ;
34418 void *argp1 = 0 ;
34419 int res1 = 0 ;
34420 int val2 ;
34421 int ecode2 = 0 ;
34422 PyObject * obj0 = 0 ;
34423 PyObject * obj1 = 0 ;
34424 char * kwnames[] = {
34425 (char *) "self",(char *) "action", NULL
34426 };
34427
34428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34430 if (!SWIG_IsOK(res1)) {
34431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34432 }
34433 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34434 ecode2 = SWIG_AsVal_int(obj1, &val2);
34435 if (!SWIG_IsOK(ecode2)) {
34436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34437 }
34438 arg2 = static_cast< wxDragResult >(val2);
34439 {
34440 PyThreadState* __tstate = wxPyBeginAllowThreads();
34441 (arg1)->SetDefaultAction(arg2);
34442 wxPyEndAllowThreads(__tstate);
34443 if (PyErr_Occurred()) SWIG_fail;
34444 }
34445 resultobj = SWIG_Py_Void();
34446 return resultobj;
34447 fail:
34448 return NULL;
34449 }
34450
34451
34452 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34453 PyObject *resultobj = 0;
34454 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34455 wxDragResult result;
34456 void *argp1 = 0 ;
34457 int res1 = 0 ;
34458 PyObject *swig_obj[1] ;
34459
34460 if (!args) SWIG_fail;
34461 swig_obj[0] = args;
34462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34463 if (!SWIG_IsOK(res1)) {
34464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34465 }
34466 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34467 {
34468 PyThreadState* __tstate = wxPyBeginAllowThreads();
34469 result = (wxDragResult)(arg1)->GetDefaultAction();
34470 wxPyEndAllowThreads(__tstate);
34471 if (PyErr_Occurred()) SWIG_fail;
34472 }
34473 resultobj = SWIG_From_int(static_cast< int >(result));
34474 return resultobj;
34475 fail:
34476 return NULL;
34477 }
34478
34479
34480 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34481 PyObject *obj;
34482 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34483 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34484 return SWIG_Py_Void();
34485 }
34486
34487 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34488 return SWIG_Python_InitShadowInstance(args);
34489 }
34490
34491 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34492 PyObject *resultobj = 0;
34493 wxPyTextDropTarget *result = 0 ;
34494
34495 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34496 {
34497 PyThreadState* __tstate = wxPyBeginAllowThreads();
34498 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34499 wxPyEndAllowThreads(__tstate);
34500 if (PyErr_Occurred()) SWIG_fail;
34501 }
34502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34503 return resultobj;
34504 fail:
34505 return NULL;
34506 }
34507
34508
34509 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34510 PyObject *resultobj = 0;
34511 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34512 PyObject *arg2 = (PyObject *) 0 ;
34513 PyObject *arg3 = (PyObject *) 0 ;
34514 void *argp1 = 0 ;
34515 int res1 = 0 ;
34516 PyObject * obj0 = 0 ;
34517 PyObject * obj1 = 0 ;
34518 PyObject * obj2 = 0 ;
34519 char * kwnames[] = {
34520 (char *) "self",(char *) "self",(char *) "_class", NULL
34521 };
34522
34523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34525 if (!SWIG_IsOK(res1)) {
34526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34527 }
34528 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34529 arg2 = obj1;
34530 arg3 = obj2;
34531 {
34532 PyThreadState* __tstate = wxPyBeginAllowThreads();
34533 (arg1)->_setCallbackInfo(arg2,arg3);
34534 wxPyEndAllowThreads(__tstate);
34535 if (PyErr_Occurred()) SWIG_fail;
34536 }
34537 resultobj = SWIG_Py_Void();
34538 return resultobj;
34539 fail:
34540 return NULL;
34541 }
34542
34543
34544 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34545 PyObject *resultobj = 0;
34546 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34547 int arg2 ;
34548 int arg3 ;
34549 wxString *arg4 = 0 ;
34550 bool result;
34551 void *argp1 = 0 ;
34552 int res1 = 0 ;
34553 int val2 ;
34554 int ecode2 = 0 ;
34555 int val3 ;
34556 int ecode3 = 0 ;
34557 bool temp4 = false ;
34558 PyObject * obj0 = 0 ;
34559 PyObject * obj1 = 0 ;
34560 PyObject * obj2 = 0 ;
34561 PyObject * obj3 = 0 ;
34562 char * kwnames[] = {
34563 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34564 };
34565
34566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34568 if (!SWIG_IsOK(res1)) {
34569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34570 }
34571 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34572 ecode2 = SWIG_AsVal_int(obj1, &val2);
34573 if (!SWIG_IsOK(ecode2)) {
34574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34575 }
34576 arg2 = static_cast< int >(val2);
34577 ecode3 = SWIG_AsVal_int(obj2, &val3);
34578 if (!SWIG_IsOK(ecode3)) {
34579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34580 }
34581 arg3 = static_cast< int >(val3);
34582 {
34583 arg4 = wxString_in_helper(obj3);
34584 if (arg4 == NULL) SWIG_fail;
34585 temp4 = true;
34586 }
34587 {
34588 PyThreadState* __tstate = wxPyBeginAllowThreads();
34589 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34590 wxPyEndAllowThreads(__tstate);
34591 if (PyErr_Occurred()) SWIG_fail;
34592 }
34593 {
34594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34595 }
34596 {
34597 if (temp4)
34598 delete arg4;
34599 }
34600 return resultobj;
34601 fail:
34602 {
34603 if (temp4)
34604 delete arg4;
34605 }
34606 return NULL;
34607 }
34608
34609
34610 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34611 PyObject *resultobj = 0;
34612 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34613 int arg2 ;
34614 int arg3 ;
34615 wxDragResult arg4 ;
34616 wxDragResult result;
34617 void *argp1 = 0 ;
34618 int res1 = 0 ;
34619 int val2 ;
34620 int ecode2 = 0 ;
34621 int val3 ;
34622 int ecode3 = 0 ;
34623 int val4 ;
34624 int ecode4 = 0 ;
34625 PyObject * obj0 = 0 ;
34626 PyObject * obj1 = 0 ;
34627 PyObject * obj2 = 0 ;
34628 PyObject * obj3 = 0 ;
34629 char * kwnames[] = {
34630 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34631 };
34632
34633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34635 if (!SWIG_IsOK(res1)) {
34636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34637 }
34638 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34639 ecode2 = SWIG_AsVal_int(obj1, &val2);
34640 if (!SWIG_IsOK(ecode2)) {
34641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34642 }
34643 arg2 = static_cast< int >(val2);
34644 ecode3 = SWIG_AsVal_int(obj2, &val3);
34645 if (!SWIG_IsOK(ecode3)) {
34646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34647 }
34648 arg3 = static_cast< int >(val3);
34649 ecode4 = SWIG_AsVal_int(obj3, &val4);
34650 if (!SWIG_IsOK(ecode4)) {
34651 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34652 }
34653 arg4 = static_cast< wxDragResult >(val4);
34654 {
34655 PyThreadState* __tstate = wxPyBeginAllowThreads();
34656 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34657 wxPyEndAllowThreads(__tstate);
34658 if (PyErr_Occurred()) SWIG_fail;
34659 }
34660 resultobj = SWIG_From_int(static_cast< int >(result));
34661 return resultobj;
34662 fail:
34663 return NULL;
34664 }
34665
34666
34667 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34668 PyObject *resultobj = 0;
34669 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34670 int arg2 ;
34671 int arg3 ;
34672 wxDragResult arg4 ;
34673 wxDragResult result;
34674 void *argp1 = 0 ;
34675 int res1 = 0 ;
34676 int val2 ;
34677 int ecode2 = 0 ;
34678 int val3 ;
34679 int ecode3 = 0 ;
34680 int val4 ;
34681 int ecode4 = 0 ;
34682 PyObject * obj0 = 0 ;
34683 PyObject * obj1 = 0 ;
34684 PyObject * obj2 = 0 ;
34685 PyObject * obj3 = 0 ;
34686 char * kwnames[] = {
34687 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34688 };
34689
34690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34692 if (!SWIG_IsOK(res1)) {
34693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34694 }
34695 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34696 ecode2 = SWIG_AsVal_int(obj1, &val2);
34697 if (!SWIG_IsOK(ecode2)) {
34698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34699 }
34700 arg2 = static_cast< int >(val2);
34701 ecode3 = SWIG_AsVal_int(obj2, &val3);
34702 if (!SWIG_IsOK(ecode3)) {
34703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34704 }
34705 arg3 = static_cast< int >(val3);
34706 ecode4 = SWIG_AsVal_int(obj3, &val4);
34707 if (!SWIG_IsOK(ecode4)) {
34708 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34709 }
34710 arg4 = static_cast< wxDragResult >(val4);
34711 {
34712 PyThreadState* __tstate = wxPyBeginAllowThreads();
34713 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34714 wxPyEndAllowThreads(__tstate);
34715 if (PyErr_Occurred()) SWIG_fail;
34716 }
34717 resultobj = SWIG_From_int(static_cast< int >(result));
34718 return resultobj;
34719 fail:
34720 return NULL;
34721 }
34722
34723
34724 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34725 PyObject *resultobj = 0;
34726 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34727 void *argp1 = 0 ;
34728 int res1 = 0 ;
34729 PyObject *swig_obj[1] ;
34730
34731 if (!args) SWIG_fail;
34732 swig_obj[0] = args;
34733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34734 if (!SWIG_IsOK(res1)) {
34735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34736 }
34737 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34738 {
34739 PyThreadState* __tstate = wxPyBeginAllowThreads();
34740 (arg1)->OnLeave();
34741 wxPyEndAllowThreads(__tstate);
34742 if (PyErr_Occurred()) SWIG_fail;
34743 }
34744 resultobj = SWIG_Py_Void();
34745 return resultobj;
34746 fail:
34747 return NULL;
34748 }
34749
34750
34751 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34752 PyObject *resultobj = 0;
34753 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34754 int arg2 ;
34755 int arg3 ;
34756 bool result;
34757 void *argp1 = 0 ;
34758 int res1 = 0 ;
34759 int val2 ;
34760 int ecode2 = 0 ;
34761 int val3 ;
34762 int ecode3 = 0 ;
34763 PyObject * obj0 = 0 ;
34764 PyObject * obj1 = 0 ;
34765 PyObject * obj2 = 0 ;
34766 char * kwnames[] = {
34767 (char *) "self",(char *) "x",(char *) "y", NULL
34768 };
34769
34770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34772 if (!SWIG_IsOK(res1)) {
34773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34774 }
34775 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34776 ecode2 = SWIG_AsVal_int(obj1, &val2);
34777 if (!SWIG_IsOK(ecode2)) {
34778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34779 }
34780 arg2 = static_cast< int >(val2);
34781 ecode3 = SWIG_AsVal_int(obj2, &val3);
34782 if (!SWIG_IsOK(ecode3)) {
34783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34784 }
34785 arg3 = static_cast< int >(val3);
34786 {
34787 PyThreadState* __tstate = wxPyBeginAllowThreads();
34788 result = (bool)(arg1)->OnDrop(arg2,arg3);
34789 wxPyEndAllowThreads(__tstate);
34790 if (PyErr_Occurred()) SWIG_fail;
34791 }
34792 {
34793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34794 }
34795 return resultobj;
34796 fail:
34797 return NULL;
34798 }
34799
34800
34801 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34802 PyObject *resultobj = 0;
34803 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34804 int arg2 ;
34805 int arg3 ;
34806 wxDragResult arg4 ;
34807 wxDragResult result;
34808 void *argp1 = 0 ;
34809 int res1 = 0 ;
34810 int val2 ;
34811 int ecode2 = 0 ;
34812 int val3 ;
34813 int ecode3 = 0 ;
34814 int val4 ;
34815 int ecode4 = 0 ;
34816 PyObject * obj0 = 0 ;
34817 PyObject * obj1 = 0 ;
34818 PyObject * obj2 = 0 ;
34819 PyObject * obj3 = 0 ;
34820 char * kwnames[] = {
34821 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34822 };
34823
34824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34826 if (!SWIG_IsOK(res1)) {
34827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34828 }
34829 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34830 ecode2 = SWIG_AsVal_int(obj1, &val2);
34831 if (!SWIG_IsOK(ecode2)) {
34832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34833 }
34834 arg2 = static_cast< int >(val2);
34835 ecode3 = SWIG_AsVal_int(obj2, &val3);
34836 if (!SWIG_IsOK(ecode3)) {
34837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34838 }
34839 arg3 = static_cast< int >(val3);
34840 ecode4 = SWIG_AsVal_int(obj3, &val4);
34841 if (!SWIG_IsOK(ecode4)) {
34842 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34843 }
34844 arg4 = static_cast< wxDragResult >(val4);
34845 {
34846 PyThreadState* __tstate = wxPyBeginAllowThreads();
34847 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34848 wxPyEndAllowThreads(__tstate);
34849 if (PyErr_Occurred()) SWIG_fail;
34850 }
34851 resultobj = SWIG_From_int(static_cast< int >(result));
34852 return resultobj;
34853 fail:
34854 return NULL;
34855 }
34856
34857
34858 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34859 PyObject *obj;
34860 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34861 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34862 return SWIG_Py_Void();
34863 }
34864
34865 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34866 return SWIG_Python_InitShadowInstance(args);
34867 }
34868
34869 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34870 PyObject *resultobj = 0;
34871 wxPyFileDropTarget *result = 0 ;
34872
34873 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34874 {
34875 PyThreadState* __tstate = wxPyBeginAllowThreads();
34876 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34877 wxPyEndAllowThreads(__tstate);
34878 if (PyErr_Occurred()) SWIG_fail;
34879 }
34880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34881 return resultobj;
34882 fail:
34883 return NULL;
34884 }
34885
34886
34887 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34888 PyObject *resultobj = 0;
34889 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34890 PyObject *arg2 = (PyObject *) 0 ;
34891 PyObject *arg3 = (PyObject *) 0 ;
34892 void *argp1 = 0 ;
34893 int res1 = 0 ;
34894 PyObject * obj0 = 0 ;
34895 PyObject * obj1 = 0 ;
34896 PyObject * obj2 = 0 ;
34897 char * kwnames[] = {
34898 (char *) "self",(char *) "self",(char *) "_class", NULL
34899 };
34900
34901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34903 if (!SWIG_IsOK(res1)) {
34904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34905 }
34906 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34907 arg2 = obj1;
34908 arg3 = obj2;
34909 {
34910 PyThreadState* __tstate = wxPyBeginAllowThreads();
34911 (arg1)->_setCallbackInfo(arg2,arg3);
34912 wxPyEndAllowThreads(__tstate);
34913 if (PyErr_Occurred()) SWIG_fail;
34914 }
34915 resultobj = SWIG_Py_Void();
34916 return resultobj;
34917 fail:
34918 return NULL;
34919 }
34920
34921
34922 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34923 PyObject *resultobj = 0;
34924 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34925 int arg2 ;
34926 int arg3 ;
34927 wxArrayString *arg4 = 0 ;
34928 bool result;
34929 void *argp1 = 0 ;
34930 int res1 = 0 ;
34931 int val2 ;
34932 int ecode2 = 0 ;
34933 int val3 ;
34934 int ecode3 = 0 ;
34935 bool temp4 = false ;
34936 PyObject * obj0 = 0 ;
34937 PyObject * obj1 = 0 ;
34938 PyObject * obj2 = 0 ;
34939 PyObject * obj3 = 0 ;
34940 char * kwnames[] = {
34941 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
34942 };
34943
34944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34946 if (!SWIG_IsOK(res1)) {
34947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34948 }
34949 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34950 ecode2 = SWIG_AsVal_int(obj1, &val2);
34951 if (!SWIG_IsOK(ecode2)) {
34952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
34953 }
34954 arg2 = static_cast< int >(val2);
34955 ecode3 = SWIG_AsVal_int(obj2, &val3);
34956 if (!SWIG_IsOK(ecode3)) {
34957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
34958 }
34959 arg3 = static_cast< int >(val3);
34960 {
34961 if (! PySequence_Check(obj3)) {
34962 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
34963 SWIG_fail;
34964 }
34965 arg4 = new wxArrayString;
34966 temp4 = true;
34967 int i, len=PySequence_Length(obj3);
34968 for (i=0; i<len; i++) {
34969 PyObject* item = PySequence_GetItem(obj3, i);
34970 wxString* s = wxString_in_helper(item);
34971 if (PyErr_Occurred()) SWIG_fail;
34972 arg4->Add(*s);
34973 delete s;
34974 Py_DECREF(item);
34975 }
34976 }
34977 {
34978 PyThreadState* __tstate = wxPyBeginAllowThreads();
34979 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
34980 wxPyEndAllowThreads(__tstate);
34981 if (PyErr_Occurred()) SWIG_fail;
34982 }
34983 {
34984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34985 }
34986 {
34987 if (temp4) delete arg4;
34988 }
34989 return resultobj;
34990 fail:
34991 {
34992 if (temp4) delete arg4;
34993 }
34994 return NULL;
34995 }
34996
34997
34998 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34999 PyObject *resultobj = 0;
35000 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35001 int arg2 ;
35002 int arg3 ;
35003 wxDragResult arg4 ;
35004 wxDragResult result;
35005 void *argp1 = 0 ;
35006 int res1 = 0 ;
35007 int val2 ;
35008 int ecode2 = 0 ;
35009 int val3 ;
35010 int ecode3 = 0 ;
35011 int val4 ;
35012 int ecode4 = 0 ;
35013 PyObject * obj0 = 0 ;
35014 PyObject * obj1 = 0 ;
35015 PyObject * obj2 = 0 ;
35016 PyObject * obj3 = 0 ;
35017 char * kwnames[] = {
35018 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35019 };
35020
35021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35023 if (!SWIG_IsOK(res1)) {
35024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35025 }
35026 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35027 ecode2 = SWIG_AsVal_int(obj1, &val2);
35028 if (!SWIG_IsOK(ecode2)) {
35029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35030 }
35031 arg2 = static_cast< int >(val2);
35032 ecode3 = SWIG_AsVal_int(obj2, &val3);
35033 if (!SWIG_IsOK(ecode3)) {
35034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35035 }
35036 arg3 = static_cast< int >(val3);
35037 ecode4 = SWIG_AsVal_int(obj3, &val4);
35038 if (!SWIG_IsOK(ecode4)) {
35039 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35040 }
35041 arg4 = static_cast< wxDragResult >(val4);
35042 {
35043 PyThreadState* __tstate = wxPyBeginAllowThreads();
35044 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35045 wxPyEndAllowThreads(__tstate);
35046 if (PyErr_Occurred()) SWIG_fail;
35047 }
35048 resultobj = SWIG_From_int(static_cast< int >(result));
35049 return resultobj;
35050 fail:
35051 return NULL;
35052 }
35053
35054
35055 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35056 PyObject *resultobj = 0;
35057 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35058 int arg2 ;
35059 int arg3 ;
35060 wxDragResult arg4 ;
35061 wxDragResult result;
35062 void *argp1 = 0 ;
35063 int res1 = 0 ;
35064 int val2 ;
35065 int ecode2 = 0 ;
35066 int val3 ;
35067 int ecode3 = 0 ;
35068 int val4 ;
35069 int ecode4 = 0 ;
35070 PyObject * obj0 = 0 ;
35071 PyObject * obj1 = 0 ;
35072 PyObject * obj2 = 0 ;
35073 PyObject * obj3 = 0 ;
35074 char * kwnames[] = {
35075 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35076 };
35077
35078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35080 if (!SWIG_IsOK(res1)) {
35081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35082 }
35083 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35084 ecode2 = SWIG_AsVal_int(obj1, &val2);
35085 if (!SWIG_IsOK(ecode2)) {
35086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35087 }
35088 arg2 = static_cast< int >(val2);
35089 ecode3 = SWIG_AsVal_int(obj2, &val3);
35090 if (!SWIG_IsOK(ecode3)) {
35091 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35092 }
35093 arg3 = static_cast< int >(val3);
35094 ecode4 = SWIG_AsVal_int(obj3, &val4);
35095 if (!SWIG_IsOK(ecode4)) {
35096 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35097 }
35098 arg4 = static_cast< wxDragResult >(val4);
35099 {
35100 PyThreadState* __tstate = wxPyBeginAllowThreads();
35101 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35102 wxPyEndAllowThreads(__tstate);
35103 if (PyErr_Occurred()) SWIG_fail;
35104 }
35105 resultobj = SWIG_From_int(static_cast< int >(result));
35106 return resultobj;
35107 fail:
35108 return NULL;
35109 }
35110
35111
35112 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35113 PyObject *resultobj = 0;
35114 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35115 void *argp1 = 0 ;
35116 int res1 = 0 ;
35117 PyObject *swig_obj[1] ;
35118
35119 if (!args) SWIG_fail;
35120 swig_obj[0] = args;
35121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35122 if (!SWIG_IsOK(res1)) {
35123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35124 }
35125 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35126 {
35127 PyThreadState* __tstate = wxPyBeginAllowThreads();
35128 (arg1)->OnLeave();
35129 wxPyEndAllowThreads(__tstate);
35130 if (PyErr_Occurred()) SWIG_fail;
35131 }
35132 resultobj = SWIG_Py_Void();
35133 return resultobj;
35134 fail:
35135 return NULL;
35136 }
35137
35138
35139 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35140 PyObject *resultobj = 0;
35141 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35142 int arg2 ;
35143 int arg3 ;
35144 bool result;
35145 void *argp1 = 0 ;
35146 int res1 = 0 ;
35147 int val2 ;
35148 int ecode2 = 0 ;
35149 int val3 ;
35150 int ecode3 = 0 ;
35151 PyObject * obj0 = 0 ;
35152 PyObject * obj1 = 0 ;
35153 PyObject * obj2 = 0 ;
35154 char * kwnames[] = {
35155 (char *) "self",(char *) "x",(char *) "y", NULL
35156 };
35157
35158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35160 if (!SWIG_IsOK(res1)) {
35161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35162 }
35163 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35164 ecode2 = SWIG_AsVal_int(obj1, &val2);
35165 if (!SWIG_IsOK(ecode2)) {
35166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35167 }
35168 arg2 = static_cast< int >(val2);
35169 ecode3 = SWIG_AsVal_int(obj2, &val3);
35170 if (!SWIG_IsOK(ecode3)) {
35171 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35172 }
35173 arg3 = static_cast< int >(val3);
35174 {
35175 PyThreadState* __tstate = wxPyBeginAllowThreads();
35176 result = (bool)(arg1)->OnDrop(arg2,arg3);
35177 wxPyEndAllowThreads(__tstate);
35178 if (PyErr_Occurred()) SWIG_fail;
35179 }
35180 {
35181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35182 }
35183 return resultobj;
35184 fail:
35185 return NULL;
35186 }
35187
35188
35189 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35190 PyObject *resultobj = 0;
35191 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35192 int arg2 ;
35193 int arg3 ;
35194 wxDragResult arg4 ;
35195 wxDragResult result;
35196 void *argp1 = 0 ;
35197 int res1 = 0 ;
35198 int val2 ;
35199 int ecode2 = 0 ;
35200 int val3 ;
35201 int ecode3 = 0 ;
35202 int val4 ;
35203 int ecode4 = 0 ;
35204 PyObject * obj0 = 0 ;
35205 PyObject * obj1 = 0 ;
35206 PyObject * obj2 = 0 ;
35207 PyObject * obj3 = 0 ;
35208 char * kwnames[] = {
35209 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35210 };
35211
35212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35214 if (!SWIG_IsOK(res1)) {
35215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35216 }
35217 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35218 ecode2 = SWIG_AsVal_int(obj1, &val2);
35219 if (!SWIG_IsOK(ecode2)) {
35220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35221 }
35222 arg2 = static_cast< int >(val2);
35223 ecode3 = SWIG_AsVal_int(obj2, &val3);
35224 if (!SWIG_IsOK(ecode3)) {
35225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35226 }
35227 arg3 = static_cast< int >(val3);
35228 ecode4 = SWIG_AsVal_int(obj3, &val4);
35229 if (!SWIG_IsOK(ecode4)) {
35230 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35231 }
35232 arg4 = static_cast< wxDragResult >(val4);
35233 {
35234 PyThreadState* __tstate = wxPyBeginAllowThreads();
35235 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35236 wxPyEndAllowThreads(__tstate);
35237 if (PyErr_Occurred()) SWIG_fail;
35238 }
35239 resultobj = SWIG_From_int(static_cast< int >(result));
35240 return resultobj;
35241 fail:
35242 return NULL;
35243 }
35244
35245
35246 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35247 PyObject *obj;
35248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35249 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35250 return SWIG_Py_Void();
35251 }
35252
35253 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35254 return SWIG_Python_InitShadowInstance(args);
35255 }
35256
35257 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35258 PyObject *resultobj = 0;
35259 wxClipboard *result = 0 ;
35260
35261 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35262 {
35263 PyThreadState* __tstate = wxPyBeginAllowThreads();
35264 result = (wxClipboard *)new wxClipboard();
35265 wxPyEndAllowThreads(__tstate);
35266 if (PyErr_Occurred()) SWIG_fail;
35267 }
35268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35269 return resultobj;
35270 fail:
35271 return NULL;
35272 }
35273
35274
35275 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35276 PyObject *resultobj = 0;
35277 wxClipboard *arg1 = (wxClipboard *) 0 ;
35278 void *argp1 = 0 ;
35279 int res1 = 0 ;
35280 PyObject *swig_obj[1] ;
35281
35282 if (!args) SWIG_fail;
35283 swig_obj[0] = args;
35284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35285 if (!SWIG_IsOK(res1)) {
35286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35287 }
35288 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35289 {
35290 PyThreadState* __tstate = wxPyBeginAllowThreads();
35291 delete arg1;
35292
35293 wxPyEndAllowThreads(__tstate);
35294 if (PyErr_Occurred()) SWIG_fail;
35295 }
35296 resultobj = SWIG_Py_Void();
35297 return resultobj;
35298 fail:
35299 return NULL;
35300 }
35301
35302
35303 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35304 PyObject *resultobj = 0;
35305 wxClipboard *arg1 = (wxClipboard *) 0 ;
35306 bool result;
35307 void *argp1 = 0 ;
35308 int res1 = 0 ;
35309 PyObject *swig_obj[1] ;
35310
35311 if (!args) SWIG_fail;
35312 swig_obj[0] = args;
35313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35314 if (!SWIG_IsOK(res1)) {
35315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35316 }
35317 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35318 {
35319 PyThreadState* __tstate = wxPyBeginAllowThreads();
35320 result = (bool)(arg1)->Open();
35321 wxPyEndAllowThreads(__tstate);
35322 if (PyErr_Occurred()) SWIG_fail;
35323 }
35324 {
35325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35326 }
35327 return resultobj;
35328 fail:
35329 return NULL;
35330 }
35331
35332
35333 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35334 PyObject *resultobj = 0;
35335 wxClipboard *arg1 = (wxClipboard *) 0 ;
35336 void *argp1 = 0 ;
35337 int res1 = 0 ;
35338 PyObject *swig_obj[1] ;
35339
35340 if (!args) SWIG_fail;
35341 swig_obj[0] = args;
35342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35343 if (!SWIG_IsOK(res1)) {
35344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35345 }
35346 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35347 {
35348 PyThreadState* __tstate = wxPyBeginAllowThreads();
35349 (arg1)->Close();
35350 wxPyEndAllowThreads(__tstate);
35351 if (PyErr_Occurred()) SWIG_fail;
35352 }
35353 resultobj = SWIG_Py_Void();
35354 return resultobj;
35355 fail:
35356 return NULL;
35357 }
35358
35359
35360 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35361 PyObject *resultobj = 0;
35362 wxClipboard *arg1 = (wxClipboard *) 0 ;
35363 bool result;
35364 void *argp1 = 0 ;
35365 int res1 = 0 ;
35366 PyObject *swig_obj[1] ;
35367
35368 if (!args) SWIG_fail;
35369 swig_obj[0] = args;
35370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35371 if (!SWIG_IsOK(res1)) {
35372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35373 }
35374 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35375 {
35376 PyThreadState* __tstate = wxPyBeginAllowThreads();
35377 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35378 wxPyEndAllowThreads(__tstate);
35379 if (PyErr_Occurred()) SWIG_fail;
35380 }
35381 {
35382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35383 }
35384 return resultobj;
35385 fail:
35386 return NULL;
35387 }
35388
35389
35390 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35391 PyObject *resultobj = 0;
35392 wxClipboard *arg1 = (wxClipboard *) 0 ;
35393 wxDataObject *arg2 = (wxDataObject *) 0 ;
35394 bool result;
35395 void *argp1 = 0 ;
35396 int res1 = 0 ;
35397 int res2 = 0 ;
35398 PyObject * obj0 = 0 ;
35399 PyObject * obj1 = 0 ;
35400 char * kwnames[] = {
35401 (char *) "self",(char *) "data", NULL
35402 };
35403
35404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35406 if (!SWIG_IsOK(res1)) {
35407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35408 }
35409 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35410 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35411 if (!SWIG_IsOK(res2)) {
35412 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35413 }
35414 {
35415 PyThreadState* __tstate = wxPyBeginAllowThreads();
35416 result = (bool)(arg1)->AddData(arg2);
35417 wxPyEndAllowThreads(__tstate);
35418 if (PyErr_Occurred()) SWIG_fail;
35419 }
35420 {
35421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35422 }
35423 return resultobj;
35424 fail:
35425 return NULL;
35426 }
35427
35428
35429 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35430 PyObject *resultobj = 0;
35431 wxClipboard *arg1 = (wxClipboard *) 0 ;
35432 wxDataObject *arg2 = (wxDataObject *) 0 ;
35433 bool result;
35434 void *argp1 = 0 ;
35435 int res1 = 0 ;
35436 int res2 = 0 ;
35437 PyObject * obj0 = 0 ;
35438 PyObject * obj1 = 0 ;
35439 char * kwnames[] = {
35440 (char *) "self",(char *) "data", NULL
35441 };
35442
35443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35445 if (!SWIG_IsOK(res1)) {
35446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35447 }
35448 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35449 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35450 if (!SWIG_IsOK(res2)) {
35451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35452 }
35453 {
35454 PyThreadState* __tstate = wxPyBeginAllowThreads();
35455 result = (bool)(arg1)->SetData(arg2);
35456 wxPyEndAllowThreads(__tstate);
35457 if (PyErr_Occurred()) SWIG_fail;
35458 }
35459 {
35460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35461 }
35462 return resultobj;
35463 fail:
35464 return NULL;
35465 }
35466
35467
35468 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35469 PyObject *resultobj = 0;
35470 wxClipboard *arg1 = (wxClipboard *) 0 ;
35471 wxDataFormat *arg2 = 0 ;
35472 bool result;
35473 void *argp1 = 0 ;
35474 int res1 = 0 ;
35475 void *argp2 = 0 ;
35476 int res2 = 0 ;
35477 PyObject * obj0 = 0 ;
35478 PyObject * obj1 = 0 ;
35479 char * kwnames[] = {
35480 (char *) "self",(char *) "format", NULL
35481 };
35482
35483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35485 if (!SWIG_IsOK(res1)) {
35486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35487 }
35488 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35489 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35490 if (!SWIG_IsOK(res2)) {
35491 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35492 }
35493 if (!argp2) {
35494 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35495 }
35496 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35497 {
35498 PyThreadState* __tstate = wxPyBeginAllowThreads();
35499 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35500 wxPyEndAllowThreads(__tstate);
35501 if (PyErr_Occurred()) SWIG_fail;
35502 }
35503 {
35504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35505 }
35506 return resultobj;
35507 fail:
35508 return NULL;
35509 }
35510
35511
35512 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35513 PyObject *resultobj = 0;
35514 wxClipboard *arg1 = (wxClipboard *) 0 ;
35515 wxDataObject *arg2 = 0 ;
35516 bool result;
35517 void *argp1 = 0 ;
35518 int res1 = 0 ;
35519 void *argp2 = 0 ;
35520 int res2 = 0 ;
35521 PyObject * obj0 = 0 ;
35522 PyObject * obj1 = 0 ;
35523 char * kwnames[] = {
35524 (char *) "self",(char *) "data", NULL
35525 };
35526
35527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35529 if (!SWIG_IsOK(res1)) {
35530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35531 }
35532 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35533 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35534 if (!SWIG_IsOK(res2)) {
35535 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35536 }
35537 if (!argp2) {
35538 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35539 }
35540 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35541 {
35542 PyThreadState* __tstate = wxPyBeginAllowThreads();
35543 result = (bool)(arg1)->GetData(*arg2);
35544 wxPyEndAllowThreads(__tstate);
35545 if (PyErr_Occurred()) SWIG_fail;
35546 }
35547 {
35548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35549 }
35550 return resultobj;
35551 fail:
35552 return NULL;
35553 }
35554
35555
35556 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35557 PyObject *resultobj = 0;
35558 wxClipboard *arg1 = (wxClipboard *) 0 ;
35559 void *argp1 = 0 ;
35560 int res1 = 0 ;
35561 PyObject *swig_obj[1] ;
35562
35563 if (!args) SWIG_fail;
35564 swig_obj[0] = args;
35565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35566 if (!SWIG_IsOK(res1)) {
35567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35568 }
35569 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35570 {
35571 PyThreadState* __tstate = wxPyBeginAllowThreads();
35572 (arg1)->Clear();
35573 wxPyEndAllowThreads(__tstate);
35574 if (PyErr_Occurred()) SWIG_fail;
35575 }
35576 resultobj = SWIG_Py_Void();
35577 return resultobj;
35578 fail:
35579 return NULL;
35580 }
35581
35582
35583 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35584 PyObject *resultobj = 0;
35585 wxClipboard *arg1 = (wxClipboard *) 0 ;
35586 bool result;
35587 void *argp1 = 0 ;
35588 int res1 = 0 ;
35589 PyObject *swig_obj[1] ;
35590
35591 if (!args) SWIG_fail;
35592 swig_obj[0] = args;
35593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35594 if (!SWIG_IsOK(res1)) {
35595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35596 }
35597 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35598 {
35599 PyThreadState* __tstate = wxPyBeginAllowThreads();
35600 result = (bool)(arg1)->Flush();
35601 wxPyEndAllowThreads(__tstate);
35602 if (PyErr_Occurred()) SWIG_fail;
35603 }
35604 {
35605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35606 }
35607 return resultobj;
35608 fail:
35609 return NULL;
35610 }
35611
35612
35613 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35614 PyObject *resultobj = 0;
35615 wxClipboard *arg1 = (wxClipboard *) 0 ;
35616 bool arg2 = (bool) true ;
35617 void *argp1 = 0 ;
35618 int res1 = 0 ;
35619 bool val2 ;
35620 int ecode2 = 0 ;
35621 PyObject * obj0 = 0 ;
35622 PyObject * obj1 = 0 ;
35623 char * kwnames[] = {
35624 (char *) "self",(char *) "primary", NULL
35625 };
35626
35627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35629 if (!SWIG_IsOK(res1)) {
35630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35631 }
35632 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35633 if (obj1) {
35634 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35635 if (!SWIG_IsOK(ecode2)) {
35636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35637 }
35638 arg2 = static_cast< bool >(val2);
35639 }
35640 {
35641 PyThreadState* __tstate = wxPyBeginAllowThreads();
35642 (arg1)->UsePrimarySelection(arg2);
35643 wxPyEndAllowThreads(__tstate);
35644 if (PyErr_Occurred()) SWIG_fail;
35645 }
35646 resultobj = SWIG_Py_Void();
35647 return resultobj;
35648 fail:
35649 return NULL;
35650 }
35651
35652
35653 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35654 PyObject *resultobj = 0;
35655 wxClipboard *result = 0 ;
35656
35657 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35658 {
35659 PyThreadState* __tstate = wxPyBeginAllowThreads();
35660 result = (wxClipboard *)wxClipboard::Get();
35661 wxPyEndAllowThreads(__tstate);
35662 if (PyErr_Occurred()) SWIG_fail;
35663 }
35664 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35665 return resultobj;
35666 fail:
35667 return NULL;
35668 }
35669
35670
35671 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35672 PyObject *obj;
35673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35674 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35675 return SWIG_Py_Void();
35676 }
35677
35678 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35679 return SWIG_Python_InitShadowInstance(args);
35680 }
35681
35682 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35683 PyObject *resultobj = 0;
35684 wxClipboard *arg1 = (wxClipboard *) NULL ;
35685 wxClipboardLocker *result = 0 ;
35686 void *argp1 = 0 ;
35687 int res1 = 0 ;
35688 PyObject * obj0 = 0 ;
35689 char * kwnames[] = {
35690 (char *) "clipboard", NULL
35691 };
35692
35693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35694 if (obj0) {
35695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35696 if (!SWIG_IsOK(res1)) {
35697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35698 }
35699 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35700 }
35701 {
35702 PyThreadState* __tstate = wxPyBeginAllowThreads();
35703 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35704 wxPyEndAllowThreads(__tstate);
35705 if (PyErr_Occurred()) SWIG_fail;
35706 }
35707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35708 return resultobj;
35709 fail:
35710 return NULL;
35711 }
35712
35713
35714 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35715 PyObject *resultobj = 0;
35716 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35717 void *argp1 = 0 ;
35718 int res1 = 0 ;
35719 PyObject *swig_obj[1] ;
35720
35721 if (!args) SWIG_fail;
35722 swig_obj[0] = args;
35723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35724 if (!SWIG_IsOK(res1)) {
35725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35726 }
35727 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35728 {
35729 PyThreadState* __tstate = wxPyBeginAllowThreads();
35730 delete arg1;
35731
35732 wxPyEndAllowThreads(__tstate);
35733 if (PyErr_Occurred()) SWIG_fail;
35734 }
35735 resultobj = SWIG_Py_Void();
35736 return resultobj;
35737 fail:
35738 return NULL;
35739 }
35740
35741
35742 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35743 PyObject *resultobj = 0;
35744 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35745 bool result;
35746 void *argp1 = 0 ;
35747 int res1 = 0 ;
35748 PyObject *swig_obj[1] ;
35749
35750 if (!args) SWIG_fail;
35751 swig_obj[0] = args;
35752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35753 if (!SWIG_IsOK(res1)) {
35754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35755 }
35756 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35757 {
35758 PyThreadState* __tstate = wxPyBeginAllowThreads();
35759 result = (bool)wxClipboardLocker___nonzero__(arg1);
35760 wxPyEndAllowThreads(__tstate);
35761 if (PyErr_Occurred()) SWIG_fail;
35762 }
35763 {
35764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35765 }
35766 return resultobj;
35767 fail:
35768 return NULL;
35769 }
35770
35771
35772 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35773 PyObject *obj;
35774 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35775 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35776 return SWIG_Py_Void();
35777 }
35778
35779 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35780 return SWIG_Python_InitShadowInstance(args);
35781 }
35782
35783 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35784 PyObject *resultobj = 0;
35785 int arg1 = (int) 0 ;
35786 int arg2 = (int) 0 ;
35787 int arg3 = (int) 0 ;
35788 int arg4 = (int) 0 ;
35789 wxVideoMode *result = 0 ;
35790 int val1 ;
35791 int ecode1 = 0 ;
35792 int val2 ;
35793 int ecode2 = 0 ;
35794 int val3 ;
35795 int ecode3 = 0 ;
35796 int val4 ;
35797 int ecode4 = 0 ;
35798 PyObject * obj0 = 0 ;
35799 PyObject * obj1 = 0 ;
35800 PyObject * obj2 = 0 ;
35801 PyObject * obj3 = 0 ;
35802 char * kwnames[] = {
35803 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35804 };
35805
35806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35807 if (obj0) {
35808 ecode1 = SWIG_AsVal_int(obj0, &val1);
35809 if (!SWIG_IsOK(ecode1)) {
35810 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35811 }
35812 arg1 = static_cast< int >(val1);
35813 }
35814 if (obj1) {
35815 ecode2 = SWIG_AsVal_int(obj1, &val2);
35816 if (!SWIG_IsOK(ecode2)) {
35817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35818 }
35819 arg2 = static_cast< int >(val2);
35820 }
35821 if (obj2) {
35822 ecode3 = SWIG_AsVal_int(obj2, &val3);
35823 if (!SWIG_IsOK(ecode3)) {
35824 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35825 }
35826 arg3 = static_cast< int >(val3);
35827 }
35828 if (obj3) {
35829 ecode4 = SWIG_AsVal_int(obj3, &val4);
35830 if (!SWIG_IsOK(ecode4)) {
35831 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35832 }
35833 arg4 = static_cast< int >(val4);
35834 }
35835 {
35836 PyThreadState* __tstate = wxPyBeginAllowThreads();
35837 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35838 wxPyEndAllowThreads(__tstate);
35839 if (PyErr_Occurred()) SWIG_fail;
35840 }
35841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35842 return resultobj;
35843 fail:
35844 return NULL;
35845 }
35846
35847
35848 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35849 PyObject *resultobj = 0;
35850 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35851 void *argp1 = 0 ;
35852 int res1 = 0 ;
35853 PyObject *swig_obj[1] ;
35854
35855 if (!args) SWIG_fail;
35856 swig_obj[0] = args;
35857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35858 if (!SWIG_IsOK(res1)) {
35859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35860 }
35861 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35862 {
35863 PyThreadState* __tstate = wxPyBeginAllowThreads();
35864 delete arg1;
35865
35866 wxPyEndAllowThreads(__tstate);
35867 if (PyErr_Occurred()) SWIG_fail;
35868 }
35869 resultobj = SWIG_Py_Void();
35870 return resultobj;
35871 fail:
35872 return NULL;
35873 }
35874
35875
35876 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35877 PyObject *resultobj = 0;
35878 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35879 wxVideoMode *arg2 = 0 ;
35880 bool result;
35881 void *argp1 = 0 ;
35882 int res1 = 0 ;
35883 void *argp2 = 0 ;
35884 int res2 = 0 ;
35885 PyObject * obj0 = 0 ;
35886 PyObject * obj1 = 0 ;
35887 char * kwnames[] = {
35888 (char *) "self",(char *) "other", NULL
35889 };
35890
35891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35893 if (!SWIG_IsOK(res1)) {
35894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35895 }
35896 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35897 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35898 if (!SWIG_IsOK(res2)) {
35899 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35900 }
35901 if (!argp2) {
35902 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35903 }
35904 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35905 {
35906 PyThreadState* __tstate = wxPyBeginAllowThreads();
35907 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35908 wxPyEndAllowThreads(__tstate);
35909 if (PyErr_Occurred()) SWIG_fail;
35910 }
35911 {
35912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35913 }
35914 return resultobj;
35915 fail:
35916 return NULL;
35917 }
35918
35919
35920 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35921 PyObject *resultobj = 0;
35922 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35923 int result;
35924 void *argp1 = 0 ;
35925 int res1 = 0 ;
35926 PyObject *swig_obj[1] ;
35927
35928 if (!args) SWIG_fail;
35929 swig_obj[0] = args;
35930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35931 if (!SWIG_IsOK(res1)) {
35932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35933 }
35934 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35935 {
35936 PyThreadState* __tstate = wxPyBeginAllowThreads();
35937 result = (int)((wxVideoMode const *)arg1)->GetWidth();
35938 wxPyEndAllowThreads(__tstate);
35939 if (PyErr_Occurred()) SWIG_fail;
35940 }
35941 resultobj = SWIG_From_int(static_cast< int >(result));
35942 return resultobj;
35943 fail:
35944 return NULL;
35945 }
35946
35947
35948 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35949 PyObject *resultobj = 0;
35950 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35951 int result;
35952 void *argp1 = 0 ;
35953 int res1 = 0 ;
35954 PyObject *swig_obj[1] ;
35955
35956 if (!args) SWIG_fail;
35957 swig_obj[0] = args;
35958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35959 if (!SWIG_IsOK(res1)) {
35960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35961 }
35962 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35963 {
35964 PyThreadState* __tstate = wxPyBeginAllowThreads();
35965 result = (int)((wxVideoMode const *)arg1)->GetHeight();
35966 wxPyEndAllowThreads(__tstate);
35967 if (PyErr_Occurred()) SWIG_fail;
35968 }
35969 resultobj = SWIG_From_int(static_cast< int >(result));
35970 return resultobj;
35971 fail:
35972 return NULL;
35973 }
35974
35975
35976 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35977 PyObject *resultobj = 0;
35978 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35979 int result;
35980 void *argp1 = 0 ;
35981 int res1 = 0 ;
35982 PyObject *swig_obj[1] ;
35983
35984 if (!args) SWIG_fail;
35985 swig_obj[0] = args;
35986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35987 if (!SWIG_IsOK(res1)) {
35988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35989 }
35990 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35991 {
35992 PyThreadState* __tstate = wxPyBeginAllowThreads();
35993 result = (int)((wxVideoMode const *)arg1)->GetDepth();
35994 wxPyEndAllowThreads(__tstate);
35995 if (PyErr_Occurred()) SWIG_fail;
35996 }
35997 resultobj = SWIG_From_int(static_cast< int >(result));
35998 return resultobj;
35999 fail:
36000 return NULL;
36001 }
36002
36003
36004 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36005 PyObject *resultobj = 0;
36006 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36007 bool result;
36008 void *argp1 = 0 ;
36009 int res1 = 0 ;
36010 PyObject *swig_obj[1] ;
36011
36012 if (!args) SWIG_fail;
36013 swig_obj[0] = args;
36014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36015 if (!SWIG_IsOK(res1)) {
36016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36017 }
36018 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36019 {
36020 PyThreadState* __tstate = wxPyBeginAllowThreads();
36021 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36022 wxPyEndAllowThreads(__tstate);
36023 if (PyErr_Occurred()) SWIG_fail;
36024 }
36025 {
36026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36027 }
36028 return resultobj;
36029 fail:
36030 return NULL;
36031 }
36032
36033
36034 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36035 PyObject *resultobj = 0;
36036 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36037 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36038 bool result;
36039 void *argp1 = 0 ;
36040 int res1 = 0 ;
36041 void *argp2 = 0 ;
36042 int res2 = 0 ;
36043 PyObject * obj0 = 0 ;
36044 PyObject * obj1 = 0 ;
36045 char * kwnames[] = {
36046 (char *) "self",(char *) "other", NULL
36047 };
36048
36049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36051 if (!SWIG_IsOK(res1)) {
36052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36053 }
36054 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36055 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36056 if (!SWIG_IsOK(res2)) {
36057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36058 }
36059 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36060 {
36061 PyThreadState* __tstate = wxPyBeginAllowThreads();
36062 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36063 wxPyEndAllowThreads(__tstate);
36064 if (PyErr_Occurred()) SWIG_fail;
36065 }
36066 {
36067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36068 }
36069 return resultobj;
36070 fail:
36071 return NULL;
36072 }
36073
36074
36075 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36076 PyObject *resultobj = 0;
36077 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36078 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36079 bool result;
36080 void *argp1 = 0 ;
36081 int res1 = 0 ;
36082 void *argp2 = 0 ;
36083 int res2 = 0 ;
36084 PyObject * obj0 = 0 ;
36085 PyObject * obj1 = 0 ;
36086 char * kwnames[] = {
36087 (char *) "self",(char *) "other", NULL
36088 };
36089
36090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36092 if (!SWIG_IsOK(res1)) {
36093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36094 }
36095 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36096 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36097 if (!SWIG_IsOK(res2)) {
36098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36099 }
36100 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36101 {
36102 PyThreadState* __tstate = wxPyBeginAllowThreads();
36103 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36104 wxPyEndAllowThreads(__tstate);
36105 if (PyErr_Occurred()) SWIG_fail;
36106 }
36107 {
36108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36109 }
36110 return resultobj;
36111 fail:
36112 return NULL;
36113 }
36114
36115
36116 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36117 PyObject *resultobj = 0;
36118 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36119 int arg2 ;
36120 void *argp1 = 0 ;
36121 int res1 = 0 ;
36122 int val2 ;
36123 int ecode2 = 0 ;
36124 PyObject *swig_obj[2] ;
36125
36126 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36128 if (!SWIG_IsOK(res1)) {
36129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36130 }
36131 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36132 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36133 if (!SWIG_IsOK(ecode2)) {
36134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36135 }
36136 arg2 = static_cast< int >(val2);
36137 if (arg1) (arg1)->w = arg2;
36138
36139 resultobj = SWIG_Py_Void();
36140 return resultobj;
36141 fail:
36142 return NULL;
36143 }
36144
36145
36146 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36147 PyObject *resultobj = 0;
36148 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36149 int result;
36150 void *argp1 = 0 ;
36151 int res1 = 0 ;
36152 PyObject *swig_obj[1] ;
36153
36154 if (!args) SWIG_fail;
36155 swig_obj[0] = args;
36156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36157 if (!SWIG_IsOK(res1)) {
36158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36159 }
36160 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36161 result = (int) ((arg1)->w);
36162 resultobj = SWIG_From_int(static_cast< int >(result));
36163 return resultobj;
36164 fail:
36165 return NULL;
36166 }
36167
36168
36169 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36170 PyObject *resultobj = 0;
36171 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36172 int arg2 ;
36173 void *argp1 = 0 ;
36174 int res1 = 0 ;
36175 int val2 ;
36176 int ecode2 = 0 ;
36177 PyObject *swig_obj[2] ;
36178
36179 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36181 if (!SWIG_IsOK(res1)) {
36182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36183 }
36184 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36185 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36186 if (!SWIG_IsOK(ecode2)) {
36187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36188 }
36189 arg2 = static_cast< int >(val2);
36190 if (arg1) (arg1)->h = arg2;
36191
36192 resultobj = SWIG_Py_Void();
36193 return resultobj;
36194 fail:
36195 return NULL;
36196 }
36197
36198
36199 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36200 PyObject *resultobj = 0;
36201 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36202 int result;
36203 void *argp1 = 0 ;
36204 int res1 = 0 ;
36205 PyObject *swig_obj[1] ;
36206
36207 if (!args) SWIG_fail;
36208 swig_obj[0] = args;
36209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36210 if (!SWIG_IsOK(res1)) {
36211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36212 }
36213 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36214 result = (int) ((arg1)->h);
36215 resultobj = SWIG_From_int(static_cast< int >(result));
36216 return resultobj;
36217 fail:
36218 return NULL;
36219 }
36220
36221
36222 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36223 PyObject *resultobj = 0;
36224 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36225 int arg2 ;
36226 void *argp1 = 0 ;
36227 int res1 = 0 ;
36228 int val2 ;
36229 int ecode2 = 0 ;
36230 PyObject *swig_obj[2] ;
36231
36232 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36234 if (!SWIG_IsOK(res1)) {
36235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36236 }
36237 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36238 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36239 if (!SWIG_IsOK(ecode2)) {
36240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36241 }
36242 arg2 = static_cast< int >(val2);
36243 if (arg1) (arg1)->bpp = arg2;
36244
36245 resultobj = SWIG_Py_Void();
36246 return resultobj;
36247 fail:
36248 return NULL;
36249 }
36250
36251
36252 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36253 PyObject *resultobj = 0;
36254 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36255 int result;
36256 void *argp1 = 0 ;
36257 int res1 = 0 ;
36258 PyObject *swig_obj[1] ;
36259
36260 if (!args) SWIG_fail;
36261 swig_obj[0] = args;
36262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36263 if (!SWIG_IsOK(res1)) {
36264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36265 }
36266 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36267 result = (int) ((arg1)->bpp);
36268 resultobj = SWIG_From_int(static_cast< int >(result));
36269 return resultobj;
36270 fail:
36271 return NULL;
36272 }
36273
36274
36275 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36276 PyObject *resultobj = 0;
36277 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36278 int arg2 ;
36279 void *argp1 = 0 ;
36280 int res1 = 0 ;
36281 int val2 ;
36282 int ecode2 = 0 ;
36283 PyObject *swig_obj[2] ;
36284
36285 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36287 if (!SWIG_IsOK(res1)) {
36288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36289 }
36290 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36291 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36292 if (!SWIG_IsOK(ecode2)) {
36293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36294 }
36295 arg2 = static_cast< int >(val2);
36296 if (arg1) (arg1)->refresh = arg2;
36297
36298 resultobj = SWIG_Py_Void();
36299 return resultobj;
36300 fail:
36301 return NULL;
36302 }
36303
36304
36305 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36306 PyObject *resultobj = 0;
36307 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36308 int result;
36309 void *argp1 = 0 ;
36310 int res1 = 0 ;
36311 PyObject *swig_obj[1] ;
36312
36313 if (!args) SWIG_fail;
36314 swig_obj[0] = args;
36315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36316 if (!SWIG_IsOK(res1)) {
36317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36318 }
36319 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36320 result = (int) ((arg1)->refresh);
36321 resultobj = SWIG_From_int(static_cast< int >(result));
36322 return resultobj;
36323 fail:
36324 return NULL;
36325 }
36326
36327
36328 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36329 PyObject *obj;
36330 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36331 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36332 return SWIG_Py_Void();
36333 }
36334
36335 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36336 return SWIG_Python_InitShadowInstance(args);
36337 }
36338
36339 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36340 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36341 return 1;
36342 }
36343
36344
36345 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36346 PyObject *pyobj = 0;
36347
36348 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36349 return pyobj;
36350 }
36351
36352
36353 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36354 PyObject *resultobj = 0;
36355 size_t arg1 = (size_t) 0 ;
36356 wxDisplay *result = 0 ;
36357 size_t val1 ;
36358 int ecode1 = 0 ;
36359 PyObject * obj0 = 0 ;
36360 char * kwnames[] = {
36361 (char *) "index", NULL
36362 };
36363
36364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36365 if (obj0) {
36366 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
36367 if (!SWIG_IsOK(ecode1)) {
36368 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
36369 }
36370 arg1 = static_cast< size_t >(val1);
36371 }
36372 {
36373 PyThreadState* __tstate = wxPyBeginAllowThreads();
36374 result = (wxDisplay *)new wxDisplay(arg1);
36375 wxPyEndAllowThreads(__tstate);
36376 if (PyErr_Occurred()) SWIG_fail;
36377 }
36378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36379 return resultobj;
36380 fail:
36381 return NULL;
36382 }
36383
36384
36385 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36386 PyObject *resultobj = 0;
36387 wxDisplay *arg1 = (wxDisplay *) 0 ;
36388 void *argp1 = 0 ;
36389 int res1 = 0 ;
36390 PyObject *swig_obj[1] ;
36391
36392 if (!args) SWIG_fail;
36393 swig_obj[0] = args;
36394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36395 if (!SWIG_IsOK(res1)) {
36396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36397 }
36398 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36399 {
36400 PyThreadState* __tstate = wxPyBeginAllowThreads();
36401 delete arg1;
36402
36403 wxPyEndAllowThreads(__tstate);
36404 if (PyErr_Occurred()) SWIG_fail;
36405 }
36406 resultobj = SWIG_Py_Void();
36407 return resultobj;
36408 fail:
36409 return NULL;
36410 }
36411
36412
36413 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36414 PyObject *resultobj = 0;
36415 size_t result;
36416
36417 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36418 {
36419 PyThreadState* __tstate = wxPyBeginAllowThreads();
36420 result = (size_t)wxDisplay::GetCount();
36421 wxPyEndAllowThreads(__tstate);
36422 if (PyErr_Occurred()) SWIG_fail;
36423 }
36424 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
36425 return resultobj;
36426 fail:
36427 return NULL;
36428 }
36429
36430
36431 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36432 PyObject *resultobj = 0;
36433 wxPoint *arg1 = 0 ;
36434 int result;
36435 wxPoint temp1 ;
36436 PyObject * obj0 = 0 ;
36437 char * kwnames[] = {
36438 (char *) "pt", NULL
36439 };
36440
36441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36442 {
36443 arg1 = &temp1;
36444 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36445 }
36446 {
36447 PyThreadState* __tstate = wxPyBeginAllowThreads();
36448 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36449 wxPyEndAllowThreads(__tstate);
36450 if (PyErr_Occurred()) SWIG_fail;
36451 }
36452 resultobj = SWIG_From_int(static_cast< int >(result));
36453 return resultobj;
36454 fail:
36455 return NULL;
36456 }
36457
36458
36459 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36460 PyObject *resultobj = 0;
36461 wxWindow *arg1 = (wxWindow *) 0 ;
36462 int result;
36463 void *argp1 = 0 ;
36464 int res1 = 0 ;
36465 PyObject * obj0 = 0 ;
36466 char * kwnames[] = {
36467 (char *) "window", NULL
36468 };
36469
36470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36472 if (!SWIG_IsOK(res1)) {
36473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36474 }
36475 arg1 = reinterpret_cast< wxWindow * >(argp1);
36476 {
36477 PyThreadState* __tstate = wxPyBeginAllowThreads();
36478 result = (int)wxDisplay::GetFromWindow(arg1);
36479 wxPyEndAllowThreads(__tstate);
36480 if (PyErr_Occurred()) SWIG_fail;
36481 }
36482 resultobj = SWIG_From_int(static_cast< int >(result));
36483 return resultobj;
36484 fail:
36485 return NULL;
36486 }
36487
36488
36489 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36490 PyObject *resultobj = 0;
36491 wxDisplay *arg1 = (wxDisplay *) 0 ;
36492 bool result;
36493 void *argp1 = 0 ;
36494 int res1 = 0 ;
36495 PyObject *swig_obj[1] ;
36496
36497 if (!args) SWIG_fail;
36498 swig_obj[0] = args;
36499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36500 if (!SWIG_IsOK(res1)) {
36501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36502 }
36503 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36504 {
36505 PyThreadState* __tstate = wxPyBeginAllowThreads();
36506 result = (bool)((wxDisplay const *)arg1)->IsOk();
36507 wxPyEndAllowThreads(__tstate);
36508 if (PyErr_Occurred()) SWIG_fail;
36509 }
36510 {
36511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36512 }
36513 return resultobj;
36514 fail:
36515 return NULL;
36516 }
36517
36518
36519 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36520 PyObject *resultobj = 0;
36521 wxDisplay *arg1 = (wxDisplay *) 0 ;
36522 wxRect result;
36523 void *argp1 = 0 ;
36524 int res1 = 0 ;
36525 PyObject *swig_obj[1] ;
36526
36527 if (!args) SWIG_fail;
36528 swig_obj[0] = args;
36529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36530 if (!SWIG_IsOK(res1)) {
36531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36532 }
36533 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36534 {
36535 PyThreadState* __tstate = wxPyBeginAllowThreads();
36536 result = ((wxDisplay const *)arg1)->GetGeometry();
36537 wxPyEndAllowThreads(__tstate);
36538 if (PyErr_Occurred()) SWIG_fail;
36539 }
36540 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36541 return resultobj;
36542 fail:
36543 return NULL;
36544 }
36545
36546
36547 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36548 PyObject *resultobj = 0;
36549 wxDisplay *arg1 = (wxDisplay *) 0 ;
36550 wxRect result;
36551 void *argp1 = 0 ;
36552 int res1 = 0 ;
36553 PyObject *swig_obj[1] ;
36554
36555 if (!args) SWIG_fail;
36556 swig_obj[0] = args;
36557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36558 if (!SWIG_IsOK(res1)) {
36559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36560 }
36561 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36562 {
36563 PyThreadState* __tstate = wxPyBeginAllowThreads();
36564 result = ((wxDisplay const *)arg1)->GetClientArea();
36565 wxPyEndAllowThreads(__tstate);
36566 if (PyErr_Occurred()) SWIG_fail;
36567 }
36568 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36569 return resultobj;
36570 fail:
36571 return NULL;
36572 }
36573
36574
36575 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36576 PyObject *resultobj = 0;
36577 wxDisplay *arg1 = (wxDisplay *) 0 ;
36578 wxString result;
36579 void *argp1 = 0 ;
36580 int res1 = 0 ;
36581 PyObject *swig_obj[1] ;
36582
36583 if (!args) SWIG_fail;
36584 swig_obj[0] = args;
36585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36586 if (!SWIG_IsOK(res1)) {
36587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36588 }
36589 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36590 {
36591 PyThreadState* __tstate = wxPyBeginAllowThreads();
36592 result = ((wxDisplay const *)arg1)->GetName();
36593 wxPyEndAllowThreads(__tstate);
36594 if (PyErr_Occurred()) SWIG_fail;
36595 }
36596 {
36597 #if wxUSE_UNICODE
36598 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36599 #else
36600 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36601 #endif
36602 }
36603 return resultobj;
36604 fail:
36605 return NULL;
36606 }
36607
36608
36609 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36610 PyObject *resultobj = 0;
36611 wxDisplay *arg1 = (wxDisplay *) 0 ;
36612 bool result;
36613 void *argp1 = 0 ;
36614 int res1 = 0 ;
36615 PyObject *swig_obj[1] ;
36616
36617 if (!args) SWIG_fail;
36618 swig_obj[0] = args;
36619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36620 if (!SWIG_IsOK(res1)) {
36621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36622 }
36623 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36624 {
36625 PyThreadState* __tstate = wxPyBeginAllowThreads();
36626 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36627 wxPyEndAllowThreads(__tstate);
36628 if (PyErr_Occurred()) SWIG_fail;
36629 }
36630 {
36631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36632 }
36633 return resultobj;
36634 fail:
36635 return NULL;
36636 }
36637
36638
36639 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36640 PyObject *resultobj = 0;
36641 wxDisplay *arg1 = (wxDisplay *) 0 ;
36642 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36643 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36644 PyObject *result = 0 ;
36645 void *argp1 = 0 ;
36646 int res1 = 0 ;
36647 void *argp2 = 0 ;
36648 int res2 = 0 ;
36649 PyObject * obj0 = 0 ;
36650 PyObject * obj1 = 0 ;
36651 char * kwnames[] = {
36652 (char *) "self",(char *) "mode", NULL
36653 };
36654
36655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36657 if (!SWIG_IsOK(res1)) {
36658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36659 }
36660 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36661 if (obj1) {
36662 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36663 if (!SWIG_IsOK(res2)) {
36664 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36665 }
36666 if (!argp2) {
36667 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36668 }
36669 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36670 }
36671 {
36672 PyThreadState* __tstate = wxPyBeginAllowThreads();
36673 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36674 wxPyEndAllowThreads(__tstate);
36675 if (PyErr_Occurred()) SWIG_fail;
36676 }
36677 resultobj = result;
36678 return resultobj;
36679 fail:
36680 return NULL;
36681 }
36682
36683
36684 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36685 PyObject *resultobj = 0;
36686 wxDisplay *arg1 = (wxDisplay *) 0 ;
36687 wxVideoMode result;
36688 void *argp1 = 0 ;
36689 int res1 = 0 ;
36690 PyObject *swig_obj[1] ;
36691
36692 if (!args) SWIG_fail;
36693 swig_obj[0] = args;
36694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36695 if (!SWIG_IsOK(res1)) {
36696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36697 }
36698 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36699 {
36700 PyThreadState* __tstate = wxPyBeginAllowThreads();
36701 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36702 wxPyEndAllowThreads(__tstate);
36703 if (PyErr_Occurred()) SWIG_fail;
36704 }
36705 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36706 return resultobj;
36707 fail:
36708 return NULL;
36709 }
36710
36711
36712 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36713 PyObject *resultobj = 0;
36714 wxDisplay *arg1 = (wxDisplay *) 0 ;
36715 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36716 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36717 bool result;
36718 void *argp1 = 0 ;
36719 int res1 = 0 ;
36720 void *argp2 = 0 ;
36721 int res2 = 0 ;
36722 PyObject * obj0 = 0 ;
36723 PyObject * obj1 = 0 ;
36724 char * kwnames[] = {
36725 (char *) "self",(char *) "mode", NULL
36726 };
36727
36728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36730 if (!SWIG_IsOK(res1)) {
36731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36732 }
36733 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36734 if (obj1) {
36735 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36736 if (!SWIG_IsOK(res2)) {
36737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36738 }
36739 if (!argp2) {
36740 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36741 }
36742 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36743 }
36744 {
36745 PyThreadState* __tstate = wxPyBeginAllowThreads();
36746 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36747 wxPyEndAllowThreads(__tstate);
36748 if (PyErr_Occurred()) SWIG_fail;
36749 }
36750 {
36751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36752 }
36753 return resultobj;
36754 fail:
36755 return NULL;
36756 }
36757
36758
36759 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36760 PyObject *resultobj = 0;
36761 wxDisplay *arg1 = (wxDisplay *) 0 ;
36762 void *argp1 = 0 ;
36763 int res1 = 0 ;
36764 PyObject *swig_obj[1] ;
36765
36766 if (!args) SWIG_fail;
36767 swig_obj[0] = args;
36768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36769 if (!SWIG_IsOK(res1)) {
36770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36771 }
36772 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36773 {
36774 PyThreadState* __tstate = wxPyBeginAllowThreads();
36775 wxDisplay_ResetMode(arg1);
36776 wxPyEndAllowThreads(__tstate);
36777 if (PyErr_Occurred()) SWIG_fail;
36778 }
36779 resultobj = SWIG_Py_Void();
36780 return resultobj;
36781 fail:
36782 return NULL;
36783 }
36784
36785
36786 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36787 PyObject *obj;
36788 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36789 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36790 return SWIG_Py_Void();
36791 }
36792
36793 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36794 return SWIG_Python_InitShadowInstance(args);
36795 }
36796
36797 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36798 PyObject *resultobj = 0;
36799 wxStandardPaths *result = 0 ;
36800
36801 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36802 {
36803 PyThreadState* __tstate = wxPyBeginAllowThreads();
36804 result = (wxStandardPaths *)wxStandardPaths_Get();
36805 wxPyEndAllowThreads(__tstate);
36806 if (PyErr_Occurred()) SWIG_fail;
36807 }
36808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36809 return resultobj;
36810 fail:
36811 return NULL;
36812 }
36813
36814
36815 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36816 PyObject *resultobj = 0;
36817 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36818 wxString result;
36819 void *argp1 = 0 ;
36820 int res1 = 0 ;
36821 PyObject *swig_obj[1] ;
36822
36823 if (!args) SWIG_fail;
36824 swig_obj[0] = args;
36825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36826 if (!SWIG_IsOK(res1)) {
36827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36828 }
36829 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36830 {
36831 PyThreadState* __tstate = wxPyBeginAllowThreads();
36832 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36833 wxPyEndAllowThreads(__tstate);
36834 if (PyErr_Occurred()) SWIG_fail;
36835 }
36836 {
36837 #if wxUSE_UNICODE
36838 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36839 #else
36840 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36841 #endif
36842 }
36843 return resultobj;
36844 fail:
36845 return NULL;
36846 }
36847
36848
36849 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36850 PyObject *resultobj = 0;
36851 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36852 wxString result;
36853 void *argp1 = 0 ;
36854 int res1 = 0 ;
36855 PyObject *swig_obj[1] ;
36856
36857 if (!args) SWIG_fail;
36858 swig_obj[0] = args;
36859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36860 if (!SWIG_IsOK(res1)) {
36861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36862 }
36863 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36864 {
36865 PyThreadState* __tstate = wxPyBeginAllowThreads();
36866 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36867 wxPyEndAllowThreads(__tstate);
36868 if (PyErr_Occurred()) SWIG_fail;
36869 }
36870 {
36871 #if wxUSE_UNICODE
36872 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36873 #else
36874 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36875 #endif
36876 }
36877 return resultobj;
36878 fail:
36879 return NULL;
36880 }
36881
36882
36883 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36884 PyObject *resultobj = 0;
36885 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36886 wxString result;
36887 void *argp1 = 0 ;
36888 int res1 = 0 ;
36889 PyObject *swig_obj[1] ;
36890
36891 if (!args) SWIG_fail;
36892 swig_obj[0] = args;
36893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36894 if (!SWIG_IsOK(res1)) {
36895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36896 }
36897 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36898 {
36899 PyThreadState* __tstate = wxPyBeginAllowThreads();
36900 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36901 wxPyEndAllowThreads(__tstate);
36902 if (PyErr_Occurred()) SWIG_fail;
36903 }
36904 {
36905 #if wxUSE_UNICODE
36906 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36907 #else
36908 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36909 #endif
36910 }
36911 return resultobj;
36912 fail:
36913 return NULL;
36914 }
36915
36916
36917 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36918 PyObject *resultobj = 0;
36919 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36920 wxString result;
36921 void *argp1 = 0 ;
36922 int res1 = 0 ;
36923 PyObject *swig_obj[1] ;
36924
36925 if (!args) SWIG_fail;
36926 swig_obj[0] = args;
36927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36928 if (!SWIG_IsOK(res1)) {
36929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36930 }
36931 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36932 {
36933 PyThreadState* __tstate = wxPyBeginAllowThreads();
36934 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
36935 wxPyEndAllowThreads(__tstate);
36936 if (PyErr_Occurred()) SWIG_fail;
36937 }
36938 {
36939 #if wxUSE_UNICODE
36940 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36941 #else
36942 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36943 #endif
36944 }
36945 return resultobj;
36946 fail:
36947 return NULL;
36948 }
36949
36950
36951 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36952 PyObject *resultobj = 0;
36953 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36954 wxString result;
36955 void *argp1 = 0 ;
36956 int res1 = 0 ;
36957 PyObject *swig_obj[1] ;
36958
36959 if (!args) SWIG_fail;
36960 swig_obj[0] = args;
36961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36962 if (!SWIG_IsOK(res1)) {
36963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36964 }
36965 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36966 {
36967 PyThreadState* __tstate = wxPyBeginAllowThreads();
36968 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
36969 wxPyEndAllowThreads(__tstate);
36970 if (PyErr_Occurred()) SWIG_fail;
36971 }
36972 {
36973 #if wxUSE_UNICODE
36974 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36975 #else
36976 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36977 #endif
36978 }
36979 return resultobj;
36980 fail:
36981 return NULL;
36982 }
36983
36984
36985 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36986 PyObject *resultobj = 0;
36987 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36988 wxString result;
36989 void *argp1 = 0 ;
36990 int res1 = 0 ;
36991 PyObject *swig_obj[1] ;
36992
36993 if (!args) SWIG_fail;
36994 swig_obj[0] = args;
36995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36996 if (!SWIG_IsOK(res1)) {
36997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36998 }
36999 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37000 {
37001 PyThreadState* __tstate = wxPyBeginAllowThreads();
37002 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37003 wxPyEndAllowThreads(__tstate);
37004 if (PyErr_Occurred()) SWIG_fail;
37005 }
37006 {
37007 #if wxUSE_UNICODE
37008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37009 #else
37010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37011 #endif
37012 }
37013 return resultobj;
37014 fail:
37015 return NULL;
37016 }
37017
37018
37019 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37020 PyObject *resultobj = 0;
37021 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37022 wxString result;
37023 void *argp1 = 0 ;
37024 int res1 = 0 ;
37025 PyObject *swig_obj[1] ;
37026
37027 if (!args) SWIG_fail;
37028 swig_obj[0] = args;
37029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37030 if (!SWIG_IsOK(res1)) {
37031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37032 }
37033 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37034 {
37035 PyThreadState* __tstate = wxPyBeginAllowThreads();
37036 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37037 wxPyEndAllowThreads(__tstate);
37038 if (PyErr_Occurred()) SWIG_fail;
37039 }
37040 {
37041 #if wxUSE_UNICODE
37042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37043 #else
37044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37045 #endif
37046 }
37047 return resultobj;
37048 fail:
37049 return NULL;
37050 }
37051
37052
37053 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37054 PyObject *resultobj = 0;
37055 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37056 wxString result;
37057 void *argp1 = 0 ;
37058 int res1 = 0 ;
37059 PyObject *swig_obj[1] ;
37060
37061 if (!args) SWIG_fail;
37062 swig_obj[0] = args;
37063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37064 if (!SWIG_IsOK(res1)) {
37065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37066 }
37067 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37068 {
37069 PyThreadState* __tstate = wxPyBeginAllowThreads();
37070 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37071 wxPyEndAllowThreads(__tstate);
37072 if (PyErr_Occurred()) SWIG_fail;
37073 }
37074 {
37075 #if wxUSE_UNICODE
37076 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37077 #else
37078 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37079 #endif
37080 }
37081 return resultobj;
37082 fail:
37083 return NULL;
37084 }
37085
37086
37087 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37088 PyObject *resultobj = 0;
37089 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37090 wxString *arg2 = 0 ;
37091 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37092 wxString result;
37093 void *argp1 = 0 ;
37094 int res1 = 0 ;
37095 bool temp2 = false ;
37096 int val3 ;
37097 int ecode3 = 0 ;
37098 PyObject * obj0 = 0 ;
37099 PyObject * obj1 = 0 ;
37100 PyObject * obj2 = 0 ;
37101 char * kwnames[] = {
37102 (char *) "self",(char *) "lang",(char *) "category", NULL
37103 };
37104
37105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37107 if (!SWIG_IsOK(res1)) {
37108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37109 }
37110 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37111 {
37112 arg2 = wxString_in_helper(obj1);
37113 if (arg2 == NULL) SWIG_fail;
37114 temp2 = true;
37115 }
37116 if (obj2) {
37117 ecode3 = SWIG_AsVal_int(obj2, &val3);
37118 if (!SWIG_IsOK(ecode3)) {
37119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37120 }
37121 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37122 }
37123 {
37124 PyThreadState* __tstate = wxPyBeginAllowThreads();
37125 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37126 wxPyEndAllowThreads(__tstate);
37127 if (PyErr_Occurred()) SWIG_fail;
37128 }
37129 {
37130 #if wxUSE_UNICODE
37131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37132 #else
37133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37134 #endif
37135 }
37136 {
37137 if (temp2)
37138 delete arg2;
37139 }
37140 return resultobj;
37141 fail:
37142 {
37143 if (temp2)
37144 delete arg2;
37145 }
37146 return NULL;
37147 }
37148
37149
37150 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37151 PyObject *resultobj = 0;
37152 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37153 wxString result;
37154 void *argp1 = 0 ;
37155 int res1 = 0 ;
37156 PyObject *swig_obj[1] ;
37157
37158 if (!args) SWIG_fail;
37159 swig_obj[0] = args;
37160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37161 if (!SWIG_IsOK(res1)) {
37162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37163 }
37164 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37165 {
37166 PyThreadState* __tstate = wxPyBeginAllowThreads();
37167 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37168 wxPyEndAllowThreads(__tstate);
37169 if (PyErr_Occurred()) SWIG_fail;
37170 }
37171 {
37172 #if wxUSE_UNICODE
37173 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37174 #else
37175 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37176 #endif
37177 }
37178 return resultobj;
37179 fail:
37180 return NULL;
37181 }
37182
37183
37184 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37185 PyObject *resultobj = 0;
37186 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37187 wxString *arg2 = 0 ;
37188 void *argp1 = 0 ;
37189 int res1 = 0 ;
37190 bool temp2 = false ;
37191 PyObject * obj0 = 0 ;
37192 PyObject * obj1 = 0 ;
37193 char * kwnames[] = {
37194 (char *) "self",(char *) "prefix", NULL
37195 };
37196
37197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37199 if (!SWIG_IsOK(res1)) {
37200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37201 }
37202 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37203 {
37204 arg2 = wxString_in_helper(obj1);
37205 if (arg2 == NULL) SWIG_fail;
37206 temp2 = true;
37207 }
37208 {
37209 PyThreadState* __tstate = wxPyBeginAllowThreads();
37210 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
37211 wxPyEndAllowThreads(__tstate);
37212 if (PyErr_Occurred()) SWIG_fail;
37213 }
37214 resultobj = SWIG_Py_Void();
37215 {
37216 if (temp2)
37217 delete arg2;
37218 }
37219 return resultobj;
37220 fail:
37221 {
37222 if (temp2)
37223 delete arg2;
37224 }
37225 return NULL;
37226 }
37227
37228
37229 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37230 PyObject *resultobj = 0;
37231 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37232 wxString result;
37233 void *argp1 = 0 ;
37234 int res1 = 0 ;
37235 PyObject *swig_obj[1] ;
37236
37237 if (!args) SWIG_fail;
37238 swig_obj[0] = args;
37239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37240 if (!SWIG_IsOK(res1)) {
37241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37242 }
37243 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37244 {
37245 PyThreadState* __tstate = wxPyBeginAllowThreads();
37246 result = wxStandardPaths_GetInstallPrefix(arg1);
37247 wxPyEndAllowThreads(__tstate);
37248 if (PyErr_Occurred()) SWIG_fail;
37249 }
37250 {
37251 #if wxUSE_UNICODE
37252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37253 #else
37254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37255 #endif
37256 }
37257 return resultobj;
37258 fail:
37259 return NULL;
37260 }
37261
37262
37263 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37264 PyObject *obj;
37265 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37266 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37267 return SWIG_Py_Void();
37268 }
37269
37270 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37271 PyObject *resultobj = 0;
37272 wxEventType arg1 ;
37273 wxPowerEvent *result = 0 ;
37274 int val1 ;
37275 int ecode1 = 0 ;
37276 PyObject * obj0 = 0 ;
37277 char * kwnames[] = {
37278 (char *) "evtType", NULL
37279 };
37280
37281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37282 ecode1 = SWIG_AsVal_int(obj0, &val1);
37283 if (!SWIG_IsOK(ecode1)) {
37284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37285 }
37286 arg1 = static_cast< wxEventType >(val1);
37287 {
37288 PyThreadState* __tstate = wxPyBeginAllowThreads();
37289 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37290 wxPyEndAllowThreads(__tstate);
37291 if (PyErr_Occurred()) SWIG_fail;
37292 }
37293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37294 return resultobj;
37295 fail:
37296 return NULL;
37297 }
37298
37299
37300 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37301 PyObject *resultobj = 0;
37302 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37303 void *argp1 = 0 ;
37304 int res1 = 0 ;
37305 PyObject *swig_obj[1] ;
37306
37307 if (!args) SWIG_fail;
37308 swig_obj[0] = args;
37309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37310 if (!SWIG_IsOK(res1)) {
37311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37312 }
37313 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37314 {
37315 PyThreadState* __tstate = wxPyBeginAllowThreads();
37316 (arg1)->Veto();
37317 wxPyEndAllowThreads(__tstate);
37318 if (PyErr_Occurred()) SWIG_fail;
37319 }
37320 resultobj = SWIG_Py_Void();
37321 return resultobj;
37322 fail:
37323 return NULL;
37324 }
37325
37326
37327 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37328 PyObject *resultobj = 0;
37329 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37330 bool result;
37331 void *argp1 = 0 ;
37332 int res1 = 0 ;
37333 PyObject *swig_obj[1] ;
37334
37335 if (!args) SWIG_fail;
37336 swig_obj[0] = args;
37337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37338 if (!SWIG_IsOK(res1)) {
37339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37340 }
37341 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37342 {
37343 PyThreadState* __tstate = wxPyBeginAllowThreads();
37344 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37345 wxPyEndAllowThreads(__tstate);
37346 if (PyErr_Occurred()) SWIG_fail;
37347 }
37348 {
37349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37350 }
37351 return resultobj;
37352 fail:
37353 return NULL;
37354 }
37355
37356
37357 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37358 PyObject *obj;
37359 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37360 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37361 return SWIG_Py_Void();
37362 }
37363
37364 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37365 return SWIG_Python_InitShadowInstance(args);
37366 }
37367
37368 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37369 PyObject *resultobj = 0;
37370 wxPowerType result;
37371
37372 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37373 {
37374 PyThreadState* __tstate = wxPyBeginAllowThreads();
37375 result = (wxPowerType)wxGetPowerType();
37376 wxPyEndAllowThreads(__tstate);
37377 if (PyErr_Occurred()) SWIG_fail;
37378 }
37379 resultobj = SWIG_From_int(static_cast< int >(result));
37380 return resultobj;
37381 fail:
37382 return NULL;
37383 }
37384
37385
37386 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37387 PyObject *resultobj = 0;
37388 wxBatteryState result;
37389
37390 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37391 {
37392 PyThreadState* __tstate = wxPyBeginAllowThreads();
37393 result = (wxBatteryState)wxGetBatteryState();
37394 wxPyEndAllowThreads(__tstate);
37395 if (PyErr_Occurred()) SWIG_fail;
37396 }
37397 resultobj = SWIG_From_int(static_cast< int >(result));
37398 return resultobj;
37399 fail:
37400 return NULL;
37401 }
37402
37403
37404 static PyMethodDef SwigMethods[] = {
37405 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
37406 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
37407 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
37408 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
37409 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
37410 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
37411 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
37412 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
37413 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
37414 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
37415 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
37416 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
37417 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
37418 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
37419 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
37420 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
37421 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
37422 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
37423 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
37424 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
37425 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
37426 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
37427 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
37428 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
37429 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
37430 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
37431 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
37432 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
37433 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
37434 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
37435 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
37436 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
37437 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
37438 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
37439 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
37440 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
37441 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
37442 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
37443 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
37444 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
37445 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
37446 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
37447 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
37448 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
37449 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
37450 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
37451 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
37452 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
37453 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
37454 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
37455 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37456 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37457 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37458 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37459 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37460 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37461 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
37462 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
37463 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
37464 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37465 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
37466 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
37467 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
37468 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
37469 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
37470 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
37471 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
37472 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
37473 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
37474 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37475 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
37476 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37477 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
37478 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
37479 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
37480 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37481 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37482 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
37483 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
37484 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
37485 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
37486 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
37487 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
37488 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
37489 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
37490 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
37491 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
37492 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
37493 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
37494 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
37495 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
37496 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
37497 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
37498 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
37499 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
37500 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
37501 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
37502 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
37503 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
37504 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
37505 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
37506 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
37507 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
37508 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
37509 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
37510 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
37511 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
37512 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
37513 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
37514 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
37515 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
37516 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
37517 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
37518 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
37519 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
37520 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
37521 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
37522 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
37523 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
37524 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
37525 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
37526 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
37527 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
37528 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
37529 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
37530 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
37531 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
37532 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
37533 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
37534 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
37535 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
37536 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
37537 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
37538 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
37539 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
37540 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
37541 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
37542 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
37543 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
37544 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
37545 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
37546 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37547 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
37548 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
37549 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
37550 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
37551 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
37552 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
37553 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
37554 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37555 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
37556 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
37557 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
37558 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
37559 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37560 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
37561 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
37562 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
37563 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
37564 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
37565 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37566 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
37567 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37568 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37569 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
37570 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37571 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37572 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
37573 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
37574 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
37575 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37576 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
37577 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
37578 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
37579 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
37580 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
37581 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
37582 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
37583 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
37584 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
37585 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
37586 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
37587 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
37588 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37589 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37590 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
37591 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
37592 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37593 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
37594 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
37595 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37596 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
37597 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
37598 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
37599 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
37600 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
37601 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
37602 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
37603 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
37604 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
37605 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
37606 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
37607 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37608 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37609 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
37610 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
37611 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
37612 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
37613 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
37614 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
37615 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
37616 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
37617 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
37618 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
37619 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
37620 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
37621 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
37622 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37623 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37624 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
37625 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
37626 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
37627 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37628 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
37629 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
37630 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37631 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
37632 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
37633 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37634 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
37635 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
37636 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
37637 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
37638 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
37639 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
37640 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
37641 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
37642 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37643 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
37644 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
37645 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
37646 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
37647 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
37648 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37649 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
37650 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
37651 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
37652 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
37653 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
37654 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
37655 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
37656 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
37657 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
37658 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
37659 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
37660 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
37661 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
37662 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
37663 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
37664 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
37665 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
37666 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
37667 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37668 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37669 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37670 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
37671 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
37672 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
37673 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
37674 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
37675 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37676 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
37677 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
37678 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
37679 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
37680 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
37681 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
37682 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
37683 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
37684 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
37685 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
37686 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
37687 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
37688 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
37689 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
37690 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
37691 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37692 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
37693 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
37694 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
37695 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
37696 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
37697 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
37698 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
37699 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
37700 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
37701 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
37702 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
37703 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
37704 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
37705 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
37706 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
37707 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
37708 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
37709 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
37710 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
37711 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
37712 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
37713 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
37714 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
37715 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
37716 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37717 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
37718 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
37719 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
37720 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
37721 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
37722 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
37723 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
37724 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
37725 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
37726 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
37727 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
37728 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
37729 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
37730 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37731 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
37732 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
37733 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
37734 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
37735 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
37736 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
37737 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37738 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
37739 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
37740 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
37741 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
37742 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
37743 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
37744 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
37745 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
37746 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
37747 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
37748 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
37749 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
37750 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
37751 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37752 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
37753 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
37754 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
37755 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
37756 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
37757 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
37758 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
37759 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
37760 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
37761 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
37762 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
37763 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
37764 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
37765 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
37766 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
37767 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
37768 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
37769 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
37770 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
37771 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
37772 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
37773 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
37774 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
37775 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
37776 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
37777 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
37778 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
37779 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
37780 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
37781 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
37782 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
37783 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
37784 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
37785 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
37786 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
37787 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
37788 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
37789 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
37790 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
37791 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
37792 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
37793 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
37794 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
37795 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
37796 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
37797 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
37798 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
37799 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
37800 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
37801 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
37802 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
37803 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
37804 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
37805 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
37806 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
37807 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
37808 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37809 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
37810 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
37811 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
37812 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
37813 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
37814 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
37815 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
37816 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
37817 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
37818 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
37819 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
37820 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
37821 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
37822 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
37823 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
37824 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
37825 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
37826 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
37827 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
37828 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
37829 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
37830 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
37831 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
37832 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
37833 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
37834 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
37835 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
37836 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
37837 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
37838 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37839 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
37840 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
37841 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
37842 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37843 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
37844 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
37845 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
37846 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
37847 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
37848 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
37849 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
37850 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
37851 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
37852 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
37853 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
37854 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
37855 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
37856 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
37857 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
37858 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
37859 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
37860 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
37861 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
37862 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
37863 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37864 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37865 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
37866 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37867 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37868 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
37869 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37870 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
37871 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
37872 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
37873 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
37874 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
37875 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
37876 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
37877 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
37878 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
37879 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
37880 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
37881 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
37882 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
37883 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
37884 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
37885 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
37886 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
37887 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
37888 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
37889 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37890 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
37891 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
37892 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
37893 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
37894 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
37895 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37896 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
37897 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
37898 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
37899 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
37900 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
37901 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
37902 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
37903 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
37904 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
37905 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
37906 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
37907 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
37908 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37909 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
37910 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37911 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
37912 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
37913 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37914 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37915 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
37916 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
37917 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
37918 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
37919 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
37920 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
37921 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
37922 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
37923 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
37924 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
37925 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
37926 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37927 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37928 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37929 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37930 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
37931 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37932 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
37933 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
37934 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
37935 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37936 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
37937 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
37938 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
37939 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
37940 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
37941 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
37942 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
37943 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
37944 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
37945 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
37946 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
37947 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
37948 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
37949 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
37950 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
37951 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
37952 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
37953 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
37954 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
37955 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
37956 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37957 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
37958 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
37959 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
37960 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
37961 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
37962 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37963 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
37964 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
37965 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
37966 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37967 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
37968 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
37969 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
37970 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
37971 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
37972 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
37973 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
37974 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
37975 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
37976 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
37977 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
37978 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
37979 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
37980 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
37981 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
37982 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
37983 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
37984 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
37985 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
37986 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
37987 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
37988 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
37989 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
37990 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37991 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
37992 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
37993 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
37994 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
37995 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
37996 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37997 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37998 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37999 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
38000 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
38001 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
38002 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
38003 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
38004 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
38005 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
38006 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
38007 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
38008 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
38009 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
38010 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
38011 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
38012 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
38013 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
38014 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
38015 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
38016 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
38017 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
38018 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
38019 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
38020 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
38021 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
38022 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
38023 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
38024 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
38025 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
38026 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
38027 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
38028 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
38029 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
38030 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
38031 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
38032 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
38033 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
38034 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
38035 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
38036 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
38037 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
38038 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
38039 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
38040 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
38041 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
38042 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
38043 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
38044 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
38045 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
38046 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
38047 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
38048 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
38049 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
38050 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
38051 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
38052 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
38053 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
38054 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
38055 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
38056 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
38057 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
38058 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
38059 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
38060 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
38061 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
38062 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
38063 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
38064 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
38065 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
38066 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38067 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
38068 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
38069 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
38070 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
38071 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
38072 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
38073 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
38074 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
38075 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
38076 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
38077 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
38078 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
38079 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
38080 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
38081 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
38082 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
38083 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
38084 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
38085 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
38086 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
38087 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
38088 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
38089 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
38090 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
38091 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
38092 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
38093 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
38094 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
38095 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
38096 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
38097 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
38098 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
38099 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
38100 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
38101 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
38102 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
38103 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
38104 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
38105 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
38106 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
38107 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
38108 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
38109 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
38110 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
38111 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
38112 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
38113 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
38114 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
38115 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
38116 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
38117 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
38118 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
38119 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
38120 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
38121 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
38122 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
38123 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
38124 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
38125 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
38126 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
38127 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
38128 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
38129 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
38130 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
38131 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
38132 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
38133 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
38134 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
38135 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
38136 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
38137 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
38138 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
38139 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
38140 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
38141 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
38142 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
38143 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
38144 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
38145 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
38146 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
38147 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
38148 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
38149 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
38150 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
38151 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
38152 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
38153 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
38154 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
38155 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
38156 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
38157 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
38158 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
38159 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
38160 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
38161 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
38162 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
38163 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
38164 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38165 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38166 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
38167 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
38168 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
38169 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
38170 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
38171 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
38172 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
38173 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
38174 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
38175 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
38176 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38177 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
38178 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
38179 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
38180 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
38181 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
38182 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38183 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
38184 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
38185 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
38186 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38187 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
38188 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
38189 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38190 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
38191 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
38192 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
38193 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38194 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
38195 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
38196 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
38197 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
38198 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
38199 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
38200 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
38201 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38202 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
38203 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
38204 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
38205 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
38206 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
38207 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38208 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38209 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
38210 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
38211 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38212 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
38213 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
38214 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
38215 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
38216 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38217 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38218 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
38219 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
38220 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
38221 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
38222 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
38223 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
38224 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
38225 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
38226 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38227 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
38228 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
38229 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
38230 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
38231 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38232 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
38233 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
38234 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
38235 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
38236 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
38237 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
38238 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
38239 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
38240 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
38241 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
38242 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
38243 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38244 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
38245 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38246 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
38247 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
38248 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38249 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
38250 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
38251 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
38252 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
38253 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38254 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
38255 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
38256 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38257 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38258 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38259 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
38260 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38261 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
38262 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
38263 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
38264 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
38265 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
38266 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
38267 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38268 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
38269 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38270 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38271 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
38272 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38273 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
38274 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
38275 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
38276 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
38277 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38278 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
38279 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38280 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38281 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
38282 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38283 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
38284 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
38285 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
38286 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
38287 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
38288 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
38289 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
38290 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
38291 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
38292 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38293 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
38294 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
38295 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
38296 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
38297 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
38298 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
38299 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
38300 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
38301 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
38302 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
38303 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
38304 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
38305 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
38306 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
38307 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
38308 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
38309 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
38310 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
38311 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
38312 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
38313 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
38314 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
38315 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
38316 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
38317 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
38318 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
38319 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
38320 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
38321 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
38322 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
38323 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
38324 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
38325 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
38326 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
38327 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
38328 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
38329 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
38330 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
38331 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
38332 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
38333 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
38334 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
38335 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
38336 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
38337 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
38338 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
38339 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
38340 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
38341 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
38342 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
38343 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
38344 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
38345 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
38346 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
38347 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
38348 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
38349 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
38350 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
38351 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
38352 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
38353 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
38354 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
38355 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
38356 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
38357 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
38358 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
38359 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
38360 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
38361 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
38362 { NULL, NULL, 0, NULL }
38363 };
38364
38365
38366 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
38367
38368 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
38369 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
38370 }
38371 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
38372 return (void *)((wxEvent *) ((wxMenuEvent *) x));
38373 }
38374 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
38375 return (void *)((wxEvent *) ((wxCloseEvent *) x));
38376 }
38377 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
38378 return (void *)((wxEvent *) ((wxMouseEvent *) x));
38379 }
38380 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
38381 return (void *)((wxEvent *) ((wxEraseEvent *) x));
38382 }
38383 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
38384 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
38385 }
38386 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
38387 return (void *)((wxEvent *) ((wxTimerEvent *) x));
38388 }
38389 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
38390 return (void *)((wxEvent *) ((wxPowerEvent *) x));
38391 }
38392 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
38393 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
38394 }
38395 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
38396 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
38397 }
38398 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
38399 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
38400 }
38401 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
38402 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
38403 }
38404 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
38405 return (void *)((wxEvent *) ((wxPyEvent *) x));
38406 }
38407 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
38408 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
38409 }
38410 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
38411 return (void *)((wxEvent *) ((wxIdleEvent *) x));
38412 }
38413 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
38414 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
38415 }
38416 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
38417 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
38418 }
38419 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
38420 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
38421 }
38422 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
38423 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
38424 }
38425 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
38426 return (void *)((wxEvent *) ((wxActivateEvent *) x));
38427 }
38428 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
38429 return (void *)((wxEvent *) ((wxSizeEvent *) x));
38430 }
38431 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
38432 return (void *)((wxEvent *) ((wxMoveEvent *) x));
38433 }
38434 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
38435 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
38436 }
38437 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
38438 return (void *)((wxEvent *) ((wxPaintEvent *) x));
38439 }
38440 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
38441 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
38442 }
38443 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
38444 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
38445 }
38446 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
38447 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
38448 }
38449 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
38450 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
38451 }
38452 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
38453 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
38454 }
38455 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
38456 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
38457 }
38458 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
38459 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
38460 }
38461 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
38462 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
38463 }
38464 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
38465 return (void *)((wxEvent *) ((wxFocusEvent *) x));
38466 }
38467 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
38468 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
38469 }
38470 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
38471 return (void *)((wxEvent *) ((wxProcessEvent *) x));
38472 }
38473 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
38474 return (void *)((wxEvent *) ((wxShowEvent *) x));
38475 }
38476 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
38477 return (void *)((wxEvent *) ((wxCommandEvent *) x));
38478 }
38479 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
38480 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
38481 }
38482 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
38483 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
38484 }
38485 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
38486 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
38487 }
38488 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
38489 return (void *)((wxEvent *) ((wxKeyEvent *) x));
38490 }
38491 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
38492 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
38493 }
38494 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
38495 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
38496 }
38497 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
38498 return (void *)((wxConfigBase *) ((wxConfig *) x));
38499 }
38500 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
38501 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38502 }
38503 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
38504 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
38505 }
38506 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
38507 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
38508 }
38509 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
38510 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
38511 }
38512 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
38513 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
38514 }
38515 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
38516 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
38517 }
38518 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
38519 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
38520 }
38521 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
38522 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
38523 }
38524 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
38525 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38526 }
38527 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
38528 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
38529 }
38530 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
38531 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
38532 }
38533 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
38534 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
38535 }
38536 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
38537 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
38538 }
38539 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
38540 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
38541 }
38542 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
38543 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
38544 }
38545 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
38546 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
38547 }
38548 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
38549 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
38550 }
38551 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
38552 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38553 }
38554 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
38555 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
38556 }
38557 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
38558 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
38559 }
38560 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
38561 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
38562 }
38563 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
38564 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
38565 }
38566 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
38567 return (void *)((wxEvtHandler *) ((wxWindow *) x));
38568 }
38569 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
38570 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
38571 }
38572 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
38573 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
38574 }
38575 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
38576 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
38577 }
38578 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
38579 return (void *)((wxEvtHandler *) ((wxValidator *) x));
38580 }
38581 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
38582 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
38583 }
38584 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
38585 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
38586 }
38587 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
38588 return (void *)((wxEvtHandler *) ((wxMenu *) x));
38589 }
38590 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
38591 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
38592 }
38593 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
38594 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
38595 }
38596 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
38597 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
38598 }
38599 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
38600 return (void *)((wxObject *) ((wxSizerItem *) x));
38601 }
38602 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
38603 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
38604 }
38605 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
38606 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
38607 }
38608 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
38609 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
38610 }
38611 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
38612 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
38613 }
38614 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
38615 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
38616 }
38617 static void *_p_wxSizerTo_p_wxObject(void *x) {
38618 return (void *)((wxObject *) ((wxSizer *) x));
38619 }
38620 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
38621 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
38622 }
38623 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
38624 return (void *)((wxObject *) ((wxFileHistory *) x));
38625 }
38626 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
38627 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
38628 }
38629 static void *_p_wxEventTo_p_wxObject(void *x) {
38630 return (void *)((wxObject *) ((wxEvent *) x));
38631 }
38632 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
38633 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
38634 }
38635 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
38636 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
38637 }
38638 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
38639 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
38640 }
38641 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
38642 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
38643 }
38644 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
38645 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
38646 }
38647 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
38648 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
38649 }
38650 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
38651 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
38652 }
38653 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
38654 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
38655 }
38656 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
38657 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
38658 }
38659 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
38660 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
38661 }
38662 static void *_p_wxControlTo_p_wxObject(void *x) {
38663 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
38664 }
38665 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
38666 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
38667 }
38668 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
38669 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
38670 }
38671 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
38672 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
38673 }
38674 static void *_p_wxFSFileTo_p_wxObject(void *x) {
38675 return (void *)((wxObject *) ((wxFSFile *) x));
38676 }
38677 static void *_p_wxClipboardTo_p_wxObject(void *x) {
38678 return (void *)((wxObject *) ((wxClipboard *) x));
38679 }
38680 static void *_p_wxPySizerTo_p_wxObject(void *x) {
38681 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
38682 }
38683 static void *_p_wxPyEventTo_p_wxObject(void *x) {
38684 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
38685 }
38686 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
38687 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
38688 }
38689 static void *_p_wxShowEventTo_p_wxObject(void *x) {
38690 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
38691 }
38692 static void *_p_wxToolTipTo_p_wxObject(void *x) {
38693 return (void *)((wxObject *) ((wxToolTip *) x));
38694 }
38695 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
38696 return (void *)((wxObject *) ((wxMenuItem *) x));
38697 }
38698 static void *_p_wxDateEventTo_p_wxObject(void *x) {
38699 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
38700 }
38701 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
38702 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
38703 }
38704 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
38705 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
38706 }
38707 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
38708 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
38709 }
38710 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
38711 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
38712 }
38713 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
38714 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
38715 }
38716 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
38717 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
38718 }
38719 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
38720 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
38721 }
38722 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
38723 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
38724 }
38725 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
38726 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
38727 }
38728 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
38729 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
38730 }
38731 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
38732 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
38733 }
38734 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
38735 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
38736 }
38737 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
38738 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
38739 }
38740 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
38741 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
38742 }
38743 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
38744 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
38745 }
38746 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
38747 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
38748 }
38749 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
38750 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
38751 }
38752 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
38753 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
38754 }
38755 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
38756 return (void *)((wxObject *) ((wxImageHandler *) x));
38757 }
38758 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
38759 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
38760 }
38761 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
38762 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
38763 }
38764 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
38765 return (void *)((wxObject *) ((wxEvtHandler *) x));
38766 }
38767 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
38768 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
38769 }
38770 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
38771 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
38772 }
38773 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
38774 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
38775 }
38776 static void *_p_wxImageTo_p_wxObject(void *x) {
38777 return (void *)((wxObject *) ((wxImage *) x));
38778 }
38779 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
38780 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
38781 }
38782 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
38783 return (void *)((wxObject *) ((wxSystemOptions *) x));
38784 }
38785 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
38786 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
38787 }
38788 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
38789 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
38790 }
38791 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
38792 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
38793 }
38794 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
38795 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
38796 }
38797 static void *_p_wxWindowTo_p_wxObject(void *x) {
38798 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
38799 }
38800 static void *_p_wxMenuTo_p_wxObject(void *x) {
38801 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
38802 }
38803 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
38804 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
38805 }
38806 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
38807 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
38808 }
38809 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
38810 return (void *)((wxObject *) ((wxFileSystem *) x));
38811 }
38812 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
38813 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
38814 }
38815 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
38816 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
38817 }
38818 static void *_p_wxPyAppTo_p_wxObject(void *x) {
38819 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
38820 }
38821 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
38822 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
38823 }
38824 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
38825 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
38826 }
38827 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
38828 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
38829 }
38830 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
38831 return (void *)((wxObject *) ((wxBusyInfo *) x));
38832 }
38833 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
38834 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
38835 }
38836 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
38837 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
38838 }
38839 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
38840 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
38841 }
38842 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
38843 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
38844 }
38845 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
38846 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
38847 }
38848 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
38849 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
38850 }
38851 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
38852 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
38853 }
38854 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
38855 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
38856 }
38857 static void *_p_wxValidatorTo_p_wxObject(void *x) {
38858 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
38859 }
38860 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
38861 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
38862 }
38863 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
38864 return (void *)((wxLog *) ((wxLogBuffer *) x));
38865 }
38866 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
38867 return (void *)((wxLog *) ((wxLogStderr *) x));
38868 }
38869 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
38870 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
38871 }
38872 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
38873 return (void *)((wxLog *) ((wxLogWindow *) x));
38874 }
38875 static void *_p_wxLogChainTo_p_wxLog(void *x) {
38876 return (void *)((wxLog *) ((wxLogChain *) x));
38877 }
38878 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
38879 return (void *)((wxLog *) ((wxLogGui *) x));
38880 }
38881 static void *_p_wxPyLogTo_p_wxLog(void *x) {
38882 return (void *)((wxLog *) ((wxPyLog *) x));
38883 }
38884 static void *_p_wxControlTo_p_wxWindow(void *x) {
38885 return (void *)((wxWindow *) ((wxControl *) x));
38886 }
38887 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
38888 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
38889 }
38890 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
38891 return (void *)((wxWindow *) ((wxMenuBar *) x));
38892 }
38893 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
38894 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
38895 }
38896 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
38897 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
38898 }
38899 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
38900 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};
38901 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
38902 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
38903 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
38904 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
38905 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
38906 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
38907 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
38908 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
38909 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
38910 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
38911 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
38912 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
38913 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
38914 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
38915 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
38916 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
38917 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
38918 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
38919 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
38920 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
38921 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
38922 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
38923 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
38924 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
38925 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
38926 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
38927 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
38928 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
38929 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
38930 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
38931 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
38932 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
38933 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
38934 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
38935 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
38936 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
38937 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
38938 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
38939 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
38940 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
38941 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
38942 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
38943 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
38944 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
38945 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
38946 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
38947 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
38948 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
38949 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
38950 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
38951 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
38952 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
38953 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
38954 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
38955 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
38956 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
38957 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
38958 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
38959 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
38960 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
38961 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
38962 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
38963 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
38964 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
38965 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
38966 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
38967 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
38968 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
38969 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
38970 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
38971 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
38972 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
38973 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
38974 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
38975 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
38976 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
38977 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
38978 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
38979 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
38980 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
38981 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
38982 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
38983 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
38984 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
38985 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
38986 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
38987 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
38988 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
38989 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
38990 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
38991 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
38992 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
38993 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
38994 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
38995 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
38996 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
38997 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
38998 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
38999 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
39000 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
39001 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
39002 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
39003 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
39004 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
39005 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
39006 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
39007 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
39008 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
39009 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
39010 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
39011 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
39012 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
39013 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
39014 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
39015 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
39016 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
39017 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
39018 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
39019 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
39020 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
39021 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
39022 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
39023 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
39024 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
39025 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
39026 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
39027 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
39028 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
39029 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
39030 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
39031 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
39032 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
39033 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
39034 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
39035 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
39036 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
39037 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
39038 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
39039 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
39040 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
39041 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
39042 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
39043 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
39044 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
39045 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
39046 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
39047 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
39048 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
39049 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
39050 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
39051 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
39052 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
39053 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
39054 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
39055 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
39056 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
39057 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
39058 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
39059 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
39060 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
39061 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
39062 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
39063 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
39064 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
39065 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
39066 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
39067 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
39068 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
39069 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
39070 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
39071 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
39072
39073 static swig_type_info *swig_type_initial[] = {
39074 &_swigt__p_char,
39075 &_swigt__p_form_ops_t,
39076 &_swigt__p_int,
39077 &_swigt__p_unsigned_char,
39078 &_swigt__p_unsigned_int,
39079 &_swigt__p_unsigned_long,
39080 &_swigt__p_void,
39081 &_swigt__p_wxANIHandler,
39082 &_swigt__p_wxAcceleratorTable,
39083 &_swigt__p_wxActivateEvent,
39084 &_swigt__p_wxArrayString,
39085 &_swigt__p_wxBMPHandler,
39086 &_swigt__p_wxBitmap,
39087 &_swigt__p_wxBitmapDataObject,
39088 &_swigt__p_wxBoxSizer,
39089 &_swigt__p_wxBusyCursor,
39090 &_swigt__p_wxBusyInfo,
39091 &_swigt__p_wxCURHandler,
39092 &_swigt__p_wxCaret,
39093 &_swigt__p_wxChar,
39094 &_swigt__p_wxChildFocusEvent,
39095 &_swigt__p_wxClipboard,
39096 &_swigt__p_wxClipboardLocker,
39097 &_swigt__p_wxClipboardTextEvent,
39098 &_swigt__p_wxCloseEvent,
39099 &_swigt__p_wxColour,
39100 &_swigt__p_wxCommandEvent,
39101 &_swigt__p_wxConfig,
39102 &_swigt__p_wxConfigBase,
39103 &_swigt__p_wxConfigPathChanger,
39104 &_swigt__p_wxContextMenuEvent,
39105 &_swigt__p_wxControl,
39106 &_swigt__p_wxControlWithItems,
39107 &_swigt__p_wxCursor,
39108 &_swigt__p_wxCustomDataObject,
39109 &_swigt__p_wxDC,
39110 &_swigt__p_wxDataFormat,
39111 &_swigt__p_wxDataObject,
39112 &_swigt__p_wxDataObjectComposite,
39113 &_swigt__p_wxDataObjectSimple,
39114 &_swigt__p_wxDateEvent,
39115 &_swigt__p_wxDateSpan,
39116 &_swigt__p_wxDateTime,
39117 &_swigt__p_wxDateTime__TimeZone,
39118 &_swigt__p_wxDisplay,
39119 &_swigt__p_wxDisplayChangedEvent,
39120 &_swigt__p_wxDropFilesEvent,
39121 &_swigt__p_wxDuplexMode,
39122 &_swigt__p_wxEraseEvent,
39123 &_swigt__p_wxEvent,
39124 &_swigt__p_wxEvtHandler,
39125 &_swigt__p_wxFSFile,
39126 &_swigt__p_wxFileConfig,
39127 &_swigt__p_wxFileDataObject,
39128 &_swigt__p_wxFileHistory,
39129 &_swigt__p_wxFileSystem,
39130 &_swigt__p_wxFileType,
39131 &_swigt__p_wxFileTypeInfo,
39132 &_swigt__p_wxFlexGridSizer,
39133 &_swigt__p_wxFocusEvent,
39134 &_swigt__p_wxFont,
39135 &_swigt__p_wxFrame,
39136 &_swigt__p_wxGBSizerItem,
39137 &_swigt__p_wxGIFHandler,
39138 &_swigt__p_wxGridBagSizer,
39139 &_swigt__p_wxGridSizer,
39140 &_swigt__p_wxICOHandler,
39141 &_swigt__p_wxIcon,
39142 &_swigt__p_wxIconizeEvent,
39143 &_swigt__p_wxIdleEvent,
39144 &_swigt__p_wxImage,
39145 &_swigt__p_wxImageHandler,
39146 &_swigt__p_wxIndividualLayoutConstraint,
39147 &_swigt__p_wxInitDialogEvent,
39148 &_swigt__p_wxJPEGHandler,
39149 &_swigt__p_wxJoystick,
39150 &_swigt__p_wxJoystickEvent,
39151 &_swigt__p_wxKeyEvent,
39152 &_swigt__p_wxKillError,
39153 &_swigt__p_wxLayoutConstraints,
39154 &_swigt__p_wxLog,
39155 &_swigt__p_wxLogBuffer,
39156 &_swigt__p_wxLogChain,
39157 &_swigt__p_wxLogGui,
39158 &_swigt__p_wxLogNull,
39159 &_swigt__p_wxLogStderr,
39160 &_swigt__p_wxLogTextCtrl,
39161 &_swigt__p_wxLogWindow,
39162 &_swigt__p_wxMaximizeEvent,
39163 &_swigt__p_wxMenu,
39164 &_swigt__p_wxMenuBar,
39165 &_swigt__p_wxMenuEvent,
39166 &_swigt__p_wxMenuItem,
39167 &_swigt__p_wxMetafile,
39168 &_swigt__p_wxMetafileDataObject,
39169 &_swigt__p_wxMimeTypesManager,
39170 &_swigt__p_wxMouseCaptureChangedEvent,
39171 &_swigt__p_wxMouseCaptureLostEvent,
39172 &_swigt__p_wxMouseEvent,
39173 &_swigt__p_wxMouseState,
39174 &_swigt__p_wxMoveEvent,
39175 &_swigt__p_wxMutexGuiLocker,
39176 &_swigt__p_wxNavigationKeyEvent,
39177 &_swigt__p_wxNcPaintEvent,
39178 &_swigt__p_wxNotifyEvent,
39179 &_swigt__p_wxObject,
39180 &_swigt__p_wxOutputStream,
39181 &_swigt__p_wxPCXHandler,
39182 &_swigt__p_wxPNGHandler,
39183 &_swigt__p_wxPNMHandler,
39184 &_swigt__p_wxPaintEvent,
39185 &_swigt__p_wxPaletteChangedEvent,
39186 &_swigt__p_wxPaperSize,
39187 &_swigt__p_wxPlatformInfo,
39188 &_swigt__p_wxPoint,
39189 &_swigt__p_wxPowerEvent,
39190 &_swigt__p_wxProcessEvent,
39191 &_swigt__p_wxPyApp,
39192 &_swigt__p_wxPyArtProvider,
39193 &_swigt__p_wxPyBitmapDataObject,
39194 &_swigt__p_wxPyCommandEvent,
39195 &_swigt__p_wxPyDataObjectSimple,
39196 &_swigt__p_wxPyDropSource,
39197 &_swigt__p_wxPyDropTarget,
39198 &_swigt__p_wxPyEvent,
39199 &_swigt__p_wxPyFileDropTarget,
39200 &_swigt__p_wxPyImageHandler,
39201 &_swigt__p_wxPyLog,
39202 &_swigt__p_wxPyProcess,
39203 &_swigt__p_wxPySizer,
39204 &_swigt__p_wxPyTextDataObject,
39205 &_swigt__p_wxPyTextDropTarget,
39206 &_swigt__p_wxPyTimer,
39207 &_swigt__p_wxPyTipProvider,
39208 &_swigt__p_wxPyValidator,
39209 &_swigt__p_wxQueryNewPaletteEvent,
39210 &_swigt__p_wxRect,
39211 &_swigt__p_wxScrollEvent,
39212 &_swigt__p_wxScrollWinEvent,
39213 &_swigt__p_wxSetCursorEvent,
39214 &_swigt__p_wxShowEvent,
39215 &_swigt__p_wxSingleInstanceChecker,
39216 &_swigt__p_wxSize,
39217 &_swigt__p_wxSizeEvent,
39218 &_swigt__p_wxSizer,
39219 &_swigt__p_wxSizerItem,
39220 &_swigt__p_wxSound,
39221 &_swigt__p_wxStandardPaths,
39222 &_swigt__p_wxStaticBoxSizer,
39223 &_swigt__p_wxStdDialogButtonSizer,
39224 &_swigt__p_wxStopWatch,
39225 &_swigt__p_wxString,
39226 &_swigt__p_wxSysColourChangedEvent,
39227 &_swigt__p_wxSystemOptions,
39228 &_swigt__p_wxSystemSettings,
39229 &_swigt__p_wxTIFFHandler,
39230 &_swigt__p_wxTextCtrl,
39231 &_swigt__p_wxTextDataObject,
39232 &_swigt__p_wxTimeSpan,
39233 &_swigt__p_wxTimer,
39234 &_swigt__p_wxTimerEvent,
39235 &_swigt__p_wxTimerRunner,
39236 &_swigt__p_wxTipProvider,
39237 &_swigt__p_wxToolTip,
39238 &_swigt__p_wxURLDataObject,
39239 &_swigt__p_wxUpdateUIEvent,
39240 &_swigt__p_wxValidator,
39241 &_swigt__p_wxVideoMode,
39242 &_swigt__p_wxWindow,
39243 &_swigt__p_wxWindowCreateEvent,
39244 &_swigt__p_wxWindowDestroyEvent,
39245 &_swigt__p_wxWindowDisabler,
39246 &_swigt__p_wxXPMHandler,
39247 };
39248
39249 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
39250 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
39251 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
39252 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
39253 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
39254 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
39255 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
39256 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
39257 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
39258 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}};
39259 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
39260 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
39261 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
39262 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
39263 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
39264 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
39265 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
39266 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
39267 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}};
39268 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
39269 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
39270 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
39271 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
39272 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
39273 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}};
39274 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
39275 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}};
39276 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
39277 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
39278 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
39279 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
39280 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
39281 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
39282 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
39283 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
39284 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
39285 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
39286 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
39287 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
39288 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
39289 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
39290 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
39291 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
39292 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
39293 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
39294 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
39295 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39296 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39297 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
39298 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39299 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
39300 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
39301 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
39302 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
39303 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
39304 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
39305 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39306 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39307 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39308 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39309 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
39310 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
39311 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
39312 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
39313 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
39314 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
39315 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
39316 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
39317 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
39318 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
39319 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}};
39320 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
39321 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
39322 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
39323 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
39324 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
39325 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
39326 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}};
39327 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
39328 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
39329 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
39330 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
39331 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
39332 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
39333 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
39334 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
39335 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
39336 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
39337 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
39338 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}};
39339 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
39340 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
39341 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
39342 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
39343 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
39344 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
39345 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
39346 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
39347 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
39348 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
39349 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
39350 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
39351 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
39352 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
39353 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
39354 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
39355 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
39356 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
39357 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
39358 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
39359 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
39360 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
39361 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
39362 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
39363 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
39364 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
39365 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
39366 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
39367 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
39368 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
39369 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
39370 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
39371 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
39372 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
39373 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
39374 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
39375 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
39376 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
39377 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
39378 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
39379 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
39380 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
39381 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
39382 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}};
39383 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
39384 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
39385 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
39386 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
39387 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
39388 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
39389 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
39390 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
39391 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
39392 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
39393 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}};
39394 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
39395 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
39396 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
39397 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
39398 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
39399 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
39400 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
39401 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
39402 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
39403 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
39404 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
39405 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
39406 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
39407 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
39408 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
39409 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
39410 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
39411 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}};
39412 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
39413 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
39414 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
39415 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
39416 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}};
39417 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
39418 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
39419 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
39420 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}};
39421 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
39422
39423 static swig_cast_info *swig_cast_initial[] = {
39424 _swigc__p_char,
39425 _swigc__p_form_ops_t,
39426 _swigc__p_int,
39427 _swigc__p_unsigned_char,
39428 _swigc__p_unsigned_int,
39429 _swigc__p_unsigned_long,
39430 _swigc__p_void,
39431 _swigc__p_wxANIHandler,
39432 _swigc__p_wxAcceleratorTable,
39433 _swigc__p_wxActivateEvent,
39434 _swigc__p_wxArrayString,
39435 _swigc__p_wxBMPHandler,
39436 _swigc__p_wxBitmap,
39437 _swigc__p_wxBitmapDataObject,
39438 _swigc__p_wxBoxSizer,
39439 _swigc__p_wxBusyCursor,
39440 _swigc__p_wxBusyInfo,
39441 _swigc__p_wxCURHandler,
39442 _swigc__p_wxCaret,
39443 _swigc__p_wxChar,
39444 _swigc__p_wxChildFocusEvent,
39445 _swigc__p_wxClipboard,
39446 _swigc__p_wxClipboardLocker,
39447 _swigc__p_wxClipboardTextEvent,
39448 _swigc__p_wxCloseEvent,
39449 _swigc__p_wxColour,
39450 _swigc__p_wxCommandEvent,
39451 _swigc__p_wxConfig,
39452 _swigc__p_wxConfigBase,
39453 _swigc__p_wxConfigPathChanger,
39454 _swigc__p_wxContextMenuEvent,
39455 _swigc__p_wxControl,
39456 _swigc__p_wxControlWithItems,
39457 _swigc__p_wxCursor,
39458 _swigc__p_wxCustomDataObject,
39459 _swigc__p_wxDC,
39460 _swigc__p_wxDataFormat,
39461 _swigc__p_wxDataObject,
39462 _swigc__p_wxDataObjectComposite,
39463 _swigc__p_wxDataObjectSimple,
39464 _swigc__p_wxDateEvent,
39465 _swigc__p_wxDateSpan,
39466 _swigc__p_wxDateTime,
39467 _swigc__p_wxDateTime__TimeZone,
39468 _swigc__p_wxDisplay,
39469 _swigc__p_wxDisplayChangedEvent,
39470 _swigc__p_wxDropFilesEvent,
39471 _swigc__p_wxDuplexMode,
39472 _swigc__p_wxEraseEvent,
39473 _swigc__p_wxEvent,
39474 _swigc__p_wxEvtHandler,
39475 _swigc__p_wxFSFile,
39476 _swigc__p_wxFileConfig,
39477 _swigc__p_wxFileDataObject,
39478 _swigc__p_wxFileHistory,
39479 _swigc__p_wxFileSystem,
39480 _swigc__p_wxFileType,
39481 _swigc__p_wxFileTypeInfo,
39482 _swigc__p_wxFlexGridSizer,
39483 _swigc__p_wxFocusEvent,
39484 _swigc__p_wxFont,
39485 _swigc__p_wxFrame,
39486 _swigc__p_wxGBSizerItem,
39487 _swigc__p_wxGIFHandler,
39488 _swigc__p_wxGridBagSizer,
39489 _swigc__p_wxGridSizer,
39490 _swigc__p_wxICOHandler,
39491 _swigc__p_wxIcon,
39492 _swigc__p_wxIconizeEvent,
39493 _swigc__p_wxIdleEvent,
39494 _swigc__p_wxImage,
39495 _swigc__p_wxImageHandler,
39496 _swigc__p_wxIndividualLayoutConstraint,
39497 _swigc__p_wxInitDialogEvent,
39498 _swigc__p_wxJPEGHandler,
39499 _swigc__p_wxJoystick,
39500 _swigc__p_wxJoystickEvent,
39501 _swigc__p_wxKeyEvent,
39502 _swigc__p_wxKillError,
39503 _swigc__p_wxLayoutConstraints,
39504 _swigc__p_wxLog,
39505 _swigc__p_wxLogBuffer,
39506 _swigc__p_wxLogChain,
39507 _swigc__p_wxLogGui,
39508 _swigc__p_wxLogNull,
39509 _swigc__p_wxLogStderr,
39510 _swigc__p_wxLogTextCtrl,
39511 _swigc__p_wxLogWindow,
39512 _swigc__p_wxMaximizeEvent,
39513 _swigc__p_wxMenu,
39514 _swigc__p_wxMenuBar,
39515 _swigc__p_wxMenuEvent,
39516 _swigc__p_wxMenuItem,
39517 _swigc__p_wxMetafile,
39518 _swigc__p_wxMetafileDataObject,
39519 _swigc__p_wxMimeTypesManager,
39520 _swigc__p_wxMouseCaptureChangedEvent,
39521 _swigc__p_wxMouseCaptureLostEvent,
39522 _swigc__p_wxMouseEvent,
39523 _swigc__p_wxMouseState,
39524 _swigc__p_wxMoveEvent,
39525 _swigc__p_wxMutexGuiLocker,
39526 _swigc__p_wxNavigationKeyEvent,
39527 _swigc__p_wxNcPaintEvent,
39528 _swigc__p_wxNotifyEvent,
39529 _swigc__p_wxObject,
39530 _swigc__p_wxOutputStream,
39531 _swigc__p_wxPCXHandler,
39532 _swigc__p_wxPNGHandler,
39533 _swigc__p_wxPNMHandler,
39534 _swigc__p_wxPaintEvent,
39535 _swigc__p_wxPaletteChangedEvent,
39536 _swigc__p_wxPaperSize,
39537 _swigc__p_wxPlatformInfo,
39538 _swigc__p_wxPoint,
39539 _swigc__p_wxPowerEvent,
39540 _swigc__p_wxProcessEvent,
39541 _swigc__p_wxPyApp,
39542 _swigc__p_wxPyArtProvider,
39543 _swigc__p_wxPyBitmapDataObject,
39544 _swigc__p_wxPyCommandEvent,
39545 _swigc__p_wxPyDataObjectSimple,
39546 _swigc__p_wxPyDropSource,
39547 _swigc__p_wxPyDropTarget,
39548 _swigc__p_wxPyEvent,
39549 _swigc__p_wxPyFileDropTarget,
39550 _swigc__p_wxPyImageHandler,
39551 _swigc__p_wxPyLog,
39552 _swigc__p_wxPyProcess,
39553 _swigc__p_wxPySizer,
39554 _swigc__p_wxPyTextDataObject,
39555 _swigc__p_wxPyTextDropTarget,
39556 _swigc__p_wxPyTimer,
39557 _swigc__p_wxPyTipProvider,
39558 _swigc__p_wxPyValidator,
39559 _swigc__p_wxQueryNewPaletteEvent,
39560 _swigc__p_wxRect,
39561 _swigc__p_wxScrollEvent,
39562 _swigc__p_wxScrollWinEvent,
39563 _swigc__p_wxSetCursorEvent,
39564 _swigc__p_wxShowEvent,
39565 _swigc__p_wxSingleInstanceChecker,
39566 _swigc__p_wxSize,
39567 _swigc__p_wxSizeEvent,
39568 _swigc__p_wxSizer,
39569 _swigc__p_wxSizerItem,
39570 _swigc__p_wxSound,
39571 _swigc__p_wxStandardPaths,
39572 _swigc__p_wxStaticBoxSizer,
39573 _swigc__p_wxStdDialogButtonSizer,
39574 _swigc__p_wxStopWatch,
39575 _swigc__p_wxString,
39576 _swigc__p_wxSysColourChangedEvent,
39577 _swigc__p_wxSystemOptions,
39578 _swigc__p_wxSystemSettings,
39579 _swigc__p_wxTIFFHandler,
39580 _swigc__p_wxTextCtrl,
39581 _swigc__p_wxTextDataObject,
39582 _swigc__p_wxTimeSpan,
39583 _swigc__p_wxTimer,
39584 _swigc__p_wxTimerEvent,
39585 _swigc__p_wxTimerRunner,
39586 _swigc__p_wxTipProvider,
39587 _swigc__p_wxToolTip,
39588 _swigc__p_wxURLDataObject,
39589 _swigc__p_wxUpdateUIEvent,
39590 _swigc__p_wxValidator,
39591 _swigc__p_wxVideoMode,
39592 _swigc__p_wxWindow,
39593 _swigc__p_wxWindowCreateEvent,
39594 _swigc__p_wxWindowDestroyEvent,
39595 _swigc__p_wxWindowDisabler,
39596 _swigc__p_wxXPMHandler,
39597 };
39598
39599
39600 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
39601
39602 static swig_const_info swig_const_table[] = {
39603 {0, 0, 0, 0.0, 0, 0}};
39604
39605 #ifdef __cplusplus
39606 }
39607 #endif
39608 /* -----------------------------------------------------------------------------
39609 * Type initialization:
39610 * This problem is tough by the requirement that no dynamic
39611 * memory is used. Also, since swig_type_info structures store pointers to
39612 * swig_cast_info structures and swig_cast_info structures store pointers back
39613 * to swig_type_info structures, we need some lookup code at initialization.
39614 * The idea is that swig generates all the structures that are needed.
39615 * The runtime then collects these partially filled structures.
39616 * The SWIG_InitializeModule function takes these initial arrays out of
39617 * swig_module, and does all the lookup, filling in the swig_module.types
39618 * array with the correct data and linking the correct swig_cast_info
39619 * structures together.
39620 *
39621 * The generated swig_type_info structures are assigned staticly to an initial
39622 * array. We just loop though that array, and handle each type individually.
39623 * First we lookup if this type has been already loaded, and if so, use the
39624 * loaded structure instead of the generated one. Then we have to fill in the
39625 * cast linked list. The cast data is initially stored in something like a
39626 * two-dimensional array. Each row corresponds to a type (there are the same
39627 * number of rows as there are in the swig_type_initial array). Each entry in
39628 * a column is one of the swig_cast_info structures for that type.
39629 * The cast_initial array is actually an array of arrays, because each row has
39630 * a variable number of columns. So to actually build the cast linked list,
39631 * we find the array of casts associated with the type, and loop through it
39632 * adding the casts to the list. The one last trick we need to do is making
39633 * sure the type pointer in the swig_cast_info struct is correct.
39634 *
39635 * First off, we lookup the cast->type name to see if it is already loaded.
39636 * There are three cases to handle:
39637 * 1) If the cast->type has already been loaded AND the type we are adding
39638 * casting info to has not been loaded (it is in this module), THEN we
39639 * replace the cast->type pointer with the type pointer that has already
39640 * been loaded.
39641 * 2) If BOTH types (the one we are adding casting info to, and the
39642 * cast->type) are loaded, THEN the cast info has already been loaded by
39643 * the previous module so we just ignore it.
39644 * 3) Finally, if cast->type has not already been loaded, then we add that
39645 * swig_cast_info to the linked list (because the cast->type) pointer will
39646 * be correct.
39647 * ----------------------------------------------------------------------------- */
39648
39649 #ifdef __cplusplus
39650 extern "C" {
39651 #if 0
39652 } /* c-mode */
39653 #endif
39654 #endif
39655
39656 #if 0
39657 #define SWIGRUNTIME_DEBUG
39658 #endif
39659
39660 SWIGRUNTIME void
39661 SWIG_InitializeModule(void *clientdata) {
39662 size_t i;
39663 swig_module_info *module_head;
39664 static int init_run = 0;
39665
39666 clientdata = clientdata;
39667
39668 if (init_run) return;
39669 init_run = 1;
39670
39671 /* Initialize the swig_module */
39672 swig_module.type_initial = swig_type_initial;
39673 swig_module.cast_initial = swig_cast_initial;
39674
39675 /* Try and load any already created modules */
39676 module_head = SWIG_GetModule(clientdata);
39677 if (module_head) {
39678 swig_module.next = module_head->next;
39679 module_head->next = &swig_module;
39680 } else {
39681 /* This is the first module loaded */
39682 swig_module.next = &swig_module;
39683 SWIG_SetModule(clientdata, &swig_module);
39684 }
39685
39686 /* Now work on filling in swig_module.types */
39687 #ifdef SWIGRUNTIME_DEBUG
39688 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
39689 #endif
39690 for (i = 0; i < swig_module.size; ++i) {
39691 swig_type_info *type = 0;
39692 swig_type_info *ret;
39693 swig_cast_info *cast;
39694
39695 #ifdef SWIGRUNTIME_DEBUG
39696 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39697 #endif
39698
39699 /* if there is another module already loaded */
39700 if (swig_module.next != &swig_module) {
39701 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
39702 }
39703 if (type) {
39704 /* Overwrite clientdata field */
39705 #ifdef SWIGRUNTIME_DEBUG
39706 printf("SWIG_InitializeModule: found type %s\n", type->name);
39707 #endif
39708 if (swig_module.type_initial[i]->clientdata) {
39709 type->clientdata = swig_module.type_initial[i]->clientdata;
39710 #ifdef SWIGRUNTIME_DEBUG
39711 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
39712 #endif
39713 }
39714 } else {
39715 type = swig_module.type_initial[i];
39716 }
39717
39718 /* Insert casting types */
39719 cast = swig_module.cast_initial[i];
39720 while (cast->type) {
39721 /* Don't need to add information already in the list */
39722 ret = 0;
39723 #ifdef SWIGRUNTIME_DEBUG
39724 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
39725 #endif
39726 if (swig_module.next != &swig_module) {
39727 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
39728 #ifdef SWIGRUNTIME_DEBUG
39729 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
39730 #endif
39731 }
39732 if (ret) {
39733 if (type == swig_module.type_initial[i]) {
39734 #ifdef SWIGRUNTIME_DEBUG
39735 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
39736 #endif
39737 cast->type = ret;
39738 ret = 0;
39739 } else {
39740 /* Check for casting already in the list */
39741 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
39742 #ifdef SWIGRUNTIME_DEBUG
39743 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
39744 #endif
39745 if (!ocast) ret = 0;
39746 }
39747 }
39748
39749 if (!ret) {
39750 #ifdef SWIGRUNTIME_DEBUG
39751 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
39752 #endif
39753 if (type->cast) {
39754 type->cast->prev = cast;
39755 cast->next = type->cast;
39756 }
39757 type->cast = cast;
39758 }
39759 cast++;
39760 }
39761 /* Set entry in modules->types array equal to the type */
39762 swig_module.types[i] = type;
39763 }
39764 swig_module.types[i] = 0;
39765
39766 #ifdef SWIGRUNTIME_DEBUG
39767 printf("**** SWIG_InitializeModule: Cast List ******\n");
39768 for (i = 0; i < swig_module.size; ++i) {
39769 int j = 0;
39770 swig_cast_info *cast = swig_module.cast_initial[i];
39771 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39772 while (cast->type) {
39773 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
39774 cast++;
39775 ++j;
39776 }
39777 printf("---- Total casts: %d\n",j);
39778 }
39779 printf("**** SWIG_InitializeModule: Cast List ******\n");
39780 #endif
39781 }
39782
39783 /* This function will propagate the clientdata field of type to
39784 * any new swig_type_info structures that have been added into the list
39785 * of equivalent types. It is like calling
39786 * SWIG_TypeClientData(type, clientdata) a second time.
39787 */
39788 SWIGRUNTIME void
39789 SWIG_PropagateClientData(void) {
39790 size_t i;
39791 swig_cast_info *equiv;
39792 static int init_run = 0;
39793
39794 if (init_run) return;
39795 init_run = 1;
39796
39797 for (i = 0; i < swig_module.size; i++) {
39798 if (swig_module.types[i]->clientdata) {
39799 equiv = swig_module.types[i]->cast;
39800 while (equiv) {
39801 if (!equiv->converter) {
39802 if (equiv->type && !equiv->type->clientdata)
39803 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
39804 }
39805 equiv = equiv->next;
39806 }
39807 }
39808 }
39809 }
39810
39811 #ifdef __cplusplus
39812 #if 0
39813 {
39814 /* c-mode */
39815 #endif
39816 }
39817 #endif
39818
39819
39820
39821 #ifdef __cplusplus
39822 extern "C" {
39823 #endif
39824
39825 /* Python-specific SWIG API */
39826 #define SWIG_newvarlink() SWIG_Python_newvarlink()
39827 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
39828 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
39829
39830 /* -----------------------------------------------------------------------------
39831 * global variable support code.
39832 * ----------------------------------------------------------------------------- */
39833
39834 typedef struct swig_globalvar {
39835 char *name; /* Name of global variable */
39836 PyObject *(*get_attr)(void); /* Return the current value */
39837 int (*set_attr)(PyObject *); /* Set the value */
39838 struct swig_globalvar *next;
39839 } swig_globalvar;
39840
39841 typedef struct swig_varlinkobject {
39842 PyObject_HEAD
39843 swig_globalvar *vars;
39844 } swig_varlinkobject;
39845
39846 SWIGINTERN PyObject *
39847 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
39848 return PyString_FromString("<Swig global variables>");
39849 }
39850
39851 SWIGINTERN PyObject *
39852 swig_varlink_str(swig_varlinkobject *v) {
39853 PyObject *str = PyString_FromString("(");
39854 swig_globalvar *var;
39855 for (var = v->vars; var; var=var->next) {
39856 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
39857 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
39858 }
39859 PyString_ConcatAndDel(&str,PyString_FromString(")"));
39860 return str;
39861 }
39862
39863 SWIGINTERN int
39864 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
39865 PyObject *str = swig_varlink_str(v);
39866 fprintf(fp,"Swig global variables ");
39867 fprintf(fp,"%s\n", PyString_AsString(str));
39868 Py_DECREF(str);
39869 return 0;
39870 }
39871
39872 SWIGINTERN void
39873 swig_varlink_dealloc(swig_varlinkobject *v) {
39874 swig_globalvar *var = v->vars;
39875 while (var) {
39876 swig_globalvar *n = var->next;
39877 free(var->name);
39878 free(var);
39879 var = n;
39880 }
39881 }
39882
39883 SWIGINTERN PyObject *
39884 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
39885 PyObject *res = NULL;
39886 swig_globalvar *var = v->vars;
39887 while (var) {
39888 if (strcmp(var->name,n) == 0) {
39889 res = (*var->get_attr)();
39890 break;
39891 }
39892 var = var->next;
39893 }
39894 if (res == NULL && !PyErr_Occurred()) {
39895 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39896 }
39897 return res;
39898 }
39899
39900 SWIGINTERN int
39901 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
39902 int res = 1;
39903 swig_globalvar *var = v->vars;
39904 while (var) {
39905 if (strcmp(var->name,n) == 0) {
39906 res = (*var->set_attr)(p);
39907 break;
39908 }
39909 var = var->next;
39910 }
39911 if (res == 1 && !PyErr_Occurred()) {
39912 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39913 }
39914 return res;
39915 }
39916
39917 SWIGINTERN PyTypeObject*
39918 swig_varlink_type(void) {
39919 static char varlink__doc__[] = "Swig var link object";
39920 static PyTypeObject varlink_type;
39921 static int type_init = 0;
39922 if (!type_init) {
39923 const PyTypeObject tmp
39924 = {
39925 PyObject_HEAD_INIT(NULL)
39926 0, /* Number of items in variable part (ob_size) */
39927 (char *)"swigvarlink", /* Type name (tp_name) */
39928 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
39929 0, /* Itemsize (tp_itemsize) */
39930 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
39931 (printfunc) swig_varlink_print, /* Print (tp_print) */
39932 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
39933 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
39934 0, /* tp_compare */
39935 (reprfunc) swig_varlink_repr, /* tp_repr */
39936 0, /* tp_as_number */
39937 0, /* tp_as_sequence */
39938 0, /* tp_as_mapping */
39939 0, /* tp_hash */
39940 0, /* tp_call */
39941 (reprfunc)swig_varlink_str, /* tp_str */
39942 0, /* tp_getattro */
39943 0, /* tp_setattro */
39944 0, /* tp_as_buffer */
39945 0, /* tp_flags */
39946 varlink__doc__, /* tp_doc */
39947 0, /* tp_traverse */
39948 0, /* tp_clear */
39949 0, /* tp_richcompare */
39950 0, /* tp_weaklistoffset */
39951 #if PY_VERSION_HEX >= 0x02020000
39952 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
39953 #endif
39954 #if PY_VERSION_HEX >= 0x02030000
39955 0, /* tp_del */
39956 #endif
39957 #ifdef COUNT_ALLOCS
39958 0,0,0,0 /* tp_alloc -> tp_next */
39959 #endif
39960 };
39961 varlink_type = tmp;
39962 varlink_type.ob_type = &PyType_Type;
39963 type_init = 1;
39964 }
39965 return &varlink_type;
39966 }
39967
39968 /* Create a variable linking object for use later */
39969 SWIGINTERN PyObject *
39970 SWIG_Python_newvarlink(void) {
39971 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
39972 if (result) {
39973 result->vars = 0;
39974 }
39975 return ((PyObject*) result);
39976 }
39977
39978 SWIGINTERN void
39979 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
39980 swig_varlinkobject *v = (swig_varlinkobject *) p;
39981 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
39982 if (gv) {
39983 size_t size = strlen(name)+1;
39984 gv->name = (char *)malloc(size);
39985 if (gv->name) {
39986 strncpy(gv->name,name,size);
39987 gv->get_attr = get_attr;
39988 gv->set_attr = set_attr;
39989 gv->next = v->vars;
39990 }
39991 }
39992 v->vars = gv;
39993 }
39994
39995 SWIGINTERN PyObject *
39996 SWIG_globals() {
39997 static PyObject *_SWIG_globals = 0;
39998 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
39999 return _SWIG_globals;
40000 }
40001
40002 /* -----------------------------------------------------------------------------
40003 * constants/methods manipulation
40004 * ----------------------------------------------------------------------------- */
40005
40006 /* Install Constants */
40007 SWIGINTERN void
40008 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
40009 PyObject *obj = 0;
40010 size_t i;
40011 for (i = 0; constants[i].type; ++i) {
40012 switch(constants[i].type) {
40013 case SWIG_PY_POINTER:
40014 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
40015 break;
40016 case SWIG_PY_BINARY:
40017 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
40018 break;
40019 default:
40020 obj = 0;
40021 break;
40022 }
40023 if (obj) {
40024 PyDict_SetItemString(d, constants[i].name, obj);
40025 Py_DECREF(obj);
40026 }
40027 }
40028 }
40029
40030 /* -----------------------------------------------------------------------------*/
40031 /* Fix SwigMethods to carry the callback ptrs when needed */
40032 /* -----------------------------------------------------------------------------*/
40033
40034 SWIGINTERN void
40035 SWIG_Python_FixMethods(PyMethodDef *methods,
40036 swig_const_info *const_table,
40037 swig_type_info **types,
40038 swig_type_info **types_initial) {
40039 size_t i;
40040 for (i = 0; methods[i].ml_name; ++i) {
40041 const char *c = methods[i].ml_doc;
40042 if (c && (c = strstr(c, "swig_ptr: "))) {
40043 int j;
40044 swig_const_info *ci = 0;
40045 const char *name = c + 10;
40046 for (j = 0; const_table[j].type; ++j) {
40047 if (strncmp(const_table[j].name, name,
40048 strlen(const_table[j].name)) == 0) {
40049 ci = &(const_table[j]);
40050 break;
40051 }
40052 }
40053 if (ci) {
40054 size_t shift = (ci->ptype) - types;
40055 swig_type_info *ty = types_initial[shift];
40056 size_t ldoc = (c - methods[i].ml_doc);
40057 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
40058 char *ndoc = (char*)malloc(ldoc + lptr + 10);
40059 if (ndoc) {
40060 char *buff = ndoc;
40061 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
40062 if (ptr) {
40063 strncpy(buff, methods[i].ml_doc, ldoc);
40064 buff += ldoc;
40065 strncpy(buff, "swig_ptr: ", 10);
40066 buff += 10;
40067 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
40068 methods[i].ml_doc = ndoc;
40069 }
40070 }
40071 }
40072 }
40073 }
40074 }
40075
40076 #ifdef __cplusplus
40077 }
40078 #endif
40079
40080 /* -----------------------------------------------------------------------------*
40081 * Partial Init method
40082 * -----------------------------------------------------------------------------*/
40083
40084 #ifdef __cplusplus
40085 extern "C"
40086 #endif
40087 SWIGEXPORT void SWIG_init(void) {
40088 PyObject *m, *d;
40089
40090 /* Fix SwigMethods to carry the callback ptrs when needed */
40091 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
40092
40093 m = Py_InitModule((char *) SWIG_name, SwigMethods);
40094 d = PyModule_GetDict(m);
40095
40096 SWIG_InitializeModule(0);
40097 SWIG_InstallConstants(d,swig_const_table);
40098
40099
40100 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
40101 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
40102 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
40103 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
40104 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
40105 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
40106 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
40107 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
40108 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
40109 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
40110 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
40111 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
40112 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
40113 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
40114 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
40115 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
40116 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
40117 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
40118 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
40119 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
40120 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
40121 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
40122 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
40123 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
40124 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
40125 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
40126 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
40127 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
40128 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
40129 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
40130 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
40131 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
40132 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
40133 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
40134 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
40135 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
40136 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
40137 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
40138 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
40139 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
40140 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
40141 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
40142 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
40143 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
40144 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
40145 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
40146 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
40147 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
40148 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
40149 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
40150 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
40151 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
40152 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
40153 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
40154 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
40155 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
40156 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
40157 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
40158 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
40159 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
40160 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
40161 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
40162 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
40163 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
40164 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
40165 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
40166 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
40167 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
40168 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
40169 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
40170 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
40171 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
40172 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
40173 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
40174 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
40175 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
40176 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
40177 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
40178 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
40179 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
40180 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
40181 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
40182 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
40183 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
40184 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
40185 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
40186 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
40187 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
40188 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
40189 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
40190 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
40191 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
40192 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
40193 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
40194 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
40195 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
40196 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
40197 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
40198 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
40199 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
40200 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
40201 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
40202 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
40203 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
40204 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
40205 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
40206 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
40207 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
40208 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
40209 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
40210 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
40211 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
40212 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
40213 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
40214 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
40215 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
40216 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
40217 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
40218 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
40219 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
40220 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
40221 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
40222 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
40223 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
40224 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
40225 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
40226 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
40227 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
40228 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
40229 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
40230 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
40231 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
40232 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
40233 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
40234 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
40235 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
40236 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
40237 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
40238 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
40239 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
40240 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
40241 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
40242 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
40243 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
40244 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
40245 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
40246 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
40247 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
40248
40249 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
40250
40251 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
40252 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
40253 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
40254 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
40255 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
40256 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
40257 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
40258 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
40259 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
40260 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
40261 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
40262 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
40263 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
40264 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
40265 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
40266 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
40267 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
40268 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
40269 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
40270 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
40271 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
40272 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
40273 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
40274 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
40275 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
40276 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
40277 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
40278 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
40279 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
40280 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
40281 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
40282 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
40283 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
40284 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
40285 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
40286 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
40287 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
40288 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
40289 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
40290 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
40291 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
40292 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
40293 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
40294 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
40295 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
40296 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
40297 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
40298 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
40299 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
40300 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
40301 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
40302 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
40303 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
40304
40305 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
40306
40307 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
40308 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
40309 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
40310 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
40311 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
40312 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
40313 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
40314 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
40315 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
40316 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
40317 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
40318 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
40319 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
40320 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
40321 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
40322 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
40323 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
40324 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
40325 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
40326 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
40327 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
40328 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
40329 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
40330 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
40331 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
40332 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
40333 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
40334 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
40335 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
40336 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
40337 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
40338 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
40339 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
40340 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
40341 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
40342 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
40343 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
40344 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
40345 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
40346 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
40347 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
40348 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
40349 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
40350 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
40351 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
40352 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
40353 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
40354 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
40355 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
40356 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
40357 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
40358 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
40359 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
40360 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
40361 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
40362 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
40363 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
40364 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
40365 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
40366 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
40367 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
40368 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
40369 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
40370 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
40371 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
40372 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
40373 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
40374 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
40375 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
40376 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
40377 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
40378 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
40379 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
40380 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
40381 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
40382 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
40383
40384 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
40385
40386 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
40387 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
40388 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
40389 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
40390 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
40391 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
40392 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
40393 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
40394 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
40395 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
40396 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
40397 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
40398 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
40399 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
40400 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
40401 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
40402 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
40403 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
40404 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
40405 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
40406 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
40407 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
40408 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
40409 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
40410 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
40411 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
40412 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
40413 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
40414 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
40415 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
40416 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
40417 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
40418 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
40419 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
40420 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
40421 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
40422 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
40423 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
40424 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
40425 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
40426 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
40427 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
40428 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
40429 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
40430 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
40431 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
40432 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
40433 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
40434 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
40435 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
40436 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
40437 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
40438 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
40439 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
40440 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
40441 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
40442 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
40443 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
40444 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
40445 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
40446 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
40447 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
40448 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
40449 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
40450 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
40451 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
40452 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
40453 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
40454 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
40455 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
40456 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
40457 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
40458 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
40459 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
40460 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
40461 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
40462 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
40463 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
40464 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
40465 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
40466 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
40467 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
40468 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
40469 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
40470 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
40471 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
40472 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
40473 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
40474 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
40475 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
40476 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
40477 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
40478 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
40479 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
40480 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
40481 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
40482 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
40483 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
40484 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
40485 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
40486 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
40487 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
40488 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
40489 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
40490 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
40491 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
40492 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
40493 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
40494 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
40495 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
40496 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
40497 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
40498 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
40499 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
40500 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
40501 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
40502 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
40503 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
40504 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
40505 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
40506 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
40507 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
40508 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
40509 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
40510 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
40511 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
40512 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
40513 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
40514 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
40515 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
40516 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
40517 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
40518 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
40519 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
40520 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
40521 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
40522 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
40523 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
40524 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
40525 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
40526 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
40527 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
40528 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
40529 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
40530 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
40531 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
40532 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
40533 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
40534 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
40535 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
40536 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
40537 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
40538 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
40539 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
40540 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
40541 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
40542 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
40543 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
40544 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
40545 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
40546 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
40547 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
40548 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
40549 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
40550 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
40551 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
40552 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
40553 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
40554 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
40555 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
40556 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
40557 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
40558 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
40559 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
40560 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
40561 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
40562 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
40563 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
40564 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
40565 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
40566 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
40567 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
40568 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
40569 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
40570 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
40571 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
40572 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
40573 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
40574 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
40575 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
40576 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
40577 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
40578 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
40579 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
40580 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
40581 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
40582 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
40583 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
40584 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
40585 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
40586
40587 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
40588 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
40589 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
40590 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
40591
40592 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
40593 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
40594 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
40595 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
40596 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
40597 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
40598 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
40599 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
40600 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
40601 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
40602 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
40603 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
40604 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
40605 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
40606 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
40607 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
40608 }
40609
wxWidgets (Impactor)