]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
RemoveItem should return the same object it is passed, but adjusted
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAboutDialogInfo swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorTable swig_types[9]
2476 #define SWIGTYPE_p_wxActivateEvent swig_types[10]
2477 #define SWIGTYPE_p_wxArrayString swig_types[11]
2478 #define SWIGTYPE_p_wxBMPHandler swig_types[12]
2479 #define SWIGTYPE_p_wxBitmap swig_types[13]
2480 #define SWIGTYPE_p_wxBitmapDataObject swig_types[14]
2481 #define SWIGTYPE_p_wxBoxSizer swig_types[15]
2482 #define SWIGTYPE_p_wxBusyCursor swig_types[16]
2483 #define SWIGTYPE_p_wxBusyInfo swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChar swig_types[20]
2487 #define SWIGTYPE_p_wxChildFocusEvent swig_types[21]
2488 #define SWIGTYPE_p_wxClipboard swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
2490 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[24]
2491 #define SWIGTYPE_p_wxCloseEvent swig_types[25]
2492 #define SWIGTYPE_p_wxColour swig_types[26]
2493 #define SWIGTYPE_p_wxCommandEvent swig_types[27]
2494 #define SWIGTYPE_p_wxConfig swig_types[28]
2495 #define SWIGTYPE_p_wxConfigBase swig_types[29]
2496 #define SWIGTYPE_p_wxConfigPathChanger swig_types[30]
2497 #define SWIGTYPE_p_wxContextMenuEvent swig_types[31]
2498 #define SWIGTYPE_p_wxControl swig_types[32]
2499 #define SWIGTYPE_p_wxControlWithItems swig_types[33]
2500 #define SWIGTYPE_p_wxCursor swig_types[34]
2501 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
2502 #define SWIGTYPE_p_wxDC swig_types[36]
2503 #define SWIGTYPE_p_wxDataFormat swig_types[37]
2504 #define SWIGTYPE_p_wxDataObject swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectComposite swig_types[39]
2506 #define SWIGTYPE_p_wxDataObjectSimple swig_types[40]
2507 #define SWIGTYPE_p_wxDateEvent swig_types[41]
2508 #define SWIGTYPE_p_wxDateSpan swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime swig_types[43]
2510 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[44]
2511 #define SWIGTYPE_p_wxDisplay swig_types[45]
2512 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDropFilesEvent swig_types[47]
2514 #define SWIGTYPE_p_wxDuplexMode swig_types[48]
2515 #define SWIGTYPE_p_wxEraseEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvent swig_types[50]
2517 #define SWIGTYPE_p_wxEvtHandler swig_types[51]
2518 #define SWIGTYPE_p_wxFSFile swig_types[52]
2519 #define SWIGTYPE_p_wxFileConfig swig_types[53]
2520 #define SWIGTYPE_p_wxFileDataObject swig_types[54]
2521 #define SWIGTYPE_p_wxFileHistory swig_types[55]
2522 #define SWIGTYPE_p_wxFileSystem swig_types[56]
2523 #define SWIGTYPE_p_wxFileType swig_types[57]
2524 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
2525 #define SWIGTYPE_p_wxFlexGridSizer swig_types[59]
2526 #define SWIGTYPE_p_wxFocusEvent swig_types[60]
2527 #define SWIGTYPE_p_wxFont swig_types[61]
2528 #define SWIGTYPE_p_wxFrame swig_types[62]
2529 #define SWIGTYPE_p_wxGBSizerItem swig_types[63]
2530 #define SWIGTYPE_p_wxGIFHandler swig_types[64]
2531 #define SWIGTYPE_p_wxGridBagSizer swig_types[65]
2532 #define SWIGTYPE_p_wxGridSizer swig_types[66]
2533 #define SWIGTYPE_p_wxICOHandler swig_types[67]
2534 #define SWIGTYPE_p_wxIcon swig_types[68]
2535 #define SWIGTYPE_p_wxIconizeEvent swig_types[69]
2536 #define SWIGTYPE_p_wxIdleEvent swig_types[70]
2537 #define SWIGTYPE_p_wxImage swig_types[71]
2538 #define SWIGTYPE_p_wxImageHandler swig_types[72]
2539 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[73]
2540 #define SWIGTYPE_p_wxInitDialogEvent swig_types[74]
2541 #define SWIGTYPE_p_wxJPEGHandler swig_types[75]
2542 #define SWIGTYPE_p_wxJoystick swig_types[76]
2543 #define SWIGTYPE_p_wxJoystickEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKeyEvent swig_types[78]
2545 #define SWIGTYPE_p_wxKillError swig_types[79]
2546 #define SWIGTYPE_p_wxLayoutConstraints swig_types[80]
2547 #define SWIGTYPE_p_wxLog swig_types[81]
2548 #define SWIGTYPE_p_wxLogBuffer swig_types[82]
2549 #define SWIGTYPE_p_wxLogChain swig_types[83]
2550 #define SWIGTYPE_p_wxLogGui swig_types[84]
2551 #define SWIGTYPE_p_wxLogNull swig_types[85]
2552 #define SWIGTYPE_p_wxLogStderr swig_types[86]
2553 #define SWIGTYPE_p_wxLogTextCtrl swig_types[87]
2554 #define SWIGTYPE_p_wxLogWindow swig_types[88]
2555 #define SWIGTYPE_p_wxMaximizeEvent swig_types[89]
2556 #define SWIGTYPE_p_wxMenu swig_types[90]
2557 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2558 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2559 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2560 #define SWIGTYPE_p_wxMetafile swig_types[94]
2561 #define SWIGTYPE_p_wxMetafileDataObject swig_types[95]
2562 #define SWIGTYPE_p_wxMimeTypesManager swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMouseState swig_types[100]
2567 #define SWIGTYPE_p_wxMoveEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[102]
2569 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNcPaintEvent swig_types[104]
2571 #define SWIGTYPE_p_wxNotifyEvent swig_types[105]
2572 #define SWIGTYPE_p_wxObject swig_types[106]
2573 #define SWIGTYPE_p_wxOutputStream swig_types[107]
2574 #define SWIGTYPE_p_wxPCXHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNGHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPNMHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPaintEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[112]
2579 #define SWIGTYPE_p_wxPaperSize swig_types[113]
2580 #define SWIGTYPE_p_wxPlatformInfo swig_types[114]
2581 #define SWIGTYPE_p_wxPoint swig_types[115]
2582 #define SWIGTYPE_p_wxPowerEvent swig_types[116]
2583 #define SWIGTYPE_p_wxProcessEvent swig_types[117]
2584 #define SWIGTYPE_p_wxPyApp swig_types[118]
2585 #define SWIGTYPE_p_wxPyArtProvider swig_types[119]
2586 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[120]
2587 #define SWIGTYPE_p_wxPyCommandEvent swig_types[121]
2588 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropSource swig_types[123]
2590 #define SWIGTYPE_p_wxPyDropTarget swig_types[124]
2591 #define SWIGTYPE_p_wxPyEvent swig_types[125]
2592 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[126]
2593 #define SWIGTYPE_p_wxPyImageHandler swig_types[127]
2594 #define SWIGTYPE_p_wxPyLog swig_types[128]
2595 #define SWIGTYPE_p_wxPyProcess swig_types[129]
2596 #define SWIGTYPE_p_wxPySizer swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDataObject swig_types[131]
2598 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[132]
2599 #define SWIGTYPE_p_wxPyTimer swig_types[133]
2600 #define SWIGTYPE_p_wxPyTipProvider swig_types[134]
2601 #define SWIGTYPE_p_wxPyValidator swig_types[135]
2602 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[136]
2603 #define SWIGTYPE_p_wxRect swig_types[137]
2604 #define SWIGTYPE_p_wxScrollEvent swig_types[138]
2605 #define SWIGTYPE_p_wxScrollWinEvent swig_types[139]
2606 #define SWIGTYPE_p_wxSetCursorEvent swig_types[140]
2607 #define SWIGTYPE_p_wxShowEvent swig_types[141]
2608 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[142]
2609 #define SWIGTYPE_p_wxSize swig_types[143]
2610 #define SWIGTYPE_p_wxSizeEvent swig_types[144]
2611 #define SWIGTYPE_p_wxSizer swig_types[145]
2612 #define SWIGTYPE_p_wxSizerItem swig_types[146]
2613 #define SWIGTYPE_p_wxSound swig_types[147]
2614 #define SWIGTYPE_p_wxStandardPaths swig_types[148]
2615 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[150]
2617 #define SWIGTYPE_p_wxStopWatch swig_types[151]
2618 #define SWIGTYPE_p_wxString swig_types[152]
2619 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[153]
2620 #define SWIGTYPE_p_wxSystemOptions swig_types[154]
2621 #define SWIGTYPE_p_wxSystemSettings swig_types[155]
2622 #define SWIGTYPE_p_wxTGAHandler swig_types[156]
2623 #define SWIGTYPE_p_wxTIFFHandler swig_types[157]
2624 #define SWIGTYPE_p_wxTextCtrl swig_types[158]
2625 #define SWIGTYPE_p_wxTextDataObject swig_types[159]
2626 #define SWIGTYPE_p_wxTimeSpan swig_types[160]
2627 #define SWIGTYPE_p_wxTimer swig_types[161]
2628 #define SWIGTYPE_p_wxTimerEvent swig_types[162]
2629 #define SWIGTYPE_p_wxTimerRunner swig_types[163]
2630 #define SWIGTYPE_p_wxTipProvider swig_types[164]
2631 #define SWIGTYPE_p_wxToolTip swig_types[165]
2632 #define SWIGTYPE_p_wxURLDataObject swig_types[166]
2633 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[167]
2634 #define SWIGTYPE_p_wxValidator swig_types[168]
2635 #define SWIGTYPE_p_wxVideoMode swig_types[169]
2636 #define SWIGTYPE_p_wxWindow swig_types[170]
2637 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[171]
2638 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[172]
2639 #define SWIGTYPE_p_wxWindowDisabler swig_types[173]
2640 #define SWIGTYPE_p_wxXPMHandler swig_types[174]
2641 static swig_type_info *swig_types[176];
2642 static swig_module_info swig_module = {swig_types, 175, 0, 0, 0, 0};
2643 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2644 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2645
2646 /* -------- TYPES TABLE (END) -------- */
2647
2648 #if (PY_VERSION_HEX <= 0x02000000)
2649 # if !defined(SWIG_PYTHON_CLASSIC)
2650 # error "This python version requires to use swig with the '-classic' option"
2651 # endif
2652 #endif
2653 #if (PY_VERSION_HEX <= 0x02020000)
2654 # error "This python version requires to use swig with the '-nomodern' option"
2655 #endif
2656 #if (PY_VERSION_HEX <= 0x02020000)
2657 # error "This python version requires to use swig with the '-nomodernargs' option"
2658 #endif
2659 #ifndef METH_O
2660 # error "This python version requires to use swig with the '-nofastunpack' option"
2661 #endif
2662
2663 /*-----------------------------------------------
2664 @(target):= _misc_.so
2665 ------------------------------------------------*/
2666 #define SWIG_init init_misc_
2667
2668 #define SWIG_name "_misc_"
2669
2670 #define SWIGVERSION 0x010329
2671
2672
2673 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2674 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2675
2676
2677 #include <stdexcept>
2678
2679
2680 namespace swig {
2681 class PyObject_ptr {
2682 protected:
2683 PyObject *_obj;
2684
2685 public:
2686 PyObject_ptr() :_obj(0)
2687 {
2688 }
2689
2690 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2691 {
2692 Py_XINCREF(_obj);
2693 }
2694
2695 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2696 {
2697 if (initial_ref) Py_XINCREF(_obj);
2698 }
2699
2700 PyObject_ptr & operator=(const PyObject_ptr& item)
2701 {
2702 Py_XINCREF(item._obj);
2703 Py_XDECREF(_obj);
2704 _obj = item._obj;
2705 return *this;
2706 }
2707
2708 ~PyObject_ptr()
2709 {
2710 Py_XDECREF(_obj);
2711 }
2712
2713 operator PyObject *() const
2714 {
2715 return _obj;
2716 }
2717
2718 PyObject *operator->() const
2719 {
2720 return _obj;
2721 }
2722 };
2723 }
2724
2725
2726 namespace swig {
2727 struct PyObject_var : PyObject_ptr {
2728 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2729
2730 PyObject_var & operator = (PyObject* obj)
2731 {
2732 Py_XDECREF(_obj);
2733 _obj = obj;
2734 return *this;
2735 }
2736 };
2737 }
2738
2739
2740 #include "wx/wxPython/wxPython.h"
2741 #include "wx/wxPython/pyclasses.h"
2742 #include "wx/wxPython/pyistream.h"
2743
2744 static const wxString wxPyEmptyString(wxEmptyString);
2745
2746
2747
2748 #define SWIG_From_long PyInt_FromLong
2749
2750
2751 SWIGINTERNINLINE PyObject *
2752 SWIG_From_int (int value)
2753 {
2754 return SWIG_From_long (value);
2755 }
2756
2757
2758 #include <limits.h>
2759 #ifndef LLONG_MIN
2760 # define LLONG_MIN LONG_LONG_MIN
2761 #endif
2762 #ifndef LLONG_MAX
2763 # define LLONG_MAX LONG_LONG_MAX
2764 #endif
2765 #ifndef ULLONG_MAX
2766 # define ULLONG_MAX ULONG_LONG_MAX
2767 #endif
2768
2769
2770 SWIGINTERN int
2771 SWIG_AsVal_long (PyObject* obj, long* val)
2772 {
2773 if (PyNumber_Check(obj)) {
2774 if (val) *val = PyInt_AsLong(obj);
2775 return SWIG_OK;
2776 }
2777 return SWIG_TypeError;
2778 }
2779
2780
2781 SWIGINTERN int
2782 SWIG_AsVal_int (PyObject * obj, int *val)
2783 {
2784 long v;
2785 int res = SWIG_AsVal_long (obj, &v);
2786 if (SWIG_IsOK(res)) {
2787 if ((v < INT_MIN || v > INT_MAX)) {
2788 return SWIG_OverflowError;
2789 } else {
2790 if (val) *val = static_cast< int >(v);
2791 }
2792 }
2793 return res;
2794 }
2795
2796 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2797
2798 #include <wx/stockitem.h>
2799
2800 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2801 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2802 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2803
2804 SWIGINTERN int
2805 SWIG_AsVal_bool (PyObject *obj, bool *val)
2806 {
2807 if (obj == Py_True) {
2808 if (val) *val = true;
2809 return SWIG_OK;
2810 } else if (obj == Py_False) {
2811 if (val) *val = false;
2812 return SWIG_OK;
2813 } else {
2814 long v = 0;
2815 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2816 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2817 return res;
2818 }
2819 }
2820
2821
2822 SWIGINTERN int
2823 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2824 {
2825 long v = 0;
2826 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2827 return SWIG_TypeError;
2828 }
2829 else if (val)
2830 *val = (unsigned long)v;
2831 return SWIG_OK;
2832 }
2833
2834
2835 SWIGINTERNINLINE PyObject*
2836 SWIG_From_unsigned_SS_long (unsigned long value)
2837 {
2838 return (value > LONG_MAX) ?
2839 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2840 }
2841
2842
2843 void* wxGetXDisplay()
2844 {
2845 #ifdef __WXGTK__
2846 return wxGetDisplay();
2847 #else
2848 return NULL;
2849 #endif
2850 }
2851
2852
2853 wxWindow* FindWindowAtPointer() {
2854 wxPoint unused;
2855 return wxFindWindowAtPointer(unused);
2856 }
2857
2858
2859 bool wxThread_IsMain() {
2860 #ifdef WXP_WITH_THREAD
2861 return wxThread::IsMain();
2862 #else
2863 return true;
2864 #endif
2865 }
2866
2867 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2868 delete self;
2869 }
2870
2871 #include <wx/snglinst.h>
2872
2873
2874 #ifdef __WXMSW__
2875 #include <wx/msw/private.h>
2876 #include <wx/dynload.h>
2877 #endif
2878
2879
2880
2881 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2882 #if 0
2883 , int method
2884 #endif
2885 )
2886 {
2887 #ifdef __WXMSW__
2888 #if 0
2889 switch (method)
2890 {
2891 case 1:
2892 // This one only partially works. Appears to be an undocumented
2893 // "standard" convention that not all widgets adhear to. For
2894 // example, for some widgets backgrounds or non-client areas may
2895 // not be painted.
2896 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2897 break;
2898
2899 case 2:
2900 #endif
2901 // This one works much better, nearly all widgets and their
2902 // children are captured correctly[**]. Prior to the big
2903 // background erase changes that Vadim did in 2004-2005 this
2904 // method failed badly on XP with Themes activated, most native
2905 // widgets draw only partially, if at all. Without themes it
2906 // worked just like on Win2k. After those changes this method
2907 // works very well.
2908 //
2909 // ** For example the radio buttons in a wxRadioBox are not its
2910 // children by default, but you can capture it via the panel
2911 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2912 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2913 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2914 PRF_ERASEBKGND | PRF_OWNED );
2915 return true;
2916 #if 0
2917 break;
2918
2919 case 3:
2920 // This one is only defined in the latest SDK and is only
2921 // available on XP. MSDN says it is similar to sending WM_PRINT
2922 // so I expect that it will work similar to the above. Since it
2923 // is avaialble only on XP, it can't be compiled like this and
2924 // will have to be loaded dynamically.
2925 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2926
2927 // fall through
2928
2929 case 4:
2930 // Use PrintWindow if available, or fallback to WM_PRINT
2931 // otherwise. Unfortunately using PrintWindow is even worse than
2932 // WM_PRINT. For most native widgets nothing is drawn to the dc
2933 // at all, with or without Themes.
2934 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2935 static bool s_triedToLoad = false;
2936 static PrintWindow_t pfnPrintWindow = NULL;
2937 if ( !s_triedToLoad )
2938 {
2939
2940 s_triedToLoad = true;
2941 wxDynamicLibrary dllUser32(_T("user32.dll"));
2942 if ( dllUser32.IsLoaded() )
2943 {
2944 wxLogNull nolog; // Don't report errors here
2945 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2946 }
2947 }
2948 if (pfnPrintWindow)
2949 {
2950 //printf("Using PrintWindow\n");
2951 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2952 }
2953 else
2954 {
2955 //printf("Using WM_PRINT\n");
2956 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2957 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2958 PRF_ERASEBKGND | PRF_OWNED );
2959 }
2960 }
2961 #endif // 0
2962 #else
2963 return false;
2964 #endif // __WXMSW__
2965 }
2966
2967
2968
2969 #include <wx/tipdlg.h>
2970
2971
2972 SWIGINTERNINLINE PyObject *
2973 SWIG_From_size_t (size_t value)
2974 {
2975 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2976 }
2977
2978
2979 class wxPyTipProvider : public wxTipProvider {
2980 public:
2981 wxPyTipProvider(size_t currentTip)
2982 : wxTipProvider(currentTip) {}
2983
2984 DEC_PYCALLBACK_STRING__pure(GetTip);
2985 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2986 PYPRIVATE;
2987 };
2988
2989 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2990 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2991
2992
2993 SWIGINTERNINLINE int
2994 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2995 {
2996 unsigned long v;
2997 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2998 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2999 return res;
3000 }
3001
3002
3003 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3004
3005 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3006
3007 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3008 : wxTimer(owner, id)
3009 {
3010 if (owner == NULL)
3011 SetOwner(this);
3012 }
3013
3014 wxPyTimer::~wxPyTimer()
3015 {
3016 // printf("-=* ~wxPyTimer\n");
3017 }
3018
3019
3020
3021 SWIGINTERN swig_type_info*
3022 SWIG_pchar_descriptor()
3023 {
3024 static int init = 0;
3025 static swig_type_info* info = 0;
3026 if (!init) {
3027 info = SWIG_TypeQuery("_p_char");
3028 init = 1;
3029 }
3030 return info;
3031 }
3032
3033
3034 SWIGINTERNINLINE PyObject *
3035 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3036 {
3037 if (carray) {
3038 if (size > INT_MAX) {
3039 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3040 return pchar_descriptor ?
3041 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3042 } else {
3043 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3044 }
3045 } else {
3046 return SWIG_Py_Void();
3047 }
3048 }
3049
3050
3051 SWIGINTERNINLINE PyObject *
3052 SWIG_FromCharPtr(const char *cptr)
3053 {
3054 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3055 }
3056
3057
3058 SWIGINTERN int
3059 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3060 {
3061 unsigned long v;
3062 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3063 if (SWIG_IsOK(res)) {
3064 if ((v > UINT_MAX)) {
3065 return SWIG_OverflowError;
3066 } else {
3067 if (val) *val = static_cast< unsigned int >(v);
3068 }
3069 }
3070 return res;
3071 }
3072
3073 SWIGINTERN wxString wxLog_TimeStamp(){
3074 wxString msg;
3075 wxLog::TimeStamp(&msg);
3076 return msg;
3077 }
3078 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3079 // Make some wrappers that double any % signs so they are 'escaped'
3080 void wxPyLogFatalError(const wxString& msg)
3081 {
3082 wxString m(msg);
3083 m.Replace(wxT("%"), wxT("%%"));
3084 wxLogFatalError(m);
3085 }
3086
3087 void wxPyLogError(const wxString& msg)
3088 {
3089 wxString m(msg);
3090 m.Replace(wxT("%"), wxT("%%"));
3091 wxLogError(m);
3092 }
3093
3094 void wxPyLogWarning(const wxString& msg)
3095 {
3096 wxString m(msg);
3097 m.Replace(wxT("%"), wxT("%%"));
3098 wxLogWarning(m);
3099 }
3100
3101 void wxPyLogMessage(const wxString& msg)
3102 {
3103 wxString m(msg);
3104 m.Replace(wxT("%"), wxT("%%"));
3105 wxLogMessage(m);
3106 }
3107
3108 void wxPyLogInfo(const wxString& msg)
3109 {
3110 wxString m(msg);
3111 m.Replace(wxT("%"), wxT("%%"));
3112 wxLogInfo(m);
3113 }
3114
3115 void wxPyLogDebug(const wxString& msg)
3116 {
3117 wxString m(msg);
3118 m.Replace(wxT("%"), wxT("%%"));
3119 wxLogDebug(m);
3120 }
3121
3122 void wxPyLogVerbose(const wxString& msg)
3123 {
3124 wxString m(msg);
3125 m.Replace(wxT("%"), wxT("%%"));
3126 wxLogVerbose(m);
3127 }
3128
3129 void wxPyLogStatus(const wxString& msg)
3130 {
3131 wxString m(msg);
3132 m.Replace(wxT("%"), wxT("%%"));
3133 wxLogStatus(m);
3134 }
3135
3136 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3137 {
3138 wxString m(msg);
3139 m.Replace(wxT("%"), wxT("%%"));
3140 wxLogStatus(pFrame, m);
3141 }
3142
3143 void wxPyLogSysError(const wxString& msg)
3144 {
3145 wxString m(msg);
3146 m.Replace(wxT("%"), wxT("%%"));
3147 wxLogSysError(m);
3148 }
3149
3150 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3151 {
3152 wxString m(msg);
3153 m.Replace(wxT("%"), wxT("%%"));
3154 wxLogGeneric(level, m);
3155 }
3156
3157 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3158 {
3159 wxString m(msg);
3160 m.Replace(wxT("%"), wxT("%%"));
3161 wxLogTrace(mask, m);
3162 }
3163
3164 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3165 {
3166 wxString m(msg);
3167 m.Replace(wxT("%"), wxT("%%"));
3168 wxLogTrace(mask, m);
3169 }
3170
3171
3172
3173 // A wxLog class that can be derived from in wxPython
3174 class wxPyLog : public wxLog {
3175 public:
3176 wxPyLog() : wxLog() {}
3177
3178 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3179 bool found;
3180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3181 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3182 PyObject* s = wx2PyString(szString);
3183 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3184 Py_DECREF(s);
3185 }
3186 wxPyEndBlockThreads(blocked);
3187 if (! found)
3188 wxLog::DoLog(level, szString, t);
3189 }
3190
3191 virtual void DoLogString(const wxChar *szString, time_t t) {
3192 bool found;
3193 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3194 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3195 PyObject* s = wx2PyString(szString);
3196 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3197 Py_DECREF(s);
3198 }
3199 wxPyEndBlockThreads(blocked);
3200 if (! found)
3201 wxLog::DoLogString(szString, t);
3202 }
3203
3204 DEC_PYCALLBACK_VOID_(Flush);
3205 PYPRIVATE;
3206 };
3207 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3208
3209
3210
3211
3212 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3213
3214
3215 #include <wx/joystick.h>
3216
3217
3218 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3219 // A C++ stub class for wxJoystick for platforms that don't have it.
3220 class wxJoystick : public wxObject {
3221 public:
3222 wxJoystick(int joystick = wxJOYSTICK1) {
3223 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3224 PyErr_SetString(PyExc_NotImplementedError,
3225 "wxJoystick is not available on this platform.");
3226 wxPyEndBlockThreads(blocked);
3227 }
3228 wxPoint GetPosition() { return wxPoint(-1,-1); }
3229 int GetZPosition() { return -1; }
3230 int GetButtonState() { return -1; }
3231 int GetPOVPosition() { return -1; }
3232 int GetPOVCTSPosition() { return -1; }
3233 int GetRudderPosition() { return -1; }
3234 int GetUPosition() { return -1; }
3235 int GetVPosition() { return -1; }
3236 int GetMovementThreshold() { return -1; }
3237 void SetMovementThreshold(int threshold) {}
3238
3239 bool IsOk(void) { return false; }
3240 int GetNumberJoysticks() { return -1; }
3241 int GetManufacturerId() { return -1; }
3242 int GetProductId() { return -1; }
3243 wxString GetProductName() { return wxEmptyString; }
3244 int GetXMin() { return -1; }
3245 int GetYMin() { return -1; }
3246 int GetZMin() { return -1; }
3247 int GetXMax() { return -1; }
3248 int GetYMax() { return -1; }
3249 int GetZMax() { return -1; }
3250 int GetNumberButtons() { return -1; }
3251 int GetNumberAxes() { return -1; }
3252 int GetMaxButtons() { return -1; }
3253 int GetMaxAxes() { return -1; }
3254 int GetPollingMin() { return -1; }
3255 int GetPollingMax() { return -1; }
3256 int GetRudderMin() { return -1; }
3257 int GetRudderMax() { return -1; }
3258 int GetUMin() { return -1; }
3259 int GetUMax() { return -1; }
3260 int GetVMin() { return -1; }
3261 int GetVMax() { return -1; }
3262
3263 bool HasRudder() { return false; }
3264 bool HasZ() { return false; }
3265 bool HasU() { return false; }
3266 bool HasV() { return false; }
3267 bool HasPOV() { return false; }
3268 bool HasPOV4Dir() { return false; }
3269 bool HasPOVCTS() { return false; }
3270
3271 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3272 bool ReleaseCapture() { return false; }
3273 };
3274 #endif
3275
3276
3277 #include <wx/sound.h>
3278
3279
3280 #if !wxUSE_SOUND
3281 // A C++ stub class for wxWave for platforms that don't have it.
3282 class wxSound : public wxObject
3283 {
3284 public:
3285 wxSound() {
3286 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3287 PyErr_SetString(PyExc_NotImplementedError,
3288 "wxSound is not available on this platform.");
3289 wxPyEndBlockThreads(blocked);
3290 }
3291 wxSound(const wxString&/*, bool*/) {
3292 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3293 PyErr_SetString(PyExc_NotImplementedError,
3294 "wxSound is not available on this platform.");
3295 wxPyEndBlockThreads(blocked);
3296 }
3297 wxSound(int, const wxByte*) {
3298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3299 PyErr_SetString(PyExc_NotImplementedError,
3300 "wxSound is not available on this platform.");
3301 wxPyEndBlockThreads(blocked);
3302 }
3303
3304 ~wxSound() {};
3305
3306 bool Create(const wxString&/*, bool*/) { return false; }
3307 bool Create(int, const wxByte*) { return false; };
3308 bool IsOk() { return false; };
3309 bool Play(unsigned) const { return false; }
3310 static bool Play(const wxString&, unsigned) { return false; }
3311 static void Stop() {}
3312 };
3313
3314 #endif
3315
3316 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3317 if (fileName.Length() == 0)
3318 return new wxSound;
3319 else
3320 return new wxSound(fileName);
3321 }
3322 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3323 unsigned char* buffer; int size;
3324 wxSound *sound = NULL;
3325
3326 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3327 if (!PyArg_Parse(data, "t#", &buffer, &size))
3328 goto done;
3329 sound = new wxSound(size, buffer);
3330 done:
3331 wxPyEndBlockThreads(blocked);
3332 return sound;
3333 }
3334 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3335 #ifndef __WXMAC__
3336 unsigned char* buffer;
3337 int size;
3338 bool rv = false;
3339
3340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3341 if (!PyArg_Parse(data, "t#", &buffer, &size))
3342 goto done;
3343 rv = self->Create(size, buffer);
3344 done:
3345 wxPyEndBlockThreads(blocked);
3346 return rv;
3347 #else
3348 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3349 PyErr_SetString(PyExc_NotImplementedError,
3350 "Create from data is not available on this platform.");
3351 wxPyEndBlockThreads(blocked);
3352 return false;
3353 #endif
3354 }
3355
3356 #include <wx/mimetype.h>
3357
3358 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3359 wxString str;
3360 if (self->GetMimeType(&str))
3361 return wx2PyString(str);
3362 else
3363 RETURN_NONE();
3364 }
3365 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3366 wxArrayString arr;
3367 if (self->GetMimeTypes(arr))
3368 return wxArrayString2PyList_helper(arr);
3369 else
3370 RETURN_NONE();
3371 }
3372 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3373 wxArrayString arr;
3374 if (self->GetExtensions(arr))
3375 return wxArrayString2PyList_helper(arr);
3376 else
3377 RETURN_NONE();
3378 }
3379 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3380 wxIconLocation loc;
3381 if (self->GetIcon(&loc))
3382 return new wxIcon(loc);
3383 else
3384 return NULL;
3385 }
3386 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3387 wxIconLocation loc;
3388 if (self->GetIcon(&loc)) {
3389 wxString iconFile = loc.GetFileName();
3390 int iconIndex = -1;
3391
3392
3393
3394 // Make a tuple and put the values in it
3395 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3396 PyObject* tuple = PyTuple_New(3);
3397 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3398 wxT("wxIcon"), true));
3399 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3400 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3401 wxPyEndBlockThreads(blocked);
3402 return tuple;
3403 }
3404 else
3405 RETURN_NONE();
3406 }
3407 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3408 wxString str;
3409 if (self->GetDescription(&str))
3410 return wx2PyString(str);
3411 else
3412 RETURN_NONE();
3413 }
3414 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3415 wxString str;
3416 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3417 return wx2PyString(str);
3418 else
3419 RETURN_NONE();
3420 }
3421 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3422 wxString str;
3423 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3424 return wx2PyString(str);
3425 else
3426 RETURN_NONE();
3427 }
3428 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3429 wxArrayString verbs;
3430 wxArrayString commands;
3431 if (self->GetAllCommands(&verbs, &commands,
3432 wxFileType::MessageParameters(filename, mimetype))) {
3433 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3434 PyObject* tuple = PyTuple_New(2);
3435 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3436 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3437 wxPyEndBlockThreads(blocked);
3438 return tuple;
3439 }
3440 else
3441 RETURN_NONE();
3442 }
3443 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3444 return wxFileType::ExpandCommand(command,
3445 wxFileType::MessageParameters(filename, mimetype));
3446 }
3447 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3448 wxArrayString arr;
3449 self->EnumAllFileTypes(arr);
3450 return wxArrayString2PyList_helper(arr);
3451 }
3452
3453 #include <wx/artprov.h>
3454
3455 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3456 static const wxString wxPyART_MENU(wxART_MENU);
3457 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3458 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3459 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3460 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3461 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3462 static const wxString wxPyART_OTHER(wxART_OTHER);
3463 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3464 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3465 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3466 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3467 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3468 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3469 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3470 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3471 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3472 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3473 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3474 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3475 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3476 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3477 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3478 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3479 static const wxString wxPyART_PRINT(wxART_PRINT);
3480 static const wxString wxPyART_HELP(wxART_HELP);
3481 static const wxString wxPyART_TIP(wxART_TIP);
3482 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3483 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3484 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3485 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3486 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3487 static const wxString wxPyART_CDROM(wxART_CDROM);
3488 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3489 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3490 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3491 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3492 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3493 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3494 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3495 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3496 static const wxString wxPyART_ERROR(wxART_ERROR);
3497 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3498 static const wxString wxPyART_WARNING(wxART_WARNING);
3499 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3500 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3501 static const wxString wxPyART_COPY(wxART_COPY);
3502 static const wxString wxPyART_CUT(wxART_CUT);
3503 static const wxString wxPyART_PASTE(wxART_PASTE);
3504 static const wxString wxPyART_DELETE(wxART_DELETE);
3505 static const wxString wxPyART_NEW(wxART_NEW);
3506 static const wxString wxPyART_UNDO(wxART_UNDO);
3507 static const wxString wxPyART_REDO(wxART_REDO);
3508 static const wxString wxPyART_QUIT(wxART_QUIT);
3509 static const wxString wxPyART_FIND(wxART_FIND);
3510 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3511 // Python aware wxArtProvider
3512 class wxPyArtProvider : public wxArtProvider {
3513 public:
3514
3515 virtual wxBitmap CreateBitmap(const wxArtID& id,
3516 const wxArtClient& client,
3517 const wxSize& size) {
3518 wxBitmap rval = wxNullBitmap;
3519 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3520 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3521 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3522 PyObject* ro;
3523 wxBitmap* ptr;
3524 PyObject* s1, *s2;
3525 s1 = wx2PyString(id);
3526 s2 = wx2PyString(client);
3527 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3528 Py_DECREF(so);
3529 Py_DECREF(s1);
3530 Py_DECREF(s2);
3531 if (ro) {
3532 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3533 rval = *ptr;
3534 Py_DECREF(ro);
3535 }
3536 }
3537 wxPyEndBlockThreads(blocked);
3538 return rval;
3539 }
3540
3541 PYPRIVATE;
3542 };
3543
3544 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3545
3546
3547
3548 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3549 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3550 PyObject* ret = PyTuple_New(3);
3551 if (ret) {
3552 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3553 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3554 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3555 }
3556 wxPyEndBlockThreads(blocked);
3557 return ret;
3558 }
3559
3560 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3561 bool cont;
3562 long index = 0;
3563 wxString value;
3564
3565 cont = self->GetFirstGroup(value, index);
3566 return __EnumerationHelper(cont, value, index);
3567 }
3568 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3569 bool cont;
3570 wxString value;
3571
3572 cont = self->GetNextGroup(value, index);
3573 return __EnumerationHelper(cont, value, index);
3574 }
3575 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3576 bool cont;
3577 long index = 0;
3578 wxString value;
3579
3580 cont = self->GetFirstEntry(value, index);
3581 return __EnumerationHelper(cont, value, index);
3582 }
3583 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3584 bool cont;
3585 wxString value;
3586
3587 cont = self->GetNextEntry(value, index);
3588 return __EnumerationHelper(cont, value, index);
3589 }
3590 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3591 long rv;
3592 self->Read(key, &rv, defaultVal);
3593 return rv;
3594 }
3595
3596 SWIGINTERN int
3597 SWIG_AsVal_double (PyObject *obj, double* val)
3598 {
3599 if (PyNumber_Check(obj)) {
3600 if (val) *val = PyFloat_AsDouble(obj);
3601 return SWIG_OK;
3602 }
3603 return SWIG_TypeError;
3604 }
3605
3606 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3607 double rv;
3608 self->Read(key, &rv, defaultVal);
3609 return rv;
3610 }
3611
3612 #define SWIG_From_double PyFloat_FromDouble
3613
3614 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3615 bool rv;
3616 self->Read(key, &rv, defaultVal);
3617 return rv;
3618 }
3619
3620 #include <wx/datetime.h>
3621
3622 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3623 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3624
3625 #define LOCAL_TZ wxDateTime::Local
3626
3627 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3628 wxString am;
3629 wxString pm;
3630 wxDateTime::GetAmPmStrings(&am, &pm);
3631 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3632 PyObject* tup = PyTuple_New(2);
3633 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3634 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3635 wxPyEndBlockThreads(blocked);
3636 return tup;
3637 }
3638
3639 SWIGINTERNINLINE PyObject *
3640 SWIG_From_unsigned_SS_int (unsigned int value)
3641 {
3642 return SWIG_From_unsigned_SS_long (value);
3643 }
3644
3645 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3646 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3647 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3648 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3649 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3650 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3651 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3652 return (*self < *other);
3653 }
3654 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3655 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3656 return (*self <= *other);
3657 }
3658 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3659 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3660 return (*self > *other);
3661 }
3662 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3663 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3664 return (*self >= *other);
3665 }
3666 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3667 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3668 return (*self == *other);
3669 }
3670 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3671 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3672 return (*self != *other);
3673 }
3674 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3675 const wxChar* rv;
3676 const wxChar* _date = date;
3677 rv = self->ParseRfc822Date(_date);
3678 if (rv == NULL) return -1;
3679 return rv - _date;
3680 }
3681 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3682 const wxChar* rv;
3683 const wxChar* _date = date;
3684 rv = self->ParseFormat(_date, format, dateDef);
3685 if (rv == NULL) return -1;
3686 return rv - _date;
3687 }
3688 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3689 const wxChar* rv;
3690 const wxChar* _datetime = datetime;
3691 rv = self->ParseDateTime(_datetime);
3692 if (rv == NULL) return -1;
3693 return rv - _datetime;
3694 }
3695 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3696 const wxChar* rv;
3697 const wxChar* _date = date;
3698 rv = self->ParseDate(_date);
3699 if (rv == NULL) return -1;
3700 return rv - _date;
3701 }
3702 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3703 const wxChar* rv;
3704 const wxChar* _time = time;
3705 rv = self->ParseTime(_time);
3706 if (rv == NULL) return -1;
3707 return rv - _time;
3708 }
3709 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3710 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3711 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3712 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3713 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3714 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3715 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3716 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3717 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3718 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3719 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3720 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3721 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3722 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3723 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3724 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3725
3726 #include <wx/dataobj.h>
3727
3728 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3729 size_t count = self->GetFormatCount(dir);
3730 wxDataFormat* formats = new wxDataFormat[count];
3731 self->GetAllFormats(formats, dir);
3732
3733 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3734 PyObject* list = PyList_New(count);
3735 for (size_t i=0; i<count; i++) {
3736 wxDataFormat* format = new wxDataFormat(formats[i]);
3737 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3738 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3739 }
3740 wxPyEndBlockThreads(blocked);
3741 delete [] formats;
3742 return list;
3743 }
3744 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3745 PyObject* rval = NULL;
3746 size_t size = self->GetDataSize(format);
3747 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3748 if (size) {
3749 char* buf = new char[size];
3750 if (self->GetDataHere(format, buf))
3751 rval = PyString_FromStringAndSize(buf, size);
3752 delete [] buf;
3753 }
3754 if (! rval) {
3755 rval = Py_None;
3756 Py_INCREF(rval);
3757 }
3758 wxPyEndBlockThreads(blocked);
3759 return rval;
3760 }
3761 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3762 bool rval;
3763 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3764 if (PyString_Check(data)) {
3765 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3766 }
3767 else {
3768 // raise a TypeError if not a string
3769 PyErr_SetString(PyExc_TypeError, "String expected.");
3770 rval = false;
3771 }
3772 wxPyEndBlockThreads(blocked);
3773 return rval;
3774 }
3775 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3776 PyObject* rval = NULL;
3777 size_t size = self->GetDataSize();
3778 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3779 if (size) {
3780 char* buf = new char[size];
3781 if (self->GetDataHere(buf))
3782 rval = PyString_FromStringAndSize(buf, size);
3783 delete [] buf;
3784 }
3785 if (! rval) {
3786 rval = Py_None;
3787 Py_INCREF(rval);
3788 }
3789 wxPyEndBlockThreads(blocked);
3790 return rval;
3791 }
3792 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3793 bool rval;
3794 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3795 if (PyString_Check(data)) {
3796 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3797 }
3798 else {
3799 // raise a TypeError if not a string
3800 PyErr_SetString(PyExc_TypeError, "String expected.");
3801 rval = false;
3802 }
3803 wxPyEndBlockThreads(blocked);
3804 return rval;
3805 }
3806 // Create a new class for wxPython to use
3807 class wxPyDataObjectSimple : public wxDataObjectSimple {
3808 public:
3809 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3810 : wxDataObjectSimple(format) {}
3811
3812 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3813 bool GetDataHere(void *buf) const;
3814 bool SetData(size_t len, const void *buf);
3815 PYPRIVATE;
3816 };
3817
3818 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3819
3820 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3821 // We need to get the data for this object and write it to buf. I think
3822 // the best way to do this for wxPython is to have the Python method
3823 // return either a string or None and then act appropriately with the
3824 // C++ version.
3825
3826 bool rval = false;
3827 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3828 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3829 PyObject* ro;
3830 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3831 if (ro) {
3832 rval = (ro != Py_None && PyString_Check(ro));
3833 if (rval)
3834 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3835 Py_DECREF(ro);
3836 }
3837 }
3838 wxPyEndBlockThreads(blocked);
3839 return rval;
3840 }
3841
3842 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3843 // For this one we simply need to make a string from buf and len
3844 // and send it to the Python method.
3845 bool rval = false;
3846 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3847 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3848 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3849 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3850 Py_DECREF(data);
3851 }
3852 wxPyEndBlockThreads(blocked);
3853 return rval;
3854 }
3855
3856 // Create a new class for wxPython to use
3857 class wxPyTextDataObject : public wxTextDataObject {
3858 public:
3859 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3860 : wxTextDataObject(text) {}
3861
3862 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3863 DEC_PYCALLBACK_STRING__const(GetText);
3864 DEC_PYCALLBACK__STRING(SetText);
3865 PYPRIVATE;
3866 };
3867
3868 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3869 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3870 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3871
3872
3873 // Create a new class for wxPython to use
3874 class wxPyBitmapDataObject : public wxBitmapDataObject {
3875 public:
3876 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3877 : wxBitmapDataObject(bitmap) {}
3878
3879 wxBitmap GetBitmap() const;
3880 void SetBitmap(const wxBitmap& bitmap);
3881 PYPRIVATE;
3882 };
3883
3884 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3885 wxBitmap* rval = &wxNullBitmap;
3886 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3887 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3888 PyObject* ro;
3889 wxBitmap* ptr;
3890 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3891 if (ro) {
3892 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3893 rval = ptr;
3894 Py_DECREF(ro);
3895 }
3896 }
3897 wxPyEndBlockThreads(blocked);
3898 return *rval;
3899 }
3900
3901 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3902 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3903 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3904 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3905 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3906 Py_DECREF(bo);
3907 }
3908 wxPyEndBlockThreads(blocked);
3909 }
3910
3911 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3912 return new wxCustomDataObject(wxDataFormat(formatName));
3913 }
3914 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3915 bool rval;
3916 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3917 if (PyString_Check(data)) {
3918 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3919 }
3920 else {
3921 // raise a TypeError if not a string
3922 PyErr_SetString(PyExc_TypeError, "String expected.");
3923 rval = false;
3924 }
3925 wxPyEndBlockThreads(blocked);
3926 return rval;
3927 }
3928 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3929 PyObject* obj;
3930 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3931 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3932 wxPyEndBlockThreads(blocked);
3933 return obj;
3934 }
3935
3936 #include <wx/metafile.h>
3937
3938
3939 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3940
3941
3942 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3943 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3944 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3945 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3946 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3947
3948
3949 class wxPyTextDropTarget : public wxTextDropTarget {
3950 public:
3951 wxPyTextDropTarget() {}
3952
3953 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3954
3955 DEC_PYCALLBACK__(OnLeave);
3956 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3957 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3958 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3959 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3960
3961 PYPRIVATE;
3962 };
3963
3964 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3965 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3966 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3967 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3968 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3969 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3970
3971
3972
3973 class wxPyFileDropTarget : public wxFileDropTarget {
3974 public:
3975 wxPyFileDropTarget() {}
3976
3977 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3978
3979 DEC_PYCALLBACK__(OnLeave);
3980 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3981 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3982 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3983 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3984
3985 PYPRIVATE;
3986 };
3987
3988 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3989 const wxArrayString& filenames) {
3990 bool rval = false;
3991 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3992 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3993 PyObject* list = wxArrayString2PyList_helper(filenames);
3994 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3995 Py_DECREF(list);
3996 }
3997 wxPyEndBlockThreads(blocked);
3998 return rval;
3999 }
4000
4001
4002
4003 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4004 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4005 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4006 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4007 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4008
4009
4010
4011
4012 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4013
4014 #include <wx/display.h>
4015 #include <wx/vidmode.h>
4016
4017 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4018 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4019
4020 #if !wxUSE_DISPLAY
4021 const wxVideoMode wxDefaultVideoMode;
4022 #endif
4023
4024 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4025 #if wxUSE_DISPLAY
4026 PyObject* pyList = NULL;
4027 wxArrayVideoModes arr = self->GetModes(mode);
4028 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4029 pyList = PyList_New(0);
4030 for (size_t i=0; i < arr.GetCount(); i++)
4031 {
4032 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4033 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4034 PyList_Append(pyList, pyObj);
4035 Py_DECREF(pyObj);
4036 }
4037 wxPyEndBlockThreads(blocked);
4038 return pyList;
4039 #else
4040 wxPyRaiseNotImplemented();
4041 return NULL;
4042 #endif
4043 }
4044 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4045 #if wxUSE_DISPLAY
4046 return self->GetCurrentMode();
4047 #else
4048 wxPyRaiseNotImplemented();
4049 return wxDefaultVideoMode;
4050 #endif
4051 }
4052 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4053 #if wxUSE_DISPLAY
4054 return self->ChangeMode(mode);
4055 #else
4056 wxPyRaiseNotImplemented();
4057 return false;
4058 #endif
4059 }
4060 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4061 #if wxUSE_DISPLAY
4062 self->ResetMode();
4063 #else
4064 wxPyRaiseNotImplemented();
4065 #endif
4066 }
4067
4068 #include <wx/stdpaths.h>
4069
4070 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4071 return (wxStandardPaths*) &wxStandardPaths::Get();
4072 }
4073 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4074 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4075
4076 #ifndef wxHAS_POWER_EVENTS
4077 // Dummy class and other definitions for platforms that don't have them
4078
4079 // See wxPython_int.h for wxPowerEvent
4080
4081 enum {
4082 wxEVT_POWER_SUSPENDING,
4083 wxEVT_POWER_SUSPENDED,
4084 wxEVT_POWER_SUSPEND_CANCEL,
4085 wxEVT_POWER_RESUME,
4086 };
4087
4088 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4089 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4090
4091 #endif
4092
4093
4094 #include <wx/aboutdlg.h>
4095
4096 #ifdef __cplusplus
4097 extern "C" {
4098 #endif
4099 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4100 PyObject *resultobj = 0;
4101 wxSystemColour arg1 ;
4102 wxColour result;
4103 int val1 ;
4104 int ecode1 = 0 ;
4105 PyObject * obj0 = 0 ;
4106 char * kwnames[] = {
4107 (char *) "index", NULL
4108 };
4109
4110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4111 ecode1 = SWIG_AsVal_int(obj0, &val1);
4112 if (!SWIG_IsOK(ecode1)) {
4113 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4114 }
4115 arg1 = static_cast< wxSystemColour >(val1);
4116 {
4117 if (!wxPyCheckForApp()) SWIG_fail;
4118 PyThreadState* __tstate = wxPyBeginAllowThreads();
4119 result = wxSystemSettings::GetColour(arg1);
4120 wxPyEndAllowThreads(__tstate);
4121 if (PyErr_Occurred()) SWIG_fail;
4122 }
4123 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4124 return resultobj;
4125 fail:
4126 return NULL;
4127 }
4128
4129
4130 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4131 PyObject *resultobj = 0;
4132 wxSystemFont arg1 ;
4133 wxFont result;
4134 int val1 ;
4135 int ecode1 = 0 ;
4136 PyObject * obj0 = 0 ;
4137 char * kwnames[] = {
4138 (char *) "index", NULL
4139 };
4140
4141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4142 ecode1 = SWIG_AsVal_int(obj0, &val1);
4143 if (!SWIG_IsOK(ecode1)) {
4144 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4145 }
4146 arg1 = static_cast< wxSystemFont >(val1);
4147 {
4148 if (!wxPyCheckForApp()) SWIG_fail;
4149 PyThreadState* __tstate = wxPyBeginAllowThreads();
4150 result = wxSystemSettings::GetFont(arg1);
4151 wxPyEndAllowThreads(__tstate);
4152 if (PyErr_Occurred()) SWIG_fail;
4153 }
4154 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4155 return resultobj;
4156 fail:
4157 return NULL;
4158 }
4159
4160
4161 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4162 PyObject *resultobj = 0;
4163 wxSystemMetric arg1 ;
4164 wxWindow *arg2 = (wxWindow *) NULL ;
4165 int result;
4166 int val1 ;
4167 int ecode1 = 0 ;
4168 void *argp2 = 0 ;
4169 int res2 = 0 ;
4170 PyObject * obj0 = 0 ;
4171 PyObject * obj1 = 0 ;
4172 char * kwnames[] = {
4173 (char *) "index",(char *) "win", NULL
4174 };
4175
4176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4177 ecode1 = SWIG_AsVal_int(obj0, &val1);
4178 if (!SWIG_IsOK(ecode1)) {
4179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4180 }
4181 arg1 = static_cast< wxSystemMetric >(val1);
4182 if (obj1) {
4183 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4184 if (!SWIG_IsOK(res2)) {
4185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4186 }
4187 arg2 = reinterpret_cast< wxWindow * >(argp2);
4188 }
4189 {
4190 if (!wxPyCheckForApp()) SWIG_fail;
4191 PyThreadState* __tstate = wxPyBeginAllowThreads();
4192 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4193 wxPyEndAllowThreads(__tstate);
4194 if (PyErr_Occurred()) SWIG_fail;
4195 }
4196 resultobj = SWIG_From_int(static_cast< int >(result));
4197 return resultobj;
4198 fail:
4199 return NULL;
4200 }
4201
4202
4203 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4204 PyObject *resultobj = 0;
4205 wxSystemFeature arg1 ;
4206 bool result;
4207 int val1 ;
4208 int ecode1 = 0 ;
4209 PyObject * obj0 = 0 ;
4210 char * kwnames[] = {
4211 (char *) "index", NULL
4212 };
4213
4214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4215 ecode1 = SWIG_AsVal_int(obj0, &val1);
4216 if (!SWIG_IsOK(ecode1)) {
4217 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4218 }
4219 arg1 = static_cast< wxSystemFeature >(val1);
4220 {
4221 if (!wxPyCheckForApp()) SWIG_fail;
4222 PyThreadState* __tstate = wxPyBeginAllowThreads();
4223 result = (bool)wxSystemSettings::HasFeature(arg1);
4224 wxPyEndAllowThreads(__tstate);
4225 if (PyErr_Occurred()) SWIG_fail;
4226 }
4227 {
4228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4229 }
4230 return resultobj;
4231 fail:
4232 return NULL;
4233 }
4234
4235
4236 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4237 PyObject *resultobj = 0;
4238 wxSystemScreenType result;
4239
4240 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4241 {
4242 if (!wxPyCheckForApp()) SWIG_fail;
4243 PyThreadState* __tstate = wxPyBeginAllowThreads();
4244 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4245 wxPyEndAllowThreads(__tstate);
4246 if (PyErr_Occurred()) SWIG_fail;
4247 }
4248 resultobj = SWIG_From_int(static_cast< int >(result));
4249 return resultobj;
4250 fail:
4251 return NULL;
4252 }
4253
4254
4255 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4256 PyObject *resultobj = 0;
4257 wxSystemScreenType arg1 ;
4258 int val1 ;
4259 int ecode1 = 0 ;
4260 PyObject * obj0 = 0 ;
4261 char * kwnames[] = {
4262 (char *) "screen", NULL
4263 };
4264
4265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4266 ecode1 = SWIG_AsVal_int(obj0, &val1);
4267 if (!SWIG_IsOK(ecode1)) {
4268 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4269 }
4270 arg1 = static_cast< wxSystemScreenType >(val1);
4271 {
4272 if (!wxPyCheckForApp()) SWIG_fail;
4273 PyThreadState* __tstate = wxPyBeginAllowThreads();
4274 wxSystemSettings::SetScreenType(arg1);
4275 wxPyEndAllowThreads(__tstate);
4276 if (PyErr_Occurred()) SWIG_fail;
4277 }
4278 resultobj = SWIG_Py_Void();
4279 return resultobj;
4280 fail:
4281 return NULL;
4282 }
4283
4284
4285 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4286 PyObject *obj;
4287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4288 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4289 return SWIG_Py_Void();
4290 }
4291
4292 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4293 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4294 return 1;
4295 }
4296
4297
4298 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4299 PyObject *pyobj = 0;
4300
4301 {
4302 #if wxUSE_UNICODE
4303 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4304 #else
4305 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4306 #endif
4307 }
4308 return pyobj;
4309 }
4310
4311
4312 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4313 PyObject *resultobj = 0;
4314 wxSystemOptions *result = 0 ;
4315
4316 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4317 {
4318 PyThreadState* __tstate = wxPyBeginAllowThreads();
4319 result = (wxSystemOptions *)new wxSystemOptions();
4320 wxPyEndAllowThreads(__tstate);
4321 if (PyErr_Occurred()) SWIG_fail;
4322 }
4323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4324 return resultobj;
4325 fail:
4326 return NULL;
4327 }
4328
4329
4330 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4331 PyObject *resultobj = 0;
4332 wxString *arg1 = 0 ;
4333 wxString *arg2 = 0 ;
4334 bool temp1 = false ;
4335 bool temp2 = false ;
4336 PyObject * obj0 = 0 ;
4337 PyObject * obj1 = 0 ;
4338 char * kwnames[] = {
4339 (char *) "name",(char *) "value", NULL
4340 };
4341
4342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4343 {
4344 arg1 = wxString_in_helper(obj0);
4345 if (arg1 == NULL) SWIG_fail;
4346 temp1 = true;
4347 }
4348 {
4349 arg2 = wxString_in_helper(obj1);
4350 if (arg2 == NULL) SWIG_fail;
4351 temp2 = true;
4352 }
4353 {
4354 PyThreadState* __tstate = wxPyBeginAllowThreads();
4355 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4356 wxPyEndAllowThreads(__tstate);
4357 if (PyErr_Occurred()) SWIG_fail;
4358 }
4359 resultobj = SWIG_Py_Void();
4360 {
4361 if (temp1)
4362 delete arg1;
4363 }
4364 {
4365 if (temp2)
4366 delete arg2;
4367 }
4368 return resultobj;
4369 fail:
4370 {
4371 if (temp1)
4372 delete arg1;
4373 }
4374 {
4375 if (temp2)
4376 delete arg2;
4377 }
4378 return NULL;
4379 }
4380
4381
4382 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4383 PyObject *resultobj = 0;
4384 wxString *arg1 = 0 ;
4385 int arg2 ;
4386 bool temp1 = false ;
4387 int val2 ;
4388 int ecode2 = 0 ;
4389 PyObject * obj0 = 0 ;
4390 PyObject * obj1 = 0 ;
4391 char * kwnames[] = {
4392 (char *) "name",(char *) "value", NULL
4393 };
4394
4395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4396 {
4397 arg1 = wxString_in_helper(obj0);
4398 if (arg1 == NULL) SWIG_fail;
4399 temp1 = true;
4400 }
4401 ecode2 = SWIG_AsVal_int(obj1, &val2);
4402 if (!SWIG_IsOK(ecode2)) {
4403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4404 }
4405 arg2 = static_cast< int >(val2);
4406 {
4407 PyThreadState* __tstate = wxPyBeginAllowThreads();
4408 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4409 wxPyEndAllowThreads(__tstate);
4410 if (PyErr_Occurred()) SWIG_fail;
4411 }
4412 resultobj = SWIG_Py_Void();
4413 {
4414 if (temp1)
4415 delete arg1;
4416 }
4417 return resultobj;
4418 fail:
4419 {
4420 if (temp1)
4421 delete arg1;
4422 }
4423 return NULL;
4424 }
4425
4426
4427 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4428 PyObject *resultobj = 0;
4429 wxString *arg1 = 0 ;
4430 wxString result;
4431 bool temp1 = false ;
4432 PyObject * obj0 = 0 ;
4433 char * kwnames[] = {
4434 (char *) "name", NULL
4435 };
4436
4437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4438 {
4439 arg1 = wxString_in_helper(obj0);
4440 if (arg1 == NULL) SWIG_fail;
4441 temp1 = true;
4442 }
4443 {
4444 PyThreadState* __tstate = wxPyBeginAllowThreads();
4445 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4446 wxPyEndAllowThreads(__tstate);
4447 if (PyErr_Occurred()) SWIG_fail;
4448 }
4449 {
4450 #if wxUSE_UNICODE
4451 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4452 #else
4453 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4454 #endif
4455 }
4456 {
4457 if (temp1)
4458 delete arg1;
4459 }
4460 return resultobj;
4461 fail:
4462 {
4463 if (temp1)
4464 delete arg1;
4465 }
4466 return NULL;
4467 }
4468
4469
4470 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4471 PyObject *resultobj = 0;
4472 wxString *arg1 = 0 ;
4473 int result;
4474 bool temp1 = false ;
4475 PyObject * obj0 = 0 ;
4476 char * kwnames[] = {
4477 (char *) "name", NULL
4478 };
4479
4480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4481 {
4482 arg1 = wxString_in_helper(obj0);
4483 if (arg1 == NULL) SWIG_fail;
4484 temp1 = true;
4485 }
4486 {
4487 PyThreadState* __tstate = wxPyBeginAllowThreads();
4488 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4489 wxPyEndAllowThreads(__tstate);
4490 if (PyErr_Occurred()) SWIG_fail;
4491 }
4492 resultobj = SWIG_From_int(static_cast< int >(result));
4493 {
4494 if (temp1)
4495 delete arg1;
4496 }
4497 return resultobj;
4498 fail:
4499 {
4500 if (temp1)
4501 delete arg1;
4502 }
4503 return NULL;
4504 }
4505
4506
4507 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4508 PyObject *resultobj = 0;
4509 wxString *arg1 = 0 ;
4510 bool result;
4511 bool temp1 = false ;
4512 PyObject * obj0 = 0 ;
4513 char * kwnames[] = {
4514 (char *) "name", NULL
4515 };
4516
4517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4518 {
4519 arg1 = wxString_in_helper(obj0);
4520 if (arg1 == NULL) SWIG_fail;
4521 temp1 = true;
4522 }
4523 {
4524 PyThreadState* __tstate = wxPyBeginAllowThreads();
4525 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4526 wxPyEndAllowThreads(__tstate);
4527 if (PyErr_Occurred()) SWIG_fail;
4528 }
4529 {
4530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4531 }
4532 {
4533 if (temp1)
4534 delete arg1;
4535 }
4536 return resultobj;
4537 fail:
4538 {
4539 if (temp1)
4540 delete arg1;
4541 }
4542 return NULL;
4543 }
4544
4545
4546 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4547 PyObject *resultobj = 0;
4548 wxString *arg1 = 0 ;
4549 bool result;
4550 bool temp1 = false ;
4551 PyObject * obj0 = 0 ;
4552 char * kwnames[] = {
4553 (char *) "name", NULL
4554 };
4555
4556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4557 {
4558 arg1 = wxString_in_helper(obj0);
4559 if (arg1 == NULL) SWIG_fail;
4560 temp1 = true;
4561 }
4562 {
4563 PyThreadState* __tstate = wxPyBeginAllowThreads();
4564 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4565 wxPyEndAllowThreads(__tstate);
4566 if (PyErr_Occurred()) SWIG_fail;
4567 }
4568 {
4569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4570 }
4571 {
4572 if (temp1)
4573 delete arg1;
4574 }
4575 return resultobj;
4576 fail:
4577 {
4578 if (temp1)
4579 delete arg1;
4580 }
4581 return NULL;
4582 }
4583
4584
4585 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4586 PyObject *obj;
4587 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4588 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4589 return SWIG_Py_Void();
4590 }
4591
4592 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4593 return SWIG_Python_InitShadowInstance(args);
4594 }
4595
4596 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4597 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4598 return 1;
4599 }
4600
4601
4602 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4603 PyObject *pyobj = 0;
4604
4605 {
4606 #if wxUSE_UNICODE
4607 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4608 #else
4609 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4610 #endif
4611 }
4612 return pyobj;
4613 }
4614
4615
4616 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4617 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4618 return 1;
4619 }
4620
4621
4622 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4623 PyObject *pyobj = 0;
4624
4625 {
4626 #if wxUSE_UNICODE
4627 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4628 #else
4629 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4630 #endif
4631 }
4632 return pyobj;
4633 }
4634
4635
4636 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4637 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4638 return 1;
4639 }
4640
4641
4642 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4643 PyObject *pyobj = 0;
4644
4645 {
4646 #if wxUSE_UNICODE
4647 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4648 #else
4649 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4650 #endif
4651 }
4652 return pyobj;
4653 }
4654
4655
4656 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4657 PyObject *resultobj = 0;
4658 long result;
4659
4660 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4661 {
4662 PyThreadState* __tstate = wxPyBeginAllowThreads();
4663 result = (long)wxNewId();
4664 wxPyEndAllowThreads(__tstate);
4665 if (PyErr_Occurred()) SWIG_fail;
4666 }
4667 resultobj = SWIG_From_long(static_cast< long >(result));
4668 return resultobj;
4669 fail:
4670 return NULL;
4671 }
4672
4673
4674 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4675 PyObject *resultobj = 0;
4676 long arg1 ;
4677 long val1 ;
4678 int ecode1 = 0 ;
4679 PyObject * obj0 = 0 ;
4680 char * kwnames[] = {
4681 (char *) "id", NULL
4682 };
4683
4684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4685 ecode1 = SWIG_AsVal_long(obj0, &val1);
4686 if (!SWIG_IsOK(ecode1)) {
4687 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4688 }
4689 arg1 = static_cast< long >(val1);
4690 {
4691 PyThreadState* __tstate = wxPyBeginAllowThreads();
4692 wxRegisterId(arg1);
4693 wxPyEndAllowThreads(__tstate);
4694 if (PyErr_Occurred()) SWIG_fail;
4695 }
4696 resultobj = SWIG_Py_Void();
4697 return resultobj;
4698 fail:
4699 return NULL;
4700 }
4701
4702
4703 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4704 PyObject *resultobj = 0;
4705 long result;
4706
4707 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4708 {
4709 PyThreadState* __tstate = wxPyBeginAllowThreads();
4710 result = (long)wxGetCurrentId();
4711 wxPyEndAllowThreads(__tstate);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 resultobj = SWIG_From_long(static_cast< long >(result));
4715 return resultobj;
4716 fail:
4717 return NULL;
4718 }
4719
4720
4721 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4722 PyObject *resultobj = 0;
4723 int arg1 ;
4724 bool result;
4725 int val1 ;
4726 int ecode1 = 0 ;
4727 PyObject * obj0 = 0 ;
4728 char * kwnames[] = {
4729 (char *) "id", NULL
4730 };
4731
4732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4733 ecode1 = SWIG_AsVal_int(obj0, &val1);
4734 if (!SWIG_IsOK(ecode1)) {
4735 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4736 }
4737 arg1 = static_cast< int >(val1);
4738 {
4739 PyThreadState* __tstate = wxPyBeginAllowThreads();
4740 result = (bool)wxIsStockID(arg1);
4741 wxPyEndAllowThreads(__tstate);
4742 if (PyErr_Occurred()) SWIG_fail;
4743 }
4744 {
4745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4746 }
4747 return resultobj;
4748 fail:
4749 return NULL;
4750 }
4751
4752
4753 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4754 PyObject *resultobj = 0;
4755 int arg1 ;
4756 wxString *arg2 = 0 ;
4757 bool result;
4758 int val1 ;
4759 int ecode1 = 0 ;
4760 bool temp2 = false ;
4761 PyObject * obj0 = 0 ;
4762 PyObject * obj1 = 0 ;
4763 char * kwnames[] = {
4764 (char *) "id",(char *) "label", NULL
4765 };
4766
4767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4768 ecode1 = SWIG_AsVal_int(obj0, &val1);
4769 if (!SWIG_IsOK(ecode1)) {
4770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4771 }
4772 arg1 = static_cast< int >(val1);
4773 {
4774 arg2 = wxString_in_helper(obj1);
4775 if (arg2 == NULL) SWIG_fail;
4776 temp2 = true;
4777 }
4778 {
4779 PyThreadState* __tstate = wxPyBeginAllowThreads();
4780 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4781 wxPyEndAllowThreads(__tstate);
4782 if (PyErr_Occurred()) SWIG_fail;
4783 }
4784 {
4785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4786 }
4787 {
4788 if (temp2)
4789 delete arg2;
4790 }
4791 return resultobj;
4792 fail:
4793 {
4794 if (temp2)
4795 delete arg2;
4796 }
4797 return NULL;
4798 }
4799
4800
4801 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4802 PyObject *resultobj = 0;
4803 int arg1 ;
4804 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4805 wxString result;
4806 int val1 ;
4807 int ecode1 = 0 ;
4808 long val2 ;
4809 int ecode2 = 0 ;
4810 PyObject * obj0 = 0 ;
4811 PyObject * obj1 = 0 ;
4812 char * kwnames[] = {
4813 (char *) "id",(char *) "flags", NULL
4814 };
4815
4816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4817 ecode1 = SWIG_AsVal_int(obj0, &val1);
4818 if (!SWIG_IsOK(ecode1)) {
4819 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4820 }
4821 arg1 = static_cast< int >(val1);
4822 if (obj1) {
4823 ecode2 = SWIG_AsVal_long(obj1, &val2);
4824 if (!SWIG_IsOK(ecode2)) {
4825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4826 }
4827 arg2 = static_cast< long >(val2);
4828 }
4829 {
4830 PyThreadState* __tstate = wxPyBeginAllowThreads();
4831 result = wxGetStockLabel(arg1,arg2);
4832 wxPyEndAllowThreads(__tstate);
4833 if (PyErr_Occurred()) SWIG_fail;
4834 }
4835 {
4836 #if wxUSE_UNICODE
4837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4838 #else
4839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4840 #endif
4841 }
4842 return resultobj;
4843 fail:
4844 return NULL;
4845 }
4846
4847
4848 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4849 PyObject *resultobj = 0;
4850 int arg1 ;
4851 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4852 wxString result;
4853 int val1 ;
4854 int ecode1 = 0 ;
4855 int val2 ;
4856 int ecode2 = 0 ;
4857 PyObject * obj0 = 0 ;
4858 PyObject * obj1 = 0 ;
4859 char * kwnames[] = {
4860 (char *) "id",(char *) "client", NULL
4861 };
4862
4863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4864 ecode1 = SWIG_AsVal_int(obj0, &val1);
4865 if (!SWIG_IsOK(ecode1)) {
4866 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4867 }
4868 arg1 = static_cast< int >(val1);
4869 if (obj1) {
4870 ecode2 = SWIG_AsVal_int(obj1, &val2);
4871 if (!SWIG_IsOK(ecode2)) {
4872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4873 }
4874 arg2 = static_cast< wxStockHelpStringClient >(val2);
4875 }
4876 {
4877 PyThreadState* __tstate = wxPyBeginAllowThreads();
4878 result = wxGetStockHelpString(arg1,arg2);
4879 wxPyEndAllowThreads(__tstate);
4880 if (PyErr_Occurred()) SWIG_fail;
4881 }
4882 {
4883 #if wxUSE_UNICODE
4884 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4885 #else
4886 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4887 #endif
4888 }
4889 return resultobj;
4890 fail:
4891 return NULL;
4892 }
4893
4894
4895 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4896 PyObject *resultobj = 0;
4897
4898 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4899 {
4900 if (!wxPyCheckForApp()) SWIG_fail;
4901 PyThreadState* __tstate = wxPyBeginAllowThreads();
4902 wxBell();
4903 wxPyEndAllowThreads(__tstate);
4904 if (PyErr_Occurred()) SWIG_fail;
4905 }
4906 resultobj = SWIG_Py_Void();
4907 return resultobj;
4908 fail:
4909 return NULL;
4910 }
4911
4912
4913 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4914 PyObject *resultobj = 0;
4915
4916 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4917 {
4918 if (!wxPyCheckForApp()) SWIG_fail;
4919 PyThreadState* __tstate = wxPyBeginAllowThreads();
4920 wxEndBusyCursor();
4921 wxPyEndAllowThreads(__tstate);
4922 if (PyErr_Occurred()) SWIG_fail;
4923 }
4924 resultobj = SWIG_Py_Void();
4925 return resultobj;
4926 fail:
4927 return NULL;
4928 }
4929
4930
4931 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4932 PyObject *resultobj = 0;
4933 bool arg1 = (bool) true ;
4934 long result;
4935 bool val1 ;
4936 int ecode1 = 0 ;
4937 PyObject * obj0 = 0 ;
4938 char * kwnames[] = {
4939 (char *) "resetTimer", NULL
4940 };
4941
4942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4943 if (obj0) {
4944 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4945 if (!SWIG_IsOK(ecode1)) {
4946 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4947 }
4948 arg1 = static_cast< bool >(val1);
4949 }
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 result = (long)wxGetElapsedTime(arg1);
4953 wxPyEndAllowThreads(__tstate);
4954 if (PyErr_Occurred()) SWIG_fail;
4955 }
4956 resultobj = SWIG_From_long(static_cast< long >(result));
4957 return resultobj;
4958 fail:
4959 return NULL;
4960 }
4961
4962
4963 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4964 PyObject *resultobj = 0;
4965 bool result;
4966
4967 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4968 {
4969 PyThreadState* __tstate = wxPyBeginAllowThreads();
4970 result = (bool)wxIsBusy();
4971 wxPyEndAllowThreads(__tstate);
4972 if (PyErr_Occurred()) SWIG_fail;
4973 }
4974 {
4975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4976 }
4977 return resultobj;
4978 fail:
4979 return NULL;
4980 }
4981
4982
4983 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4984 PyObject *resultobj = 0;
4985 wxString result;
4986
4987 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4988 {
4989 PyThreadState* __tstate = wxPyBeginAllowThreads();
4990 result = wxNow();
4991 wxPyEndAllowThreads(__tstate);
4992 if (PyErr_Occurred()) SWIG_fail;
4993 }
4994 {
4995 #if wxUSE_UNICODE
4996 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4997 #else
4998 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4999 #endif
5000 }
5001 return resultobj;
5002 fail:
5003 return NULL;
5004 }
5005
5006
5007 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5008 PyObject *resultobj = 0;
5009 wxString const &arg1_defvalue = wxPyEmptyString ;
5010 wxString *arg1 = (wxString *) &arg1_defvalue ;
5011 bool result;
5012 bool temp1 = false ;
5013 PyObject * obj0 = 0 ;
5014 char * kwnames[] = {
5015 (char *) "command", NULL
5016 };
5017
5018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5019 if (obj0) {
5020 {
5021 arg1 = wxString_in_helper(obj0);
5022 if (arg1 == NULL) SWIG_fail;
5023 temp1 = true;
5024 }
5025 }
5026 {
5027 PyThreadState* __tstate = wxPyBeginAllowThreads();
5028 result = (bool)wxShell((wxString const &)*arg1);
5029 wxPyEndAllowThreads(__tstate);
5030 if (PyErr_Occurred()) SWIG_fail;
5031 }
5032 {
5033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5034 }
5035 {
5036 if (temp1)
5037 delete arg1;
5038 }
5039 return resultobj;
5040 fail:
5041 {
5042 if (temp1)
5043 delete arg1;
5044 }
5045 return NULL;
5046 }
5047
5048
5049 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5050 PyObject *resultobj = 0;
5051
5052 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5053 {
5054 PyThreadState* __tstate = wxPyBeginAllowThreads();
5055 wxStartTimer();
5056 wxPyEndAllowThreads(__tstate);
5057 if (PyErr_Occurred()) SWIG_fail;
5058 }
5059 resultobj = SWIG_Py_Void();
5060 return resultobj;
5061 fail:
5062 return NULL;
5063 }
5064
5065
5066 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5067 PyObject *resultobj = 0;
5068 int *arg1 = (int *) 0 ;
5069 int *arg2 = (int *) 0 ;
5070 int result;
5071 int temp1 ;
5072 int res1 = SWIG_TMPOBJ ;
5073 int temp2 ;
5074 int res2 = SWIG_TMPOBJ ;
5075
5076 arg1 = &temp1;
5077 arg2 = &temp2;
5078 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5079 {
5080 PyThreadState* __tstate = wxPyBeginAllowThreads();
5081 result = (int)wxGetOsVersion(arg1,arg2);
5082 wxPyEndAllowThreads(__tstate);
5083 if (PyErr_Occurred()) SWIG_fail;
5084 }
5085 resultobj = SWIG_From_int(static_cast< int >(result));
5086 if (SWIG_IsTmpObj(res1)) {
5087 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5088 } else {
5089 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5091 }
5092 if (SWIG_IsTmpObj(res2)) {
5093 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5094 } else {
5095 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5096 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5097 }
5098 return resultobj;
5099 fail:
5100 return NULL;
5101 }
5102
5103
5104 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5105 PyObject *resultobj = 0;
5106 wxString result;
5107
5108 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5109 {
5110 PyThreadState* __tstate = wxPyBeginAllowThreads();
5111 result = wxGetOsDescription();
5112 wxPyEndAllowThreads(__tstate);
5113 if (PyErr_Occurred()) SWIG_fail;
5114 }
5115 {
5116 #if wxUSE_UNICODE
5117 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5118 #else
5119 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5120 #endif
5121 }
5122 return resultobj;
5123 fail:
5124 return NULL;
5125 }
5126
5127
5128 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5129 PyObject *resultobj = 0;
5130 bool result;
5131
5132 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5133 {
5134 PyThreadState* __tstate = wxPyBeginAllowThreads();
5135 result = (bool)wxIsPlatformLittleEndian();
5136 wxPyEndAllowThreads(__tstate);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 {
5140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5141 }
5142 return resultobj;
5143 fail:
5144 return NULL;
5145 }
5146
5147
5148 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5149 PyObject *resultobj = 0;
5150 bool result;
5151
5152 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5153 {
5154 PyThreadState* __tstate = wxPyBeginAllowThreads();
5155 result = (bool)wxIsPlatform64Bit();
5156 wxPyEndAllowThreads(__tstate);
5157 if (PyErr_Occurred()) SWIG_fail;
5158 }
5159 {
5160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5161 }
5162 return resultobj;
5163 fail:
5164 return NULL;
5165 }
5166
5167
5168 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5169 PyObject *resultobj = 0;
5170 wxMemorySize result;
5171
5172 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5173 {
5174 PyThreadState* __tstate = wxPyBeginAllowThreads();
5175 result = wxGetFreeMemory();
5176 wxPyEndAllowThreads(__tstate);
5177 if (PyErr_Occurred()) SWIG_fail;
5178 }
5179 {
5180 #if wxUSE_LONGLONG
5181 resultobj = PyLong_FromLongLong((&result)->GetValue());
5182 #else
5183 resultobj = PyInt_FromLong(result);
5184 #endif
5185 }
5186 return resultobj;
5187 fail:
5188 return NULL;
5189 }
5190
5191
5192 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5193 PyObject *resultobj = 0;
5194 wxShutdownFlags arg1 ;
5195 bool result;
5196 int val1 ;
5197 int ecode1 = 0 ;
5198 PyObject * obj0 = 0 ;
5199 char * kwnames[] = {
5200 (char *) "wFlags", NULL
5201 };
5202
5203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5204 ecode1 = SWIG_AsVal_int(obj0, &val1);
5205 if (!SWIG_IsOK(ecode1)) {
5206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5207 }
5208 arg1 = static_cast< wxShutdownFlags >(val1);
5209 {
5210 if (!wxPyCheckForApp()) SWIG_fail;
5211 PyThreadState* __tstate = wxPyBeginAllowThreads();
5212 result = (bool)wxShutdown(arg1);
5213 wxPyEndAllowThreads(__tstate);
5214 if (PyErr_Occurred()) SWIG_fail;
5215 }
5216 {
5217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5218 }
5219 return resultobj;
5220 fail:
5221 return NULL;
5222 }
5223
5224
5225 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5226 PyObject *resultobj = 0;
5227 int arg1 ;
5228 int val1 ;
5229 int ecode1 = 0 ;
5230 PyObject * obj0 = 0 ;
5231 char * kwnames[] = {
5232 (char *) "secs", NULL
5233 };
5234
5235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5236 ecode1 = SWIG_AsVal_int(obj0, &val1);
5237 if (!SWIG_IsOK(ecode1)) {
5238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5239 }
5240 arg1 = static_cast< int >(val1);
5241 {
5242 PyThreadState* __tstate = wxPyBeginAllowThreads();
5243 wxSleep(arg1);
5244 wxPyEndAllowThreads(__tstate);
5245 if (PyErr_Occurred()) SWIG_fail;
5246 }
5247 resultobj = SWIG_Py_Void();
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5255 PyObject *resultobj = 0;
5256 unsigned long arg1 ;
5257 unsigned long val1 ;
5258 int ecode1 = 0 ;
5259 PyObject * obj0 = 0 ;
5260 char * kwnames[] = {
5261 (char *) "milliseconds", NULL
5262 };
5263
5264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5265 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5266 if (!SWIG_IsOK(ecode1)) {
5267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5268 }
5269 arg1 = static_cast< unsigned long >(val1);
5270 {
5271 PyThreadState* __tstate = wxPyBeginAllowThreads();
5272 wxMilliSleep(arg1);
5273 wxPyEndAllowThreads(__tstate);
5274 if (PyErr_Occurred()) SWIG_fail;
5275 }
5276 resultobj = SWIG_Py_Void();
5277 return resultobj;
5278 fail:
5279 return NULL;
5280 }
5281
5282
5283 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5284 PyObject *resultobj = 0;
5285 unsigned long arg1 ;
5286 unsigned long val1 ;
5287 int ecode1 = 0 ;
5288 PyObject * obj0 = 0 ;
5289 char * kwnames[] = {
5290 (char *) "microseconds", NULL
5291 };
5292
5293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5294 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5295 if (!SWIG_IsOK(ecode1)) {
5296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5297 }
5298 arg1 = static_cast< unsigned long >(val1);
5299 {
5300 PyThreadState* __tstate = wxPyBeginAllowThreads();
5301 wxMicroSleep(arg1);
5302 wxPyEndAllowThreads(__tstate);
5303 if (PyErr_Occurred()) SWIG_fail;
5304 }
5305 resultobj = SWIG_Py_Void();
5306 return resultobj;
5307 fail:
5308 return NULL;
5309 }
5310
5311
5312 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5313 PyObject *resultobj = 0;
5314 bool arg1 ;
5315 bool val1 ;
5316 int ecode1 = 0 ;
5317 PyObject * obj0 = 0 ;
5318 char * kwnames[] = {
5319 (char *) "enable", NULL
5320 };
5321
5322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5323 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5324 if (!SWIG_IsOK(ecode1)) {
5325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5326 }
5327 arg1 = static_cast< bool >(val1);
5328 {
5329 PyThreadState* __tstate = wxPyBeginAllowThreads();
5330 wxEnableTopLevelWindows(arg1);
5331 wxPyEndAllowThreads(__tstate);
5332 if (PyErr_Occurred()) SWIG_fail;
5333 }
5334 resultobj = SWIG_Py_Void();
5335 return resultobj;
5336 fail:
5337 return NULL;
5338 }
5339
5340
5341 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5342 PyObject *resultobj = 0;
5343 wxString *arg1 = 0 ;
5344 wxString result;
5345 bool temp1 = false ;
5346 PyObject * obj0 = 0 ;
5347 char * kwnames[] = {
5348 (char *) "in", NULL
5349 };
5350
5351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5352 {
5353 arg1 = wxString_in_helper(obj0);
5354 if (arg1 == NULL) SWIG_fail;
5355 temp1 = true;
5356 }
5357 {
5358 PyThreadState* __tstate = wxPyBeginAllowThreads();
5359 result = wxStripMenuCodes((wxString const &)*arg1);
5360 wxPyEndAllowThreads(__tstate);
5361 if (PyErr_Occurred()) SWIG_fail;
5362 }
5363 {
5364 #if wxUSE_UNICODE
5365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5366 #else
5367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5368 #endif
5369 }
5370 {
5371 if (temp1)
5372 delete arg1;
5373 }
5374 return resultobj;
5375 fail:
5376 {
5377 if (temp1)
5378 delete arg1;
5379 }
5380 return NULL;
5381 }
5382
5383
5384 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5385 PyObject *resultobj = 0;
5386 wxString result;
5387
5388 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5389 {
5390 PyThreadState* __tstate = wxPyBeginAllowThreads();
5391 result = wxGetEmailAddress();
5392 wxPyEndAllowThreads(__tstate);
5393 if (PyErr_Occurred()) SWIG_fail;
5394 }
5395 {
5396 #if wxUSE_UNICODE
5397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5398 #else
5399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5400 #endif
5401 }
5402 return resultobj;
5403 fail:
5404 return NULL;
5405 }
5406
5407
5408 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5409 PyObject *resultobj = 0;
5410 wxString result;
5411
5412 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5413 {
5414 PyThreadState* __tstate = wxPyBeginAllowThreads();
5415 result = wxGetHostName();
5416 wxPyEndAllowThreads(__tstate);
5417 if (PyErr_Occurred()) SWIG_fail;
5418 }
5419 {
5420 #if wxUSE_UNICODE
5421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5422 #else
5423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5424 #endif
5425 }
5426 return resultobj;
5427 fail:
5428 return NULL;
5429 }
5430
5431
5432 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5433 PyObject *resultobj = 0;
5434 wxString result;
5435
5436 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5437 {
5438 PyThreadState* __tstate = wxPyBeginAllowThreads();
5439 result = wxGetFullHostName();
5440 wxPyEndAllowThreads(__tstate);
5441 if (PyErr_Occurred()) SWIG_fail;
5442 }
5443 {
5444 #if wxUSE_UNICODE
5445 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5446 #else
5447 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5448 #endif
5449 }
5450 return resultobj;
5451 fail:
5452 return NULL;
5453 }
5454
5455
5456 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5457 PyObject *resultobj = 0;
5458 wxString result;
5459
5460 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5461 {
5462 PyThreadState* __tstate = wxPyBeginAllowThreads();
5463 result = wxGetUserId();
5464 wxPyEndAllowThreads(__tstate);
5465 if (PyErr_Occurred()) SWIG_fail;
5466 }
5467 {
5468 #if wxUSE_UNICODE
5469 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5470 #else
5471 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5472 #endif
5473 }
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5481 PyObject *resultobj = 0;
5482 wxString result;
5483
5484 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5485 {
5486 PyThreadState* __tstate = wxPyBeginAllowThreads();
5487 result = wxGetUserName();
5488 wxPyEndAllowThreads(__tstate);
5489 if (PyErr_Occurred()) SWIG_fail;
5490 }
5491 {
5492 #if wxUSE_UNICODE
5493 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5494 #else
5495 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5496 #endif
5497 }
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5505 PyObject *resultobj = 0;
5506 wxString result;
5507
5508 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5509 {
5510 PyThreadState* __tstate = wxPyBeginAllowThreads();
5511 result = wxGetHomeDir();
5512 wxPyEndAllowThreads(__tstate);
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 {
5516 #if wxUSE_UNICODE
5517 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5518 #else
5519 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5520 #endif
5521 }
5522 return resultobj;
5523 fail:
5524 return NULL;
5525 }
5526
5527
5528 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5529 PyObject *resultobj = 0;
5530 wxString const &arg1_defvalue = wxPyEmptyString ;
5531 wxString *arg1 = (wxString *) &arg1_defvalue ;
5532 wxString result;
5533 bool temp1 = false ;
5534 PyObject * obj0 = 0 ;
5535 char * kwnames[] = {
5536 (char *) "user", NULL
5537 };
5538
5539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5540 if (obj0) {
5541 {
5542 arg1 = wxString_in_helper(obj0);
5543 if (arg1 == NULL) SWIG_fail;
5544 temp1 = true;
5545 }
5546 }
5547 {
5548 PyThreadState* __tstate = wxPyBeginAllowThreads();
5549 result = wxGetUserHome((wxString const &)*arg1);
5550 wxPyEndAllowThreads(__tstate);
5551 if (PyErr_Occurred()) SWIG_fail;
5552 }
5553 {
5554 #if wxUSE_UNICODE
5555 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5556 #else
5557 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5558 #endif
5559 }
5560 {
5561 if (temp1)
5562 delete arg1;
5563 }
5564 return resultobj;
5565 fail:
5566 {
5567 if (temp1)
5568 delete arg1;
5569 }
5570 return NULL;
5571 }
5572
5573
5574 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5575 PyObject *resultobj = 0;
5576 unsigned long result;
5577
5578 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5579 {
5580 PyThreadState* __tstate = wxPyBeginAllowThreads();
5581 result = (unsigned long)wxGetProcessId();
5582 wxPyEndAllowThreads(__tstate);
5583 if (PyErr_Occurred()) SWIG_fail;
5584 }
5585 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5586 return resultobj;
5587 fail:
5588 return NULL;
5589 }
5590
5591
5592 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5593 PyObject *resultobj = 0;
5594
5595 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5596 {
5597 PyThreadState* __tstate = wxPyBeginAllowThreads();
5598 wxTrap();
5599 wxPyEndAllowThreads(__tstate);
5600 if (PyErr_Occurred()) SWIG_fail;
5601 }
5602 resultobj = SWIG_Py_Void();
5603 return resultobj;
5604 fail:
5605 return NULL;
5606 }
5607
5608
5609 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5610 PyObject *resultobj = 0;
5611 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5612 wxString *arg1 = (wxString *) &arg1_defvalue ;
5613 wxString const &arg2_defvalue = wxPyEmptyString ;
5614 wxString *arg2 = (wxString *) &arg2_defvalue ;
5615 wxString const &arg3_defvalue = wxPyEmptyString ;
5616 wxString *arg3 = (wxString *) &arg3_defvalue ;
5617 wxString const &arg4_defvalue = wxPyEmptyString ;
5618 wxString *arg4 = (wxString *) &arg4_defvalue ;
5619 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5620 wxString *arg5 = (wxString *) &arg5_defvalue ;
5621 int arg6 = (int) 0 ;
5622 wxWindow *arg7 = (wxWindow *) NULL ;
5623 int arg8 = (int) -1 ;
5624 int arg9 = (int) -1 ;
5625 wxString result;
5626 bool temp1 = false ;
5627 bool temp2 = false ;
5628 bool temp3 = false ;
5629 bool temp4 = false ;
5630 bool temp5 = false ;
5631 int val6 ;
5632 int ecode6 = 0 ;
5633 void *argp7 = 0 ;
5634 int res7 = 0 ;
5635 int val8 ;
5636 int ecode8 = 0 ;
5637 int val9 ;
5638 int ecode9 = 0 ;
5639 PyObject * obj0 = 0 ;
5640 PyObject * obj1 = 0 ;
5641 PyObject * obj2 = 0 ;
5642 PyObject * obj3 = 0 ;
5643 PyObject * obj4 = 0 ;
5644 PyObject * obj5 = 0 ;
5645 PyObject * obj6 = 0 ;
5646 PyObject * obj7 = 0 ;
5647 PyObject * obj8 = 0 ;
5648 char * kwnames[] = {
5649 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5650 };
5651
5652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5653 if (obj0) {
5654 {
5655 arg1 = wxString_in_helper(obj0);
5656 if (arg1 == NULL) SWIG_fail;
5657 temp1 = true;
5658 }
5659 }
5660 if (obj1) {
5661 {
5662 arg2 = wxString_in_helper(obj1);
5663 if (arg2 == NULL) SWIG_fail;
5664 temp2 = true;
5665 }
5666 }
5667 if (obj2) {
5668 {
5669 arg3 = wxString_in_helper(obj2);
5670 if (arg3 == NULL) SWIG_fail;
5671 temp3 = true;
5672 }
5673 }
5674 if (obj3) {
5675 {
5676 arg4 = wxString_in_helper(obj3);
5677 if (arg4 == NULL) SWIG_fail;
5678 temp4 = true;
5679 }
5680 }
5681 if (obj4) {
5682 {
5683 arg5 = wxString_in_helper(obj4);
5684 if (arg5 == NULL) SWIG_fail;
5685 temp5 = true;
5686 }
5687 }
5688 if (obj5) {
5689 ecode6 = SWIG_AsVal_int(obj5, &val6);
5690 if (!SWIG_IsOK(ecode6)) {
5691 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5692 }
5693 arg6 = static_cast< int >(val6);
5694 }
5695 if (obj6) {
5696 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5697 if (!SWIG_IsOK(res7)) {
5698 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5699 }
5700 arg7 = reinterpret_cast< wxWindow * >(argp7);
5701 }
5702 if (obj7) {
5703 ecode8 = SWIG_AsVal_int(obj7, &val8);
5704 if (!SWIG_IsOK(ecode8)) {
5705 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5706 }
5707 arg8 = static_cast< int >(val8);
5708 }
5709 if (obj8) {
5710 ecode9 = SWIG_AsVal_int(obj8, &val9);
5711 if (!SWIG_IsOK(ecode9)) {
5712 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5713 }
5714 arg9 = static_cast< int >(val9);
5715 }
5716 {
5717 if (!wxPyCheckForApp()) SWIG_fail;
5718 PyThreadState* __tstate = wxPyBeginAllowThreads();
5719 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5720 wxPyEndAllowThreads(__tstate);
5721 if (PyErr_Occurred()) SWIG_fail;
5722 }
5723 {
5724 #if wxUSE_UNICODE
5725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5726 #else
5727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5728 #endif
5729 }
5730 {
5731 if (temp1)
5732 delete arg1;
5733 }
5734 {
5735 if (temp2)
5736 delete arg2;
5737 }
5738 {
5739 if (temp3)
5740 delete arg3;
5741 }
5742 {
5743 if (temp4)
5744 delete arg4;
5745 }
5746 {
5747 if (temp5)
5748 delete arg5;
5749 }
5750 return resultobj;
5751 fail:
5752 {
5753 if (temp1)
5754 delete arg1;
5755 }
5756 {
5757 if (temp2)
5758 delete arg2;
5759 }
5760 {
5761 if (temp3)
5762 delete arg3;
5763 }
5764 {
5765 if (temp4)
5766 delete arg4;
5767 }
5768 {
5769 if (temp5)
5770 delete arg5;
5771 }
5772 return NULL;
5773 }
5774
5775
5776 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5777 PyObject *resultobj = 0;
5778 wxString *arg1 = 0 ;
5779 wxString *arg2 = 0 ;
5780 wxString const &arg3_defvalue = wxPyEmptyString ;
5781 wxString *arg3 = (wxString *) &arg3_defvalue ;
5782 wxWindow *arg4 = (wxWindow *) NULL ;
5783 wxString result;
5784 bool temp1 = false ;
5785 bool temp2 = false ;
5786 bool temp3 = false ;
5787 void *argp4 = 0 ;
5788 int res4 = 0 ;
5789 PyObject * obj0 = 0 ;
5790 PyObject * obj1 = 0 ;
5791 PyObject * obj2 = 0 ;
5792 PyObject * obj3 = 0 ;
5793 char * kwnames[] = {
5794 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5795 };
5796
5797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5798 {
5799 arg1 = wxString_in_helper(obj0);
5800 if (arg1 == NULL) SWIG_fail;
5801 temp1 = true;
5802 }
5803 {
5804 arg2 = wxString_in_helper(obj1);
5805 if (arg2 == NULL) SWIG_fail;
5806 temp2 = true;
5807 }
5808 if (obj2) {
5809 {
5810 arg3 = wxString_in_helper(obj2);
5811 if (arg3 == NULL) SWIG_fail;
5812 temp3 = true;
5813 }
5814 }
5815 if (obj3) {
5816 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5817 if (!SWIG_IsOK(res4)) {
5818 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5819 }
5820 arg4 = reinterpret_cast< wxWindow * >(argp4);
5821 }
5822 {
5823 if (!wxPyCheckForApp()) SWIG_fail;
5824 PyThreadState* __tstate = wxPyBeginAllowThreads();
5825 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5826 wxPyEndAllowThreads(__tstate);
5827 if (PyErr_Occurred()) SWIG_fail;
5828 }
5829 {
5830 #if wxUSE_UNICODE
5831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5832 #else
5833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5834 #endif
5835 }
5836 {
5837 if (temp1)
5838 delete arg1;
5839 }
5840 {
5841 if (temp2)
5842 delete arg2;
5843 }
5844 {
5845 if (temp3)
5846 delete arg3;
5847 }
5848 return resultobj;
5849 fail:
5850 {
5851 if (temp1)
5852 delete arg1;
5853 }
5854 {
5855 if (temp2)
5856 delete arg2;
5857 }
5858 {
5859 if (temp3)
5860 delete arg3;
5861 }
5862 return NULL;
5863 }
5864
5865
5866 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5867 PyObject *resultobj = 0;
5868 wxString *arg1 = 0 ;
5869 wxString *arg2 = 0 ;
5870 wxString const &arg3_defvalue = wxPyEmptyString ;
5871 wxString *arg3 = (wxString *) &arg3_defvalue ;
5872 wxWindow *arg4 = (wxWindow *) NULL ;
5873 wxString result;
5874 bool temp1 = false ;
5875 bool temp2 = false ;
5876 bool temp3 = false ;
5877 void *argp4 = 0 ;
5878 int res4 = 0 ;
5879 PyObject * obj0 = 0 ;
5880 PyObject * obj1 = 0 ;
5881 PyObject * obj2 = 0 ;
5882 PyObject * obj3 = 0 ;
5883 char * kwnames[] = {
5884 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5885 };
5886
5887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5888 {
5889 arg1 = wxString_in_helper(obj0);
5890 if (arg1 == NULL) SWIG_fail;
5891 temp1 = true;
5892 }
5893 {
5894 arg2 = wxString_in_helper(obj1);
5895 if (arg2 == NULL) SWIG_fail;
5896 temp2 = true;
5897 }
5898 if (obj2) {
5899 {
5900 arg3 = wxString_in_helper(obj2);
5901 if (arg3 == NULL) SWIG_fail;
5902 temp3 = true;
5903 }
5904 }
5905 if (obj3) {
5906 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5907 if (!SWIG_IsOK(res4)) {
5908 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5909 }
5910 arg4 = reinterpret_cast< wxWindow * >(argp4);
5911 }
5912 {
5913 if (!wxPyCheckForApp()) SWIG_fail;
5914 PyThreadState* __tstate = wxPyBeginAllowThreads();
5915 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5916 wxPyEndAllowThreads(__tstate);
5917 if (PyErr_Occurred()) SWIG_fail;
5918 }
5919 {
5920 #if wxUSE_UNICODE
5921 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5922 #else
5923 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5924 #endif
5925 }
5926 {
5927 if (temp1)
5928 delete arg1;
5929 }
5930 {
5931 if (temp2)
5932 delete arg2;
5933 }
5934 {
5935 if (temp3)
5936 delete arg3;
5937 }
5938 return resultobj;
5939 fail:
5940 {
5941 if (temp1)
5942 delete arg1;
5943 }
5944 {
5945 if (temp2)
5946 delete arg2;
5947 }
5948 {
5949 if (temp3)
5950 delete arg3;
5951 }
5952 return NULL;
5953 }
5954
5955
5956 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5957 PyObject *resultobj = 0;
5958 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5959 wxString *arg1 = (wxString *) &arg1_defvalue ;
5960 wxString const &arg2_defvalue = wxPyEmptyString ;
5961 wxString *arg2 = (wxString *) &arg2_defvalue ;
5962 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5963 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5964 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5965 wxWindow *arg5 = (wxWindow *) NULL ;
5966 wxString result;
5967 bool temp1 = false ;
5968 bool temp2 = false ;
5969 long val3 ;
5970 int ecode3 = 0 ;
5971 wxPoint temp4 ;
5972 void *argp5 = 0 ;
5973 int res5 = 0 ;
5974 PyObject * obj0 = 0 ;
5975 PyObject * obj1 = 0 ;
5976 PyObject * obj2 = 0 ;
5977 PyObject * obj3 = 0 ;
5978 PyObject * obj4 = 0 ;
5979 char * kwnames[] = {
5980 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5981 };
5982
5983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5984 if (obj0) {
5985 {
5986 arg1 = wxString_in_helper(obj0);
5987 if (arg1 == NULL) SWIG_fail;
5988 temp1 = true;
5989 }
5990 }
5991 if (obj1) {
5992 {
5993 arg2 = wxString_in_helper(obj1);
5994 if (arg2 == NULL) SWIG_fail;
5995 temp2 = true;
5996 }
5997 }
5998 if (obj2) {
5999 ecode3 = SWIG_AsVal_long(obj2, &val3);
6000 if (!SWIG_IsOK(ecode3)) {
6001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
6002 }
6003 arg3 = static_cast< long >(val3);
6004 }
6005 if (obj3) {
6006 {
6007 arg4 = &temp4;
6008 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6009 }
6010 }
6011 if (obj4) {
6012 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6013 if (!SWIG_IsOK(res5)) {
6014 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6015 }
6016 arg5 = reinterpret_cast< wxWindow * >(argp5);
6017 }
6018 {
6019 if (!wxPyCheckForApp()) SWIG_fail;
6020 PyThreadState* __tstate = wxPyBeginAllowThreads();
6021 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6022 wxPyEndAllowThreads(__tstate);
6023 if (PyErr_Occurred()) SWIG_fail;
6024 }
6025 {
6026 #if wxUSE_UNICODE
6027 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6028 #else
6029 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6030 #endif
6031 }
6032 {
6033 if (temp1)
6034 delete arg1;
6035 }
6036 {
6037 if (temp2)
6038 delete arg2;
6039 }
6040 return resultobj;
6041 fail:
6042 {
6043 if (temp1)
6044 delete arg1;
6045 }
6046 {
6047 if (temp2)
6048 delete arg2;
6049 }
6050 return NULL;
6051 }
6052
6053
6054 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6055 PyObject *resultobj = 0;
6056 wxString *arg1 = 0 ;
6057 wxString const &arg2_defvalue = wxPyEmptyString ;
6058 wxString *arg2 = (wxString *) &arg2_defvalue ;
6059 wxString const &arg3_defvalue = wxPyEmptyString ;
6060 wxString *arg3 = (wxString *) &arg3_defvalue ;
6061 wxWindow *arg4 = (wxWindow *) NULL ;
6062 int arg5 = (int) -1 ;
6063 int arg6 = (int) -1 ;
6064 bool arg7 = (bool) true ;
6065 wxString result;
6066 bool temp1 = false ;
6067 bool temp2 = false ;
6068 bool temp3 = false ;
6069 void *argp4 = 0 ;
6070 int res4 = 0 ;
6071 int val5 ;
6072 int ecode5 = 0 ;
6073 int val6 ;
6074 int ecode6 = 0 ;
6075 bool val7 ;
6076 int ecode7 = 0 ;
6077 PyObject * obj0 = 0 ;
6078 PyObject * obj1 = 0 ;
6079 PyObject * obj2 = 0 ;
6080 PyObject * obj3 = 0 ;
6081 PyObject * obj4 = 0 ;
6082 PyObject * obj5 = 0 ;
6083 PyObject * obj6 = 0 ;
6084 char * kwnames[] = {
6085 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6086 };
6087
6088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6089 {
6090 arg1 = wxString_in_helper(obj0);
6091 if (arg1 == NULL) SWIG_fail;
6092 temp1 = true;
6093 }
6094 if (obj1) {
6095 {
6096 arg2 = wxString_in_helper(obj1);
6097 if (arg2 == NULL) SWIG_fail;
6098 temp2 = true;
6099 }
6100 }
6101 if (obj2) {
6102 {
6103 arg3 = wxString_in_helper(obj2);
6104 if (arg3 == NULL) SWIG_fail;
6105 temp3 = true;
6106 }
6107 }
6108 if (obj3) {
6109 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6110 if (!SWIG_IsOK(res4)) {
6111 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6112 }
6113 arg4 = reinterpret_cast< wxWindow * >(argp4);
6114 }
6115 if (obj4) {
6116 ecode5 = SWIG_AsVal_int(obj4, &val5);
6117 if (!SWIG_IsOK(ecode5)) {
6118 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6119 }
6120 arg5 = static_cast< int >(val5);
6121 }
6122 if (obj5) {
6123 ecode6 = SWIG_AsVal_int(obj5, &val6);
6124 if (!SWIG_IsOK(ecode6)) {
6125 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6126 }
6127 arg6 = static_cast< int >(val6);
6128 }
6129 if (obj6) {
6130 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6131 if (!SWIG_IsOK(ecode7)) {
6132 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6133 }
6134 arg7 = static_cast< bool >(val7);
6135 }
6136 {
6137 if (!wxPyCheckForApp()) SWIG_fail;
6138 PyThreadState* __tstate = wxPyBeginAllowThreads();
6139 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6140 wxPyEndAllowThreads(__tstate);
6141 if (PyErr_Occurred()) SWIG_fail;
6142 }
6143 {
6144 #if wxUSE_UNICODE
6145 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6146 #else
6147 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6148 #endif
6149 }
6150 {
6151 if (temp1)
6152 delete arg1;
6153 }
6154 {
6155 if (temp2)
6156 delete arg2;
6157 }
6158 {
6159 if (temp3)
6160 delete arg3;
6161 }
6162 return resultobj;
6163 fail:
6164 {
6165 if (temp1)
6166 delete arg1;
6167 }
6168 {
6169 if (temp2)
6170 delete arg2;
6171 }
6172 {
6173 if (temp3)
6174 delete arg3;
6175 }
6176 return NULL;
6177 }
6178
6179
6180 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6181 PyObject *resultobj = 0;
6182 wxString *arg1 = 0 ;
6183 wxString const &arg2_defvalue = wxPyEmptyString ;
6184 wxString *arg2 = (wxString *) &arg2_defvalue ;
6185 wxString const &arg3_defvalue = wxPyEmptyString ;
6186 wxString *arg3 = (wxString *) &arg3_defvalue ;
6187 wxWindow *arg4 = (wxWindow *) NULL ;
6188 wxString result;
6189 bool temp1 = false ;
6190 bool temp2 = false ;
6191 bool temp3 = false ;
6192 void *argp4 = 0 ;
6193 int res4 = 0 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 PyObject * obj2 = 0 ;
6197 PyObject * obj3 = 0 ;
6198 char * kwnames[] = {
6199 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6200 };
6201
6202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6203 {
6204 arg1 = wxString_in_helper(obj0);
6205 if (arg1 == NULL) SWIG_fail;
6206 temp1 = true;
6207 }
6208 if (obj1) {
6209 {
6210 arg2 = wxString_in_helper(obj1);
6211 if (arg2 == NULL) SWIG_fail;
6212 temp2 = true;
6213 }
6214 }
6215 if (obj2) {
6216 {
6217 arg3 = wxString_in_helper(obj2);
6218 if (arg3 == NULL) SWIG_fail;
6219 temp3 = true;
6220 }
6221 }
6222 if (obj3) {
6223 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6224 if (!SWIG_IsOK(res4)) {
6225 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6226 }
6227 arg4 = reinterpret_cast< wxWindow * >(argp4);
6228 }
6229 {
6230 if (!wxPyCheckForApp()) SWIG_fail;
6231 PyThreadState* __tstate = wxPyBeginAllowThreads();
6232 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6233 wxPyEndAllowThreads(__tstate);
6234 if (PyErr_Occurred()) SWIG_fail;
6235 }
6236 {
6237 #if wxUSE_UNICODE
6238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6239 #else
6240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6241 #endif
6242 }
6243 {
6244 if (temp1)
6245 delete arg1;
6246 }
6247 {
6248 if (temp2)
6249 delete arg2;
6250 }
6251 {
6252 if (temp3)
6253 delete arg3;
6254 }
6255 return resultobj;
6256 fail:
6257 {
6258 if (temp1)
6259 delete arg1;
6260 }
6261 {
6262 if (temp2)
6263 delete arg2;
6264 }
6265 {
6266 if (temp3)
6267 delete arg3;
6268 }
6269 return NULL;
6270 }
6271
6272
6273 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6274 PyObject *resultobj = 0;
6275 wxString *arg1 = 0 ;
6276 wxString *arg2 = 0 ;
6277 int arg3 ;
6278 wxString *arg4 = (wxString *) 0 ;
6279 wxWindow *arg5 = (wxWindow *) NULL ;
6280 int arg6 = (int) -1 ;
6281 int arg7 = (int) -1 ;
6282 bool arg8 = (bool) true ;
6283 int arg9 = (int) 150 ;
6284 int arg10 = (int) 200 ;
6285 wxString result;
6286 bool temp1 = false ;
6287 bool temp2 = false ;
6288 void *argp5 = 0 ;
6289 int res5 = 0 ;
6290 int val6 ;
6291 int ecode6 = 0 ;
6292 int val7 ;
6293 int ecode7 = 0 ;
6294 bool val8 ;
6295 int ecode8 = 0 ;
6296 int val9 ;
6297 int ecode9 = 0 ;
6298 int val10 ;
6299 int ecode10 = 0 ;
6300 PyObject * obj0 = 0 ;
6301 PyObject * obj1 = 0 ;
6302 PyObject * obj2 = 0 ;
6303 PyObject * obj3 = 0 ;
6304 PyObject * obj4 = 0 ;
6305 PyObject * obj5 = 0 ;
6306 PyObject * obj6 = 0 ;
6307 PyObject * obj7 = 0 ;
6308 PyObject * obj8 = 0 ;
6309 char * kwnames[] = {
6310 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6311 };
6312
6313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6314 {
6315 arg1 = wxString_in_helper(obj0);
6316 if (arg1 == NULL) SWIG_fail;
6317 temp1 = true;
6318 }
6319 {
6320 arg2 = wxString_in_helper(obj1);
6321 if (arg2 == NULL) SWIG_fail;
6322 temp2 = true;
6323 }
6324 {
6325 arg3 = PyList_Size(obj2);
6326 arg4 = wxString_LIST_helper(obj2);
6327 if (arg4 == NULL) SWIG_fail;
6328 }
6329 if (obj3) {
6330 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6331 if (!SWIG_IsOK(res5)) {
6332 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6333 }
6334 arg5 = reinterpret_cast< wxWindow * >(argp5);
6335 }
6336 if (obj4) {
6337 ecode6 = SWIG_AsVal_int(obj4, &val6);
6338 if (!SWIG_IsOK(ecode6)) {
6339 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6340 }
6341 arg6 = static_cast< int >(val6);
6342 }
6343 if (obj5) {
6344 ecode7 = SWIG_AsVal_int(obj5, &val7);
6345 if (!SWIG_IsOK(ecode7)) {
6346 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6347 }
6348 arg7 = static_cast< int >(val7);
6349 }
6350 if (obj6) {
6351 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6352 if (!SWIG_IsOK(ecode8)) {
6353 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6354 }
6355 arg8 = static_cast< bool >(val8);
6356 }
6357 if (obj7) {
6358 ecode9 = SWIG_AsVal_int(obj7, &val9);
6359 if (!SWIG_IsOK(ecode9)) {
6360 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6361 }
6362 arg9 = static_cast< int >(val9);
6363 }
6364 if (obj8) {
6365 ecode10 = SWIG_AsVal_int(obj8, &val10);
6366 if (!SWIG_IsOK(ecode10)) {
6367 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6368 }
6369 arg10 = static_cast< int >(val10);
6370 }
6371 {
6372 if (!wxPyCheckForApp()) SWIG_fail;
6373 PyThreadState* __tstate = wxPyBeginAllowThreads();
6374 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6375 wxPyEndAllowThreads(__tstate);
6376 if (PyErr_Occurred()) SWIG_fail;
6377 }
6378 {
6379 #if wxUSE_UNICODE
6380 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6381 #else
6382 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6383 #endif
6384 }
6385 {
6386 if (temp1)
6387 delete arg1;
6388 }
6389 {
6390 if (temp2)
6391 delete arg2;
6392 }
6393 {
6394 if (arg4) delete [] arg4;
6395 }
6396 return resultobj;
6397 fail:
6398 {
6399 if (temp1)
6400 delete arg1;
6401 }
6402 {
6403 if (temp2)
6404 delete arg2;
6405 }
6406 {
6407 if (arg4) delete [] arg4;
6408 }
6409 return NULL;
6410 }
6411
6412
6413 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6414 PyObject *resultobj = 0;
6415 wxString *arg1 = 0 ;
6416 wxString *arg2 = 0 ;
6417 int arg3 ;
6418 wxString *arg4 = (wxString *) 0 ;
6419 wxWindow *arg5 = (wxWindow *) NULL ;
6420 int arg6 = (int) -1 ;
6421 int arg7 = (int) -1 ;
6422 bool arg8 = (bool) true ;
6423 int arg9 = (int) 150 ;
6424 int arg10 = (int) 200 ;
6425 int result;
6426 bool temp1 = false ;
6427 bool temp2 = false ;
6428 void *argp5 = 0 ;
6429 int res5 = 0 ;
6430 int val6 ;
6431 int ecode6 = 0 ;
6432 int val7 ;
6433 int ecode7 = 0 ;
6434 bool val8 ;
6435 int ecode8 = 0 ;
6436 int val9 ;
6437 int ecode9 = 0 ;
6438 int val10 ;
6439 int ecode10 = 0 ;
6440 PyObject * obj0 = 0 ;
6441 PyObject * obj1 = 0 ;
6442 PyObject * obj2 = 0 ;
6443 PyObject * obj3 = 0 ;
6444 PyObject * obj4 = 0 ;
6445 PyObject * obj5 = 0 ;
6446 PyObject * obj6 = 0 ;
6447 PyObject * obj7 = 0 ;
6448 PyObject * obj8 = 0 ;
6449 char * kwnames[] = {
6450 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6451 };
6452
6453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6454 {
6455 arg1 = wxString_in_helper(obj0);
6456 if (arg1 == NULL) SWIG_fail;
6457 temp1 = true;
6458 }
6459 {
6460 arg2 = wxString_in_helper(obj1);
6461 if (arg2 == NULL) SWIG_fail;
6462 temp2 = true;
6463 }
6464 {
6465 arg3 = PyList_Size(obj2);
6466 arg4 = wxString_LIST_helper(obj2);
6467 if (arg4 == NULL) SWIG_fail;
6468 }
6469 if (obj3) {
6470 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6471 if (!SWIG_IsOK(res5)) {
6472 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6473 }
6474 arg5 = reinterpret_cast< wxWindow * >(argp5);
6475 }
6476 if (obj4) {
6477 ecode6 = SWIG_AsVal_int(obj4, &val6);
6478 if (!SWIG_IsOK(ecode6)) {
6479 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6480 }
6481 arg6 = static_cast< int >(val6);
6482 }
6483 if (obj5) {
6484 ecode7 = SWIG_AsVal_int(obj5, &val7);
6485 if (!SWIG_IsOK(ecode7)) {
6486 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6487 }
6488 arg7 = static_cast< int >(val7);
6489 }
6490 if (obj6) {
6491 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6492 if (!SWIG_IsOK(ecode8)) {
6493 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6494 }
6495 arg8 = static_cast< bool >(val8);
6496 }
6497 if (obj7) {
6498 ecode9 = SWIG_AsVal_int(obj7, &val9);
6499 if (!SWIG_IsOK(ecode9)) {
6500 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6501 }
6502 arg9 = static_cast< int >(val9);
6503 }
6504 if (obj8) {
6505 ecode10 = SWIG_AsVal_int(obj8, &val10);
6506 if (!SWIG_IsOK(ecode10)) {
6507 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6508 }
6509 arg10 = static_cast< int >(val10);
6510 }
6511 {
6512 if (!wxPyCheckForApp()) SWIG_fail;
6513 PyThreadState* __tstate = wxPyBeginAllowThreads();
6514 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6515 wxPyEndAllowThreads(__tstate);
6516 if (PyErr_Occurred()) SWIG_fail;
6517 }
6518 resultobj = SWIG_From_int(static_cast< int >(result));
6519 {
6520 if (temp1)
6521 delete arg1;
6522 }
6523 {
6524 if (temp2)
6525 delete arg2;
6526 }
6527 {
6528 if (arg4) delete [] arg4;
6529 }
6530 return resultobj;
6531 fail:
6532 {
6533 if (temp1)
6534 delete arg1;
6535 }
6536 {
6537 if (temp2)
6538 delete arg2;
6539 }
6540 {
6541 if (arg4) delete [] arg4;
6542 }
6543 return NULL;
6544 }
6545
6546
6547 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6548 PyObject *resultobj = 0;
6549 wxString *arg1 = 0 ;
6550 wxString const &arg2_defvalue = wxPyEmptyString ;
6551 wxString *arg2 = (wxString *) &arg2_defvalue ;
6552 int arg3 = (int) wxOK|wxCENTRE ;
6553 wxWindow *arg4 = (wxWindow *) NULL ;
6554 int arg5 = (int) -1 ;
6555 int arg6 = (int) -1 ;
6556 int result;
6557 bool temp1 = false ;
6558 bool temp2 = false ;
6559 int val3 ;
6560 int ecode3 = 0 ;
6561 void *argp4 = 0 ;
6562 int res4 = 0 ;
6563 int val5 ;
6564 int ecode5 = 0 ;
6565 int val6 ;
6566 int ecode6 = 0 ;
6567 PyObject * obj0 = 0 ;
6568 PyObject * obj1 = 0 ;
6569 PyObject * obj2 = 0 ;
6570 PyObject * obj3 = 0 ;
6571 PyObject * obj4 = 0 ;
6572 PyObject * obj5 = 0 ;
6573 char * kwnames[] = {
6574 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6575 };
6576
6577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6578 {
6579 arg1 = wxString_in_helper(obj0);
6580 if (arg1 == NULL) SWIG_fail;
6581 temp1 = true;
6582 }
6583 if (obj1) {
6584 {
6585 arg2 = wxString_in_helper(obj1);
6586 if (arg2 == NULL) SWIG_fail;
6587 temp2 = true;
6588 }
6589 }
6590 if (obj2) {
6591 ecode3 = SWIG_AsVal_int(obj2, &val3);
6592 if (!SWIG_IsOK(ecode3)) {
6593 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6594 }
6595 arg3 = static_cast< int >(val3);
6596 }
6597 if (obj3) {
6598 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6599 if (!SWIG_IsOK(res4)) {
6600 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6601 }
6602 arg4 = reinterpret_cast< wxWindow * >(argp4);
6603 }
6604 if (obj4) {
6605 ecode5 = SWIG_AsVal_int(obj4, &val5);
6606 if (!SWIG_IsOK(ecode5)) {
6607 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6608 }
6609 arg5 = static_cast< int >(val5);
6610 }
6611 if (obj5) {
6612 ecode6 = SWIG_AsVal_int(obj5, &val6);
6613 if (!SWIG_IsOK(ecode6)) {
6614 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6615 }
6616 arg6 = static_cast< int >(val6);
6617 }
6618 {
6619 if (!wxPyCheckForApp()) SWIG_fail;
6620 PyThreadState* __tstate = wxPyBeginAllowThreads();
6621 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6622 wxPyEndAllowThreads(__tstate);
6623 if (PyErr_Occurred()) SWIG_fail;
6624 }
6625 resultobj = SWIG_From_int(static_cast< int >(result));
6626 {
6627 if (temp1)
6628 delete arg1;
6629 }
6630 {
6631 if (temp2)
6632 delete arg2;
6633 }
6634 return resultobj;
6635 fail:
6636 {
6637 if (temp1)
6638 delete arg1;
6639 }
6640 {
6641 if (temp2)
6642 delete arg2;
6643 }
6644 return NULL;
6645 }
6646
6647
6648 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6649 PyObject *resultobj = 0;
6650 wxString *arg1 = 0 ;
6651 wxString *arg2 = 0 ;
6652 wxString *arg3 = 0 ;
6653 long arg4 ;
6654 long arg5 = (long) 0 ;
6655 long arg6 = (long) 100 ;
6656 wxWindow *arg7 = (wxWindow *) NULL ;
6657 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6658 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6659 long result;
6660 bool temp1 = false ;
6661 bool temp2 = false ;
6662 bool temp3 = false ;
6663 long val4 ;
6664 int ecode4 = 0 ;
6665 long val5 ;
6666 int ecode5 = 0 ;
6667 long val6 ;
6668 int ecode6 = 0 ;
6669 void *argp7 = 0 ;
6670 int res7 = 0 ;
6671 wxPoint temp8 ;
6672 PyObject * obj0 = 0 ;
6673 PyObject * obj1 = 0 ;
6674 PyObject * obj2 = 0 ;
6675 PyObject * obj3 = 0 ;
6676 PyObject * obj4 = 0 ;
6677 PyObject * obj5 = 0 ;
6678 PyObject * obj6 = 0 ;
6679 PyObject * obj7 = 0 ;
6680 char * kwnames[] = {
6681 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6682 };
6683
6684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6685 {
6686 arg1 = wxString_in_helper(obj0);
6687 if (arg1 == NULL) SWIG_fail;
6688 temp1 = true;
6689 }
6690 {
6691 arg2 = wxString_in_helper(obj1);
6692 if (arg2 == NULL) SWIG_fail;
6693 temp2 = true;
6694 }
6695 {
6696 arg3 = wxString_in_helper(obj2);
6697 if (arg3 == NULL) SWIG_fail;
6698 temp3 = true;
6699 }
6700 ecode4 = SWIG_AsVal_long(obj3, &val4);
6701 if (!SWIG_IsOK(ecode4)) {
6702 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6703 }
6704 arg4 = static_cast< long >(val4);
6705 if (obj4) {
6706 ecode5 = SWIG_AsVal_long(obj4, &val5);
6707 if (!SWIG_IsOK(ecode5)) {
6708 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6709 }
6710 arg5 = static_cast< long >(val5);
6711 }
6712 if (obj5) {
6713 ecode6 = SWIG_AsVal_long(obj5, &val6);
6714 if (!SWIG_IsOK(ecode6)) {
6715 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6716 }
6717 arg6 = static_cast< long >(val6);
6718 }
6719 if (obj6) {
6720 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6721 if (!SWIG_IsOK(res7)) {
6722 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6723 }
6724 arg7 = reinterpret_cast< wxWindow * >(argp7);
6725 }
6726 if (obj7) {
6727 {
6728 arg8 = &temp8;
6729 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6730 }
6731 }
6732 {
6733 if (!wxPyCheckForApp()) SWIG_fail;
6734 PyThreadState* __tstate = wxPyBeginAllowThreads();
6735 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6736 wxPyEndAllowThreads(__tstate);
6737 if (PyErr_Occurred()) SWIG_fail;
6738 }
6739 resultobj = SWIG_From_long(static_cast< long >(result));
6740 {
6741 if (temp1)
6742 delete arg1;
6743 }
6744 {
6745 if (temp2)
6746 delete arg2;
6747 }
6748 {
6749 if (temp3)
6750 delete arg3;
6751 }
6752 return resultobj;
6753 fail:
6754 {
6755 if (temp1)
6756 delete arg1;
6757 }
6758 {
6759 if (temp2)
6760 delete arg2;
6761 }
6762 {
6763 if (temp3)
6764 delete arg3;
6765 }
6766 return NULL;
6767 }
6768
6769
6770 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6771 PyObject *resultobj = 0;
6772 bool result;
6773
6774 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6775 {
6776 if (!wxPyCheckForApp()) SWIG_fail;
6777 PyThreadState* __tstate = wxPyBeginAllowThreads();
6778 result = (bool)wxColourDisplay();
6779 wxPyEndAllowThreads(__tstate);
6780 if (PyErr_Occurred()) SWIG_fail;
6781 }
6782 {
6783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6784 }
6785 return resultobj;
6786 fail:
6787 return NULL;
6788 }
6789
6790
6791 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6792 PyObject *resultobj = 0;
6793 int result;
6794
6795 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6796 {
6797 if (!wxPyCheckForApp()) SWIG_fail;
6798 PyThreadState* __tstate = wxPyBeginAllowThreads();
6799 result = (int)wxDisplayDepth();
6800 wxPyEndAllowThreads(__tstate);
6801 if (PyErr_Occurred()) SWIG_fail;
6802 }
6803 resultobj = SWIG_From_int(static_cast< int >(result));
6804 return resultobj;
6805 fail:
6806 return NULL;
6807 }
6808
6809
6810 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6811 PyObject *resultobj = 0;
6812 int result;
6813
6814 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6815 {
6816 if (!wxPyCheckForApp()) SWIG_fail;
6817 PyThreadState* __tstate = wxPyBeginAllowThreads();
6818 result = (int)wxGetDisplayDepth();
6819 wxPyEndAllowThreads(__tstate);
6820 if (PyErr_Occurred()) SWIG_fail;
6821 }
6822 resultobj = SWIG_From_int(static_cast< int >(result));
6823 return resultobj;
6824 fail:
6825 return NULL;
6826 }
6827
6828
6829 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6830 PyObject *resultobj = 0;
6831 int *arg1 = (int *) 0 ;
6832 int *arg2 = (int *) 0 ;
6833 int temp1 ;
6834 int res1 = SWIG_TMPOBJ ;
6835 int temp2 ;
6836 int res2 = SWIG_TMPOBJ ;
6837
6838 arg1 = &temp1;
6839 arg2 = &temp2;
6840 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6841 {
6842 if (!wxPyCheckForApp()) SWIG_fail;
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 wxDisplaySize(arg1,arg2);
6845 wxPyEndAllowThreads(__tstate);
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 resultobj = SWIG_Py_Void();
6849 if (SWIG_IsTmpObj(res1)) {
6850 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6851 } else {
6852 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6853 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6854 }
6855 if (SWIG_IsTmpObj(res2)) {
6856 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6857 } else {
6858 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6859 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6860 }
6861 return resultobj;
6862 fail:
6863 return NULL;
6864 }
6865
6866
6867 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6868 PyObject *resultobj = 0;
6869 wxSize result;
6870
6871 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6872 {
6873 if (!wxPyCheckForApp()) SWIG_fail;
6874 PyThreadState* __tstate = wxPyBeginAllowThreads();
6875 result = wxGetDisplaySize();
6876 wxPyEndAllowThreads(__tstate);
6877 if (PyErr_Occurred()) SWIG_fail;
6878 }
6879 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6880 return resultobj;
6881 fail:
6882 return NULL;
6883 }
6884
6885
6886 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6887 PyObject *resultobj = 0;
6888 int *arg1 = (int *) 0 ;
6889 int *arg2 = (int *) 0 ;
6890 int temp1 ;
6891 int res1 = SWIG_TMPOBJ ;
6892 int temp2 ;
6893 int res2 = SWIG_TMPOBJ ;
6894
6895 arg1 = &temp1;
6896 arg2 = &temp2;
6897 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6898 {
6899 if (!wxPyCheckForApp()) SWIG_fail;
6900 PyThreadState* __tstate = wxPyBeginAllowThreads();
6901 wxDisplaySizeMM(arg1,arg2);
6902 wxPyEndAllowThreads(__tstate);
6903 if (PyErr_Occurred()) SWIG_fail;
6904 }
6905 resultobj = SWIG_Py_Void();
6906 if (SWIG_IsTmpObj(res1)) {
6907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6908 } else {
6909 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6911 }
6912 if (SWIG_IsTmpObj(res2)) {
6913 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6914 } else {
6915 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6916 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6917 }
6918 return resultobj;
6919 fail:
6920 return NULL;
6921 }
6922
6923
6924 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6925 PyObject *resultobj = 0;
6926 wxSize result;
6927
6928 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6929 {
6930 if (!wxPyCheckForApp()) SWIG_fail;
6931 PyThreadState* __tstate = wxPyBeginAllowThreads();
6932 result = wxGetDisplaySizeMM();
6933 wxPyEndAllowThreads(__tstate);
6934 if (PyErr_Occurred()) SWIG_fail;
6935 }
6936 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6937 return resultobj;
6938 fail:
6939 return NULL;
6940 }
6941
6942
6943 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6944 PyObject *resultobj = 0;
6945 int *arg1 = (int *) 0 ;
6946 int *arg2 = (int *) 0 ;
6947 int *arg3 = (int *) 0 ;
6948 int *arg4 = (int *) 0 ;
6949 int temp1 ;
6950 int res1 = SWIG_TMPOBJ ;
6951 int temp2 ;
6952 int res2 = SWIG_TMPOBJ ;
6953 int temp3 ;
6954 int res3 = SWIG_TMPOBJ ;
6955 int temp4 ;
6956 int res4 = SWIG_TMPOBJ ;
6957
6958 arg1 = &temp1;
6959 arg2 = &temp2;
6960 arg3 = &temp3;
6961 arg4 = &temp4;
6962 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6963 {
6964 if (!wxPyCheckForApp()) SWIG_fail;
6965 PyThreadState* __tstate = wxPyBeginAllowThreads();
6966 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6967 wxPyEndAllowThreads(__tstate);
6968 if (PyErr_Occurred()) SWIG_fail;
6969 }
6970 resultobj = SWIG_Py_Void();
6971 if (SWIG_IsTmpObj(res1)) {
6972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6973 } else {
6974 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6975 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6976 }
6977 if (SWIG_IsTmpObj(res2)) {
6978 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6979 } else {
6980 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6981 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6982 }
6983 if (SWIG_IsTmpObj(res3)) {
6984 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6985 } else {
6986 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6988 }
6989 if (SWIG_IsTmpObj(res4)) {
6990 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6991 } else {
6992 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6993 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6994 }
6995 return resultobj;
6996 fail:
6997 return NULL;
6998 }
6999
7000
7001 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7002 PyObject *resultobj = 0;
7003 wxRect result;
7004
7005 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
7006 {
7007 if (!wxPyCheckForApp()) SWIG_fail;
7008 PyThreadState* __tstate = wxPyBeginAllowThreads();
7009 result = wxGetClientDisplayRect();
7010 wxPyEndAllowThreads(__tstate);
7011 if (PyErr_Occurred()) SWIG_fail;
7012 }
7013 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7014 return resultobj;
7015 fail:
7016 return NULL;
7017 }
7018
7019
7020 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7021 PyObject *resultobj = 0;
7022 wxCursor *arg1 = 0 ;
7023 void *argp1 = 0 ;
7024 int res1 = 0 ;
7025 PyObject * obj0 = 0 ;
7026 char * kwnames[] = {
7027 (char *) "cursor", NULL
7028 };
7029
7030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7031 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7032 if (!SWIG_IsOK(res1)) {
7033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7034 }
7035 if (!argp1) {
7036 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7037 }
7038 arg1 = reinterpret_cast< wxCursor * >(argp1);
7039 {
7040 if (!wxPyCheckForApp()) SWIG_fail;
7041 PyThreadState* __tstate = wxPyBeginAllowThreads();
7042 wxSetCursor(*arg1);
7043 wxPyEndAllowThreads(__tstate);
7044 if (PyErr_Occurred()) SWIG_fail;
7045 }
7046 resultobj = SWIG_Py_Void();
7047 return resultobj;
7048 fail:
7049 return NULL;
7050 }
7051
7052
7053 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7054 PyObject *resultobj = 0;
7055 void *result = 0 ;
7056
7057 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7058 {
7059 if (!wxPyCheckForApp()) SWIG_fail;
7060 PyThreadState* __tstate = wxPyBeginAllowThreads();
7061 result = (void *)wxGetXDisplay();
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7066 return resultobj;
7067 fail:
7068 return NULL;
7069 }
7070
7071
7072 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7073 PyObject *resultobj = 0;
7074 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7075 void *argp1 = 0 ;
7076 int res1 = 0 ;
7077 PyObject * obj0 = 0 ;
7078 char * kwnames[] = {
7079 (char *) "cursor", NULL
7080 };
7081
7082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7083 if (obj0) {
7084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7085 if (!SWIG_IsOK(res1)) {
7086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7087 }
7088 arg1 = reinterpret_cast< wxCursor * >(argp1);
7089 }
7090 {
7091 if (!wxPyCheckForApp()) SWIG_fail;
7092 PyThreadState* __tstate = wxPyBeginAllowThreads();
7093 wxBeginBusyCursor(arg1);
7094 wxPyEndAllowThreads(__tstate);
7095 if (PyErr_Occurred()) SWIG_fail;
7096 }
7097 resultobj = SWIG_Py_Void();
7098 return resultobj;
7099 fail:
7100 return NULL;
7101 }
7102
7103
7104 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7105 PyObject *resultobj = 0;
7106 wxPoint result;
7107
7108 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7109 {
7110 if (!wxPyCheckForApp()) SWIG_fail;
7111 PyThreadState* __tstate = wxPyBeginAllowThreads();
7112 result = wxGetMousePosition();
7113 wxPyEndAllowThreads(__tstate);
7114 if (PyErr_Occurred()) SWIG_fail;
7115 }
7116 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7124 PyObject *resultobj = 0;
7125 wxWindow *result = 0 ;
7126
7127 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7128 {
7129 if (!wxPyCheckForApp()) SWIG_fail;
7130 PyThreadState* __tstate = wxPyBeginAllowThreads();
7131 result = (wxWindow *)FindWindowAtPointer();
7132 wxPyEndAllowThreads(__tstate);
7133 if (PyErr_Occurred()) SWIG_fail;
7134 }
7135 {
7136 resultobj = wxPyMake_wxObject(result, 0);
7137 }
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7145 PyObject *resultobj = 0;
7146 wxWindow *result = 0 ;
7147
7148 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7149 {
7150 if (!wxPyCheckForApp()) SWIG_fail;
7151 PyThreadState* __tstate = wxPyBeginAllowThreads();
7152 result = (wxWindow *)wxGetActiveWindow();
7153 wxPyEndAllowThreads(__tstate);
7154 if (PyErr_Occurred()) SWIG_fail;
7155 }
7156 {
7157 resultobj = wxPyMake_wxObject(result, 0);
7158 }
7159 return resultobj;
7160 fail:
7161 return NULL;
7162 }
7163
7164
7165 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7166 PyObject *resultobj = 0;
7167 wxPoint *arg1 = 0 ;
7168 wxWindow *result = 0 ;
7169 wxPoint temp1 ;
7170 PyObject * obj0 = 0 ;
7171 char * kwnames[] = {
7172 (char *) "pt", NULL
7173 };
7174
7175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7176 {
7177 arg1 = &temp1;
7178 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7179 }
7180 {
7181 if (!wxPyCheckForApp()) SWIG_fail;
7182 PyThreadState* __tstate = wxPyBeginAllowThreads();
7183 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7184 wxPyEndAllowThreads(__tstate);
7185 if (PyErr_Occurred()) SWIG_fail;
7186 }
7187 {
7188 resultobj = wxPyMake_wxObject(result, 0);
7189 }
7190 return resultobj;
7191 fail:
7192 return NULL;
7193 }
7194
7195
7196 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7197 PyObject *resultobj = 0;
7198 wxPoint *arg1 = 0 ;
7199 wxWindow *result = 0 ;
7200 wxPoint temp1 ;
7201 PyObject * obj0 = 0 ;
7202 char * kwnames[] = {
7203 (char *) "pt", NULL
7204 };
7205
7206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7207 {
7208 arg1 = &temp1;
7209 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7210 }
7211 {
7212 if (!wxPyCheckForApp()) SWIG_fail;
7213 PyThreadState* __tstate = wxPyBeginAllowThreads();
7214 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7215 wxPyEndAllowThreads(__tstate);
7216 if (PyErr_Occurred()) SWIG_fail;
7217 }
7218 {
7219 resultobj = wxPyMake_wxObject(result, 0);
7220 }
7221 return resultobj;
7222 fail:
7223 return NULL;
7224 }
7225
7226
7227 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7228 PyObject *resultobj = 0;
7229 wxWindow *arg1 = (wxWindow *) 0 ;
7230 wxWindow *result = 0 ;
7231 void *argp1 = 0 ;
7232 int res1 = 0 ;
7233 PyObject * obj0 = 0 ;
7234 char * kwnames[] = {
7235 (char *) "win", NULL
7236 };
7237
7238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7240 if (!SWIG_IsOK(res1)) {
7241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7242 }
7243 arg1 = reinterpret_cast< wxWindow * >(argp1);
7244 {
7245 if (!wxPyCheckForApp()) SWIG_fail;
7246 PyThreadState* __tstate = wxPyBeginAllowThreads();
7247 result = (wxWindow *)wxGetTopLevelParent(arg1);
7248 wxPyEndAllowThreads(__tstate);
7249 if (PyErr_Occurred()) SWIG_fail;
7250 }
7251 {
7252 resultobj = wxPyMake_wxObject(result, 0);
7253 }
7254 return resultobj;
7255 fail:
7256 return NULL;
7257 }
7258
7259
7260 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7261 PyObject *resultobj = 0;
7262 wxString *arg1 = 0 ;
7263 bool result;
7264 bool temp1 = false ;
7265 PyObject * obj0 = 0 ;
7266 char * kwnames[] = {
7267 (char *) "url", NULL
7268 };
7269
7270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7271 {
7272 arg1 = wxString_in_helper(obj0);
7273 if (arg1 == NULL) SWIG_fail;
7274 temp1 = true;
7275 }
7276 {
7277 PyThreadState* __tstate = wxPyBeginAllowThreads();
7278 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7279 wxPyEndAllowThreads(__tstate);
7280 if (PyErr_Occurred()) SWIG_fail;
7281 }
7282 {
7283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7284 }
7285 {
7286 if (temp1)
7287 delete arg1;
7288 }
7289 return resultobj;
7290 fail:
7291 {
7292 if (temp1)
7293 delete arg1;
7294 }
7295 return NULL;
7296 }
7297
7298
7299 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7300 PyObject *resultobj = 0;
7301 wxKeyCode arg1 ;
7302 bool result;
7303 int val1 ;
7304 int ecode1 = 0 ;
7305 PyObject * obj0 = 0 ;
7306 char * kwnames[] = {
7307 (char *) "key", NULL
7308 };
7309
7310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7311 ecode1 = SWIG_AsVal_int(obj0, &val1);
7312 if (!SWIG_IsOK(ecode1)) {
7313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7314 }
7315 arg1 = static_cast< wxKeyCode >(val1);
7316 {
7317 if (!wxPyCheckForApp()) SWIG_fail;
7318 PyThreadState* __tstate = wxPyBeginAllowThreads();
7319 result = (bool)wxGetKeyState(arg1);
7320 wxPyEndAllowThreads(__tstate);
7321 if (PyErr_Occurred()) SWIG_fail;
7322 }
7323 {
7324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7325 }
7326 return resultobj;
7327 fail:
7328 return NULL;
7329 }
7330
7331
7332 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7333 PyObject *resultobj = 0;
7334 wxMouseState *result = 0 ;
7335
7336 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7337 {
7338 PyThreadState* __tstate = wxPyBeginAllowThreads();
7339 result = (wxMouseState *)new wxMouseState();
7340 wxPyEndAllowThreads(__tstate);
7341 if (PyErr_Occurred()) SWIG_fail;
7342 }
7343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7351 PyObject *resultobj = 0;
7352 wxMouseState *arg1 = (wxMouseState *) 0 ;
7353 void *argp1 = 0 ;
7354 int res1 = 0 ;
7355 PyObject *swig_obj[1] ;
7356
7357 if (!args) SWIG_fail;
7358 swig_obj[0] = args;
7359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7360 if (!SWIG_IsOK(res1)) {
7361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7362 }
7363 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7364 {
7365 PyThreadState* __tstate = wxPyBeginAllowThreads();
7366 delete arg1;
7367
7368 wxPyEndAllowThreads(__tstate);
7369 if (PyErr_Occurred()) SWIG_fail;
7370 }
7371 resultobj = SWIG_Py_Void();
7372 return resultobj;
7373 fail:
7374 return NULL;
7375 }
7376
7377
7378 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7379 PyObject *resultobj = 0;
7380 wxMouseState *arg1 = (wxMouseState *) 0 ;
7381 int result;
7382 void *argp1 = 0 ;
7383 int res1 = 0 ;
7384 PyObject *swig_obj[1] ;
7385
7386 if (!args) SWIG_fail;
7387 swig_obj[0] = args;
7388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7389 if (!SWIG_IsOK(res1)) {
7390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7391 }
7392 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7393 {
7394 PyThreadState* __tstate = wxPyBeginAllowThreads();
7395 result = (int)(arg1)->GetX();
7396 wxPyEndAllowThreads(__tstate);
7397 if (PyErr_Occurred()) SWIG_fail;
7398 }
7399 resultobj = SWIG_From_int(static_cast< int >(result));
7400 return resultobj;
7401 fail:
7402 return NULL;
7403 }
7404
7405
7406 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7407 PyObject *resultobj = 0;
7408 wxMouseState *arg1 = (wxMouseState *) 0 ;
7409 int result;
7410 void *argp1 = 0 ;
7411 int res1 = 0 ;
7412 PyObject *swig_obj[1] ;
7413
7414 if (!args) SWIG_fail;
7415 swig_obj[0] = args;
7416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7417 if (!SWIG_IsOK(res1)) {
7418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7419 }
7420 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7421 {
7422 PyThreadState* __tstate = wxPyBeginAllowThreads();
7423 result = (int)(arg1)->GetY();
7424 wxPyEndAllowThreads(__tstate);
7425 if (PyErr_Occurred()) SWIG_fail;
7426 }
7427 resultobj = SWIG_From_int(static_cast< int >(result));
7428 return resultobj;
7429 fail:
7430 return NULL;
7431 }
7432
7433
7434 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7435 PyObject *resultobj = 0;
7436 wxMouseState *arg1 = (wxMouseState *) 0 ;
7437 bool result;
7438 void *argp1 = 0 ;
7439 int res1 = 0 ;
7440 PyObject *swig_obj[1] ;
7441
7442 if (!args) SWIG_fail;
7443 swig_obj[0] = args;
7444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7445 if (!SWIG_IsOK(res1)) {
7446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7447 }
7448 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7449 {
7450 PyThreadState* __tstate = wxPyBeginAllowThreads();
7451 result = (bool)(arg1)->LeftDown();
7452 wxPyEndAllowThreads(__tstate);
7453 if (PyErr_Occurred()) SWIG_fail;
7454 }
7455 {
7456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7457 }
7458 return resultobj;
7459 fail:
7460 return NULL;
7461 }
7462
7463
7464 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7465 PyObject *resultobj = 0;
7466 wxMouseState *arg1 = (wxMouseState *) 0 ;
7467 bool result;
7468 void *argp1 = 0 ;
7469 int res1 = 0 ;
7470 PyObject *swig_obj[1] ;
7471
7472 if (!args) SWIG_fail;
7473 swig_obj[0] = args;
7474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7475 if (!SWIG_IsOK(res1)) {
7476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7477 }
7478 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7479 {
7480 PyThreadState* __tstate = wxPyBeginAllowThreads();
7481 result = (bool)(arg1)->MiddleDown();
7482 wxPyEndAllowThreads(__tstate);
7483 if (PyErr_Occurred()) SWIG_fail;
7484 }
7485 {
7486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7487 }
7488 return resultobj;
7489 fail:
7490 return NULL;
7491 }
7492
7493
7494 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7495 PyObject *resultobj = 0;
7496 wxMouseState *arg1 = (wxMouseState *) 0 ;
7497 bool result;
7498 void *argp1 = 0 ;
7499 int res1 = 0 ;
7500 PyObject *swig_obj[1] ;
7501
7502 if (!args) SWIG_fail;
7503 swig_obj[0] = args;
7504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7505 if (!SWIG_IsOK(res1)) {
7506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7507 }
7508 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7509 {
7510 PyThreadState* __tstate = wxPyBeginAllowThreads();
7511 result = (bool)(arg1)->RightDown();
7512 wxPyEndAllowThreads(__tstate);
7513 if (PyErr_Occurred()) SWIG_fail;
7514 }
7515 {
7516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7517 }
7518 return resultobj;
7519 fail:
7520 return NULL;
7521 }
7522
7523
7524 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7525 PyObject *resultobj = 0;
7526 wxMouseState *arg1 = (wxMouseState *) 0 ;
7527 bool result;
7528 void *argp1 = 0 ;
7529 int res1 = 0 ;
7530 PyObject *swig_obj[1] ;
7531
7532 if (!args) SWIG_fail;
7533 swig_obj[0] = args;
7534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7535 if (!SWIG_IsOK(res1)) {
7536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7537 }
7538 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7539 {
7540 PyThreadState* __tstate = wxPyBeginAllowThreads();
7541 result = (bool)(arg1)->ControlDown();
7542 wxPyEndAllowThreads(__tstate);
7543 if (PyErr_Occurred()) SWIG_fail;
7544 }
7545 {
7546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7547 }
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7555 PyObject *resultobj = 0;
7556 wxMouseState *arg1 = (wxMouseState *) 0 ;
7557 bool result;
7558 void *argp1 = 0 ;
7559 int res1 = 0 ;
7560 PyObject *swig_obj[1] ;
7561
7562 if (!args) SWIG_fail;
7563 swig_obj[0] = args;
7564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7565 if (!SWIG_IsOK(res1)) {
7566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7567 }
7568 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7569 {
7570 PyThreadState* __tstate = wxPyBeginAllowThreads();
7571 result = (bool)(arg1)->ShiftDown();
7572 wxPyEndAllowThreads(__tstate);
7573 if (PyErr_Occurred()) SWIG_fail;
7574 }
7575 {
7576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7577 }
7578 return resultobj;
7579 fail:
7580 return NULL;
7581 }
7582
7583
7584 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7585 PyObject *resultobj = 0;
7586 wxMouseState *arg1 = (wxMouseState *) 0 ;
7587 bool result;
7588 void *argp1 = 0 ;
7589 int res1 = 0 ;
7590 PyObject *swig_obj[1] ;
7591
7592 if (!args) SWIG_fail;
7593 swig_obj[0] = args;
7594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7595 if (!SWIG_IsOK(res1)) {
7596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7597 }
7598 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7599 {
7600 PyThreadState* __tstate = wxPyBeginAllowThreads();
7601 result = (bool)(arg1)->AltDown();
7602 wxPyEndAllowThreads(__tstate);
7603 if (PyErr_Occurred()) SWIG_fail;
7604 }
7605 {
7606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7607 }
7608 return resultobj;
7609 fail:
7610 return NULL;
7611 }
7612
7613
7614 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7615 PyObject *resultobj = 0;
7616 wxMouseState *arg1 = (wxMouseState *) 0 ;
7617 bool result;
7618 void *argp1 = 0 ;
7619 int res1 = 0 ;
7620 PyObject *swig_obj[1] ;
7621
7622 if (!args) SWIG_fail;
7623 swig_obj[0] = args;
7624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7625 if (!SWIG_IsOK(res1)) {
7626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7627 }
7628 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7629 {
7630 PyThreadState* __tstate = wxPyBeginAllowThreads();
7631 result = (bool)(arg1)->MetaDown();
7632 wxPyEndAllowThreads(__tstate);
7633 if (PyErr_Occurred()) SWIG_fail;
7634 }
7635 {
7636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7637 }
7638 return resultobj;
7639 fail:
7640 return NULL;
7641 }
7642
7643
7644 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7645 PyObject *resultobj = 0;
7646 wxMouseState *arg1 = (wxMouseState *) 0 ;
7647 bool result;
7648 void *argp1 = 0 ;
7649 int res1 = 0 ;
7650 PyObject *swig_obj[1] ;
7651
7652 if (!args) SWIG_fail;
7653 swig_obj[0] = args;
7654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7655 if (!SWIG_IsOK(res1)) {
7656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7657 }
7658 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7659 {
7660 PyThreadState* __tstate = wxPyBeginAllowThreads();
7661 result = (bool)(arg1)->CmdDown();
7662 wxPyEndAllowThreads(__tstate);
7663 if (PyErr_Occurred()) SWIG_fail;
7664 }
7665 {
7666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7667 }
7668 return resultobj;
7669 fail:
7670 return NULL;
7671 }
7672
7673
7674 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7675 PyObject *resultobj = 0;
7676 wxMouseState *arg1 = (wxMouseState *) 0 ;
7677 int arg2 ;
7678 void *argp1 = 0 ;
7679 int res1 = 0 ;
7680 int val2 ;
7681 int ecode2 = 0 ;
7682 PyObject * obj0 = 0 ;
7683 PyObject * obj1 = 0 ;
7684 char * kwnames[] = {
7685 (char *) "self",(char *) "x", NULL
7686 };
7687
7688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7690 if (!SWIG_IsOK(res1)) {
7691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7692 }
7693 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7694 ecode2 = SWIG_AsVal_int(obj1, &val2);
7695 if (!SWIG_IsOK(ecode2)) {
7696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7697 }
7698 arg2 = static_cast< int >(val2);
7699 {
7700 PyThreadState* __tstate = wxPyBeginAllowThreads();
7701 (arg1)->SetX(arg2);
7702 wxPyEndAllowThreads(__tstate);
7703 if (PyErr_Occurred()) SWIG_fail;
7704 }
7705 resultobj = SWIG_Py_Void();
7706 return resultobj;
7707 fail:
7708 return NULL;
7709 }
7710
7711
7712 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7713 PyObject *resultobj = 0;
7714 wxMouseState *arg1 = (wxMouseState *) 0 ;
7715 int arg2 ;
7716 void *argp1 = 0 ;
7717 int res1 = 0 ;
7718 int val2 ;
7719 int ecode2 = 0 ;
7720 PyObject * obj0 = 0 ;
7721 PyObject * obj1 = 0 ;
7722 char * kwnames[] = {
7723 (char *) "self",(char *) "y", NULL
7724 };
7725
7726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7728 if (!SWIG_IsOK(res1)) {
7729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7730 }
7731 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7732 ecode2 = SWIG_AsVal_int(obj1, &val2);
7733 if (!SWIG_IsOK(ecode2)) {
7734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7735 }
7736 arg2 = static_cast< int >(val2);
7737 {
7738 PyThreadState* __tstate = wxPyBeginAllowThreads();
7739 (arg1)->SetY(arg2);
7740 wxPyEndAllowThreads(__tstate);
7741 if (PyErr_Occurred()) SWIG_fail;
7742 }
7743 resultobj = SWIG_Py_Void();
7744 return resultobj;
7745 fail:
7746 return NULL;
7747 }
7748
7749
7750 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7751 PyObject *resultobj = 0;
7752 wxMouseState *arg1 = (wxMouseState *) 0 ;
7753 bool arg2 ;
7754 void *argp1 = 0 ;
7755 int res1 = 0 ;
7756 bool val2 ;
7757 int ecode2 = 0 ;
7758 PyObject * obj0 = 0 ;
7759 PyObject * obj1 = 0 ;
7760 char * kwnames[] = {
7761 (char *) "self",(char *) "down", NULL
7762 };
7763
7764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7766 if (!SWIG_IsOK(res1)) {
7767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7768 }
7769 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7770 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7771 if (!SWIG_IsOK(ecode2)) {
7772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7773 }
7774 arg2 = static_cast< bool >(val2);
7775 {
7776 PyThreadState* __tstate = wxPyBeginAllowThreads();
7777 (arg1)->SetLeftDown(arg2);
7778 wxPyEndAllowThreads(__tstate);
7779 if (PyErr_Occurred()) SWIG_fail;
7780 }
7781 resultobj = SWIG_Py_Void();
7782 return resultobj;
7783 fail:
7784 return NULL;
7785 }
7786
7787
7788 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7789 PyObject *resultobj = 0;
7790 wxMouseState *arg1 = (wxMouseState *) 0 ;
7791 bool arg2 ;
7792 void *argp1 = 0 ;
7793 int res1 = 0 ;
7794 bool val2 ;
7795 int ecode2 = 0 ;
7796 PyObject * obj0 = 0 ;
7797 PyObject * obj1 = 0 ;
7798 char * kwnames[] = {
7799 (char *) "self",(char *) "down", NULL
7800 };
7801
7802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7804 if (!SWIG_IsOK(res1)) {
7805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7806 }
7807 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7808 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7809 if (!SWIG_IsOK(ecode2)) {
7810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7811 }
7812 arg2 = static_cast< bool >(val2);
7813 {
7814 PyThreadState* __tstate = wxPyBeginAllowThreads();
7815 (arg1)->SetMiddleDown(arg2);
7816 wxPyEndAllowThreads(__tstate);
7817 if (PyErr_Occurred()) SWIG_fail;
7818 }
7819 resultobj = SWIG_Py_Void();
7820 return resultobj;
7821 fail:
7822 return NULL;
7823 }
7824
7825
7826 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7827 PyObject *resultobj = 0;
7828 wxMouseState *arg1 = (wxMouseState *) 0 ;
7829 bool arg2 ;
7830 void *argp1 = 0 ;
7831 int res1 = 0 ;
7832 bool val2 ;
7833 int ecode2 = 0 ;
7834 PyObject * obj0 = 0 ;
7835 PyObject * obj1 = 0 ;
7836 char * kwnames[] = {
7837 (char *) "self",(char *) "down", NULL
7838 };
7839
7840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7842 if (!SWIG_IsOK(res1)) {
7843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7844 }
7845 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7846 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7847 if (!SWIG_IsOK(ecode2)) {
7848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7849 }
7850 arg2 = static_cast< bool >(val2);
7851 {
7852 PyThreadState* __tstate = wxPyBeginAllowThreads();
7853 (arg1)->SetRightDown(arg2);
7854 wxPyEndAllowThreads(__tstate);
7855 if (PyErr_Occurred()) SWIG_fail;
7856 }
7857 resultobj = SWIG_Py_Void();
7858 return resultobj;
7859 fail:
7860 return NULL;
7861 }
7862
7863
7864 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7865 PyObject *resultobj = 0;
7866 wxMouseState *arg1 = (wxMouseState *) 0 ;
7867 bool arg2 ;
7868 void *argp1 = 0 ;
7869 int res1 = 0 ;
7870 bool val2 ;
7871 int ecode2 = 0 ;
7872 PyObject * obj0 = 0 ;
7873 PyObject * obj1 = 0 ;
7874 char * kwnames[] = {
7875 (char *) "self",(char *) "down", NULL
7876 };
7877
7878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7880 if (!SWIG_IsOK(res1)) {
7881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7882 }
7883 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7884 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7885 if (!SWIG_IsOK(ecode2)) {
7886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7887 }
7888 arg2 = static_cast< bool >(val2);
7889 {
7890 PyThreadState* __tstate = wxPyBeginAllowThreads();
7891 (arg1)->SetControlDown(arg2);
7892 wxPyEndAllowThreads(__tstate);
7893 if (PyErr_Occurred()) SWIG_fail;
7894 }
7895 resultobj = SWIG_Py_Void();
7896 return resultobj;
7897 fail:
7898 return NULL;
7899 }
7900
7901
7902 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7903 PyObject *resultobj = 0;
7904 wxMouseState *arg1 = (wxMouseState *) 0 ;
7905 bool arg2 ;
7906 void *argp1 = 0 ;
7907 int res1 = 0 ;
7908 bool val2 ;
7909 int ecode2 = 0 ;
7910 PyObject * obj0 = 0 ;
7911 PyObject * obj1 = 0 ;
7912 char * kwnames[] = {
7913 (char *) "self",(char *) "down", NULL
7914 };
7915
7916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7918 if (!SWIG_IsOK(res1)) {
7919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7920 }
7921 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7922 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7923 if (!SWIG_IsOK(ecode2)) {
7924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7925 }
7926 arg2 = static_cast< bool >(val2);
7927 {
7928 PyThreadState* __tstate = wxPyBeginAllowThreads();
7929 (arg1)->SetShiftDown(arg2);
7930 wxPyEndAllowThreads(__tstate);
7931 if (PyErr_Occurred()) SWIG_fail;
7932 }
7933 resultobj = SWIG_Py_Void();
7934 return resultobj;
7935 fail:
7936 return NULL;
7937 }
7938
7939
7940 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7941 PyObject *resultobj = 0;
7942 wxMouseState *arg1 = (wxMouseState *) 0 ;
7943 bool arg2 ;
7944 void *argp1 = 0 ;
7945 int res1 = 0 ;
7946 bool val2 ;
7947 int ecode2 = 0 ;
7948 PyObject * obj0 = 0 ;
7949 PyObject * obj1 = 0 ;
7950 char * kwnames[] = {
7951 (char *) "self",(char *) "down", NULL
7952 };
7953
7954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7956 if (!SWIG_IsOK(res1)) {
7957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7958 }
7959 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7960 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7961 if (!SWIG_IsOK(ecode2)) {
7962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7963 }
7964 arg2 = static_cast< bool >(val2);
7965 {
7966 PyThreadState* __tstate = wxPyBeginAllowThreads();
7967 (arg1)->SetAltDown(arg2);
7968 wxPyEndAllowThreads(__tstate);
7969 if (PyErr_Occurred()) SWIG_fail;
7970 }
7971 resultobj = SWIG_Py_Void();
7972 return resultobj;
7973 fail:
7974 return NULL;
7975 }
7976
7977
7978 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7979 PyObject *resultobj = 0;
7980 wxMouseState *arg1 = (wxMouseState *) 0 ;
7981 bool arg2 ;
7982 void *argp1 = 0 ;
7983 int res1 = 0 ;
7984 bool val2 ;
7985 int ecode2 = 0 ;
7986 PyObject * obj0 = 0 ;
7987 PyObject * obj1 = 0 ;
7988 char * kwnames[] = {
7989 (char *) "self",(char *) "down", NULL
7990 };
7991
7992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7994 if (!SWIG_IsOK(res1)) {
7995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7996 }
7997 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7998 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7999 if (!SWIG_IsOK(ecode2)) {
8000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
8001 }
8002 arg2 = static_cast< bool >(val2);
8003 {
8004 PyThreadState* __tstate = wxPyBeginAllowThreads();
8005 (arg1)->SetMetaDown(arg2);
8006 wxPyEndAllowThreads(__tstate);
8007 if (PyErr_Occurred()) SWIG_fail;
8008 }
8009 resultobj = SWIG_Py_Void();
8010 return resultobj;
8011 fail:
8012 return NULL;
8013 }
8014
8015
8016 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8017 PyObject *obj;
8018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8019 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8020 return SWIG_Py_Void();
8021 }
8022
8023 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8024 return SWIG_Python_InitShadowInstance(args);
8025 }
8026
8027 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8028 PyObject *resultobj = 0;
8029 wxMouseState result;
8030
8031 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8032 {
8033 PyThreadState* __tstate = wxPyBeginAllowThreads();
8034 result = wxGetMouseState();
8035 wxPyEndAllowThreads(__tstate);
8036 if (PyErr_Occurred()) SWIG_fail;
8037 }
8038 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8039 return resultobj;
8040 fail:
8041 return NULL;
8042 }
8043
8044
8045 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8046 PyObject *resultobj = 0;
8047
8048 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8049 {
8050 if (!wxPyCheckForApp()) SWIG_fail;
8051 PyThreadState* __tstate = wxPyBeginAllowThreads();
8052 wxWakeUpMainThread();
8053 wxPyEndAllowThreads(__tstate);
8054 if (PyErr_Occurred()) SWIG_fail;
8055 }
8056 resultobj = SWIG_Py_Void();
8057 return resultobj;
8058 fail:
8059 return NULL;
8060 }
8061
8062
8063 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8064 PyObject *resultobj = 0;
8065
8066 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8067 {
8068 if (!wxPyCheckForApp()) SWIG_fail;
8069 PyThreadState* __tstate = wxPyBeginAllowThreads();
8070 wxMutexGuiEnter();
8071 wxPyEndAllowThreads(__tstate);
8072 if (PyErr_Occurred()) SWIG_fail;
8073 }
8074 resultobj = SWIG_Py_Void();
8075 return resultobj;
8076 fail:
8077 return NULL;
8078 }
8079
8080
8081 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8082 PyObject *resultobj = 0;
8083
8084 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8085 {
8086 if (!wxPyCheckForApp()) SWIG_fail;
8087 PyThreadState* __tstate = wxPyBeginAllowThreads();
8088 wxMutexGuiLeave();
8089 wxPyEndAllowThreads(__tstate);
8090 if (PyErr_Occurred()) SWIG_fail;
8091 }
8092 resultobj = SWIG_Py_Void();
8093 return resultobj;
8094 fail:
8095 return NULL;
8096 }
8097
8098
8099 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8100 PyObject *resultobj = 0;
8101 wxMutexGuiLocker *result = 0 ;
8102
8103 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8104 {
8105 if (!wxPyCheckForApp()) SWIG_fail;
8106 PyThreadState* __tstate = wxPyBeginAllowThreads();
8107 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8108 wxPyEndAllowThreads(__tstate);
8109 if (PyErr_Occurred()) SWIG_fail;
8110 }
8111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8112 return resultobj;
8113 fail:
8114 return NULL;
8115 }
8116
8117
8118 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8119 PyObject *resultobj = 0;
8120 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8121 void *argp1 = 0 ;
8122 int res1 = 0 ;
8123 PyObject *swig_obj[1] ;
8124
8125 if (!args) SWIG_fail;
8126 swig_obj[0] = args;
8127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8128 if (!SWIG_IsOK(res1)) {
8129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8130 }
8131 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8132 {
8133 PyThreadState* __tstate = wxPyBeginAllowThreads();
8134 delete arg1;
8135
8136 wxPyEndAllowThreads(__tstate);
8137 if (PyErr_Occurred()) SWIG_fail;
8138 }
8139 resultobj = SWIG_Py_Void();
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8147 PyObject *obj;
8148 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8149 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8150 return SWIG_Py_Void();
8151 }
8152
8153 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8154 return SWIG_Python_InitShadowInstance(args);
8155 }
8156
8157 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8158 PyObject *resultobj = 0;
8159 bool result;
8160
8161 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8162 {
8163 PyThreadState* __tstate = wxPyBeginAllowThreads();
8164 result = (bool)wxThread_IsMain();
8165 wxPyEndAllowThreads(__tstate);
8166 if (PyErr_Occurred()) SWIG_fail;
8167 }
8168 {
8169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8170 }
8171 return resultobj;
8172 fail:
8173 return NULL;
8174 }
8175
8176
8177 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8178 PyObject *resultobj = 0;
8179 wxString *arg1 = 0 ;
8180 wxToolTip *result = 0 ;
8181 bool temp1 = false ;
8182 PyObject * obj0 = 0 ;
8183 char * kwnames[] = {
8184 (char *) "tip", NULL
8185 };
8186
8187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8188 {
8189 arg1 = wxString_in_helper(obj0);
8190 if (arg1 == NULL) SWIG_fail;
8191 temp1 = true;
8192 }
8193 {
8194 if (!wxPyCheckForApp()) SWIG_fail;
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8197 wxPyEndAllowThreads(__tstate);
8198 if (PyErr_Occurred()) SWIG_fail;
8199 }
8200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8201 {
8202 if (temp1)
8203 delete arg1;
8204 }
8205 return resultobj;
8206 fail:
8207 {
8208 if (temp1)
8209 delete arg1;
8210 }
8211 return NULL;
8212 }
8213
8214
8215 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8216 PyObject *resultobj = 0;
8217 wxToolTip *arg1 = (wxToolTip *) 0 ;
8218 void *argp1 = 0 ;
8219 int res1 = 0 ;
8220 PyObject *swig_obj[1] ;
8221
8222 if (!args) SWIG_fail;
8223 swig_obj[0] = args;
8224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8225 if (!SWIG_IsOK(res1)) {
8226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8227 }
8228 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8229 {
8230 PyThreadState* __tstate = wxPyBeginAllowThreads();
8231 delete arg1;
8232
8233 wxPyEndAllowThreads(__tstate);
8234 if (PyErr_Occurred()) SWIG_fail;
8235 }
8236 resultobj = SWIG_Py_Void();
8237 return resultobj;
8238 fail:
8239 return NULL;
8240 }
8241
8242
8243 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8244 PyObject *resultobj = 0;
8245 wxToolTip *arg1 = (wxToolTip *) 0 ;
8246 wxString *arg2 = 0 ;
8247 void *argp1 = 0 ;
8248 int res1 = 0 ;
8249 bool temp2 = false ;
8250 PyObject * obj0 = 0 ;
8251 PyObject * obj1 = 0 ;
8252 char * kwnames[] = {
8253 (char *) "self",(char *) "tip", NULL
8254 };
8255
8256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8258 if (!SWIG_IsOK(res1)) {
8259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8260 }
8261 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8262 {
8263 arg2 = wxString_in_helper(obj1);
8264 if (arg2 == NULL) SWIG_fail;
8265 temp2 = true;
8266 }
8267 {
8268 PyThreadState* __tstate = wxPyBeginAllowThreads();
8269 (arg1)->SetTip((wxString const &)*arg2);
8270 wxPyEndAllowThreads(__tstate);
8271 if (PyErr_Occurred()) SWIG_fail;
8272 }
8273 resultobj = SWIG_Py_Void();
8274 {
8275 if (temp2)
8276 delete arg2;
8277 }
8278 return resultobj;
8279 fail:
8280 {
8281 if (temp2)
8282 delete arg2;
8283 }
8284 return NULL;
8285 }
8286
8287
8288 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8289 PyObject *resultobj = 0;
8290 wxToolTip *arg1 = (wxToolTip *) 0 ;
8291 wxString result;
8292 void *argp1 = 0 ;
8293 int res1 = 0 ;
8294 PyObject *swig_obj[1] ;
8295
8296 if (!args) SWIG_fail;
8297 swig_obj[0] = args;
8298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8299 if (!SWIG_IsOK(res1)) {
8300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8301 }
8302 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8303 {
8304 PyThreadState* __tstate = wxPyBeginAllowThreads();
8305 result = (arg1)->GetTip();
8306 wxPyEndAllowThreads(__tstate);
8307 if (PyErr_Occurred()) SWIG_fail;
8308 }
8309 {
8310 #if wxUSE_UNICODE
8311 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8312 #else
8313 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8314 #endif
8315 }
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8323 PyObject *resultobj = 0;
8324 wxToolTip *arg1 = (wxToolTip *) 0 ;
8325 wxWindow *result = 0 ;
8326 void *argp1 = 0 ;
8327 int res1 = 0 ;
8328 PyObject *swig_obj[1] ;
8329
8330 if (!args) SWIG_fail;
8331 swig_obj[0] = args;
8332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8333 if (!SWIG_IsOK(res1)) {
8334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8335 }
8336 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8337 {
8338 PyThreadState* __tstate = wxPyBeginAllowThreads();
8339 result = (wxWindow *)(arg1)->GetWindow();
8340 wxPyEndAllowThreads(__tstate);
8341 if (PyErr_Occurred()) SWIG_fail;
8342 }
8343 {
8344 resultobj = wxPyMake_wxObject(result, 0);
8345 }
8346 return resultobj;
8347 fail:
8348 return NULL;
8349 }
8350
8351
8352 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8353 PyObject *resultobj = 0;
8354 bool arg1 ;
8355 bool val1 ;
8356 int ecode1 = 0 ;
8357 PyObject * obj0 = 0 ;
8358 char * kwnames[] = {
8359 (char *) "flag", NULL
8360 };
8361
8362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8363 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8364 if (!SWIG_IsOK(ecode1)) {
8365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8366 }
8367 arg1 = static_cast< bool >(val1);
8368 {
8369 PyThreadState* __tstate = wxPyBeginAllowThreads();
8370 wxToolTip::Enable(arg1);
8371 wxPyEndAllowThreads(__tstate);
8372 if (PyErr_Occurred()) SWIG_fail;
8373 }
8374 resultobj = SWIG_Py_Void();
8375 return resultobj;
8376 fail:
8377 return NULL;
8378 }
8379
8380
8381 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8382 PyObject *resultobj = 0;
8383 long arg1 ;
8384 long val1 ;
8385 int ecode1 = 0 ;
8386 PyObject * obj0 = 0 ;
8387 char * kwnames[] = {
8388 (char *) "milliseconds", NULL
8389 };
8390
8391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8392 ecode1 = SWIG_AsVal_long(obj0, &val1);
8393 if (!SWIG_IsOK(ecode1)) {
8394 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8395 }
8396 arg1 = static_cast< long >(val1);
8397 {
8398 PyThreadState* __tstate = wxPyBeginAllowThreads();
8399 wxToolTip::SetDelay(arg1);
8400 wxPyEndAllowThreads(__tstate);
8401 if (PyErr_Occurred()) SWIG_fail;
8402 }
8403 resultobj = SWIG_Py_Void();
8404 return resultobj;
8405 fail:
8406 return NULL;
8407 }
8408
8409
8410 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8411 PyObject *obj;
8412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8413 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8414 return SWIG_Py_Void();
8415 }
8416
8417 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8418 return SWIG_Python_InitShadowInstance(args);
8419 }
8420
8421 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8422 PyObject *resultobj = 0;
8423 wxWindow *arg1 = (wxWindow *) 0 ;
8424 wxSize *arg2 = 0 ;
8425 wxCaret *result = 0 ;
8426 void *argp1 = 0 ;
8427 int res1 = 0 ;
8428 wxSize temp2 ;
8429 PyObject * obj0 = 0 ;
8430 PyObject * obj1 = 0 ;
8431 char * kwnames[] = {
8432 (char *) "window",(char *) "size", NULL
8433 };
8434
8435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8437 if (!SWIG_IsOK(res1)) {
8438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8439 }
8440 arg1 = reinterpret_cast< wxWindow * >(argp1);
8441 {
8442 arg2 = &temp2;
8443 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8444 }
8445 {
8446 if (!wxPyCheckForApp()) SWIG_fail;
8447 PyThreadState* __tstate = wxPyBeginAllowThreads();
8448 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8449 wxPyEndAllowThreads(__tstate);
8450 if (PyErr_Occurred()) SWIG_fail;
8451 }
8452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8453 return resultobj;
8454 fail:
8455 return NULL;
8456 }
8457
8458
8459 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8460 PyObject *resultobj = 0;
8461 wxCaret *arg1 = (wxCaret *) 0 ;
8462 void *argp1 = 0 ;
8463 int res1 = 0 ;
8464 PyObject *swig_obj[1] ;
8465
8466 if (!args) SWIG_fail;
8467 swig_obj[0] = args;
8468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8469 if (!SWIG_IsOK(res1)) {
8470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8471 }
8472 arg1 = reinterpret_cast< wxCaret * >(argp1);
8473 {
8474 PyThreadState* __tstate = wxPyBeginAllowThreads();
8475 delete arg1;
8476
8477 wxPyEndAllowThreads(__tstate);
8478 if (PyErr_Occurred()) SWIG_fail;
8479 }
8480 resultobj = SWIG_Py_Void();
8481 return resultobj;
8482 fail:
8483 return NULL;
8484 }
8485
8486
8487 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8488 PyObject *resultobj = 0;
8489 wxCaret *arg1 = (wxCaret *) 0 ;
8490 void *argp1 = 0 ;
8491 int res1 = 0 ;
8492 PyObject *swig_obj[1] ;
8493
8494 if (!args) SWIG_fail;
8495 swig_obj[0] = args;
8496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8497 if (!SWIG_IsOK(res1)) {
8498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8499 }
8500 arg1 = reinterpret_cast< wxCaret * >(argp1);
8501 {
8502 PyThreadState* __tstate = wxPyBeginAllowThreads();
8503 wxCaret_Destroy(arg1);
8504 wxPyEndAllowThreads(__tstate);
8505 if (PyErr_Occurred()) SWIG_fail;
8506 }
8507 resultobj = SWIG_Py_Void();
8508 return resultobj;
8509 fail:
8510 return NULL;
8511 }
8512
8513
8514 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8515 PyObject *resultobj = 0;
8516 wxCaret *arg1 = (wxCaret *) 0 ;
8517 bool result;
8518 void *argp1 = 0 ;
8519 int res1 = 0 ;
8520 PyObject *swig_obj[1] ;
8521
8522 if (!args) SWIG_fail;
8523 swig_obj[0] = args;
8524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8525 if (!SWIG_IsOK(res1)) {
8526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8527 }
8528 arg1 = reinterpret_cast< wxCaret * >(argp1);
8529 {
8530 PyThreadState* __tstate = wxPyBeginAllowThreads();
8531 result = (bool)(arg1)->IsOk();
8532 wxPyEndAllowThreads(__tstate);
8533 if (PyErr_Occurred()) SWIG_fail;
8534 }
8535 {
8536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8537 }
8538 return resultobj;
8539 fail:
8540 return NULL;
8541 }
8542
8543
8544 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8545 PyObject *resultobj = 0;
8546 wxCaret *arg1 = (wxCaret *) 0 ;
8547 bool result;
8548 void *argp1 = 0 ;
8549 int res1 = 0 ;
8550 PyObject *swig_obj[1] ;
8551
8552 if (!args) SWIG_fail;
8553 swig_obj[0] = args;
8554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8555 if (!SWIG_IsOK(res1)) {
8556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8557 }
8558 arg1 = reinterpret_cast< wxCaret * >(argp1);
8559 {
8560 PyThreadState* __tstate = wxPyBeginAllowThreads();
8561 result = (bool)(arg1)->IsVisible();
8562 wxPyEndAllowThreads(__tstate);
8563 if (PyErr_Occurred()) SWIG_fail;
8564 }
8565 {
8566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8567 }
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8575 PyObject *resultobj = 0;
8576 wxCaret *arg1 = (wxCaret *) 0 ;
8577 wxPoint result;
8578 void *argp1 = 0 ;
8579 int res1 = 0 ;
8580 PyObject *swig_obj[1] ;
8581
8582 if (!args) SWIG_fail;
8583 swig_obj[0] = args;
8584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8585 if (!SWIG_IsOK(res1)) {
8586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8587 }
8588 arg1 = reinterpret_cast< wxCaret * >(argp1);
8589 {
8590 PyThreadState* __tstate = wxPyBeginAllowThreads();
8591 result = (arg1)->GetPosition();
8592 wxPyEndAllowThreads(__tstate);
8593 if (PyErr_Occurred()) SWIG_fail;
8594 }
8595 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8596 return resultobj;
8597 fail:
8598 return NULL;
8599 }
8600
8601
8602 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8603 PyObject *resultobj = 0;
8604 wxCaret *arg1 = (wxCaret *) 0 ;
8605 int *arg2 = (int *) 0 ;
8606 int *arg3 = (int *) 0 ;
8607 void *argp1 = 0 ;
8608 int res1 = 0 ;
8609 int temp2 ;
8610 int res2 = SWIG_TMPOBJ ;
8611 int temp3 ;
8612 int res3 = SWIG_TMPOBJ ;
8613 PyObject *swig_obj[1] ;
8614
8615 arg2 = &temp2;
8616 arg3 = &temp3;
8617 if (!args) SWIG_fail;
8618 swig_obj[0] = args;
8619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8620 if (!SWIG_IsOK(res1)) {
8621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8622 }
8623 arg1 = reinterpret_cast< wxCaret * >(argp1);
8624 {
8625 PyThreadState* __tstate = wxPyBeginAllowThreads();
8626 (arg1)->GetPosition(arg2,arg3);
8627 wxPyEndAllowThreads(__tstate);
8628 if (PyErr_Occurred()) SWIG_fail;
8629 }
8630 resultobj = SWIG_Py_Void();
8631 if (SWIG_IsTmpObj(res2)) {
8632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8633 } else {
8634 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8635 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8636 }
8637 if (SWIG_IsTmpObj(res3)) {
8638 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8639 } else {
8640 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8642 }
8643 return resultobj;
8644 fail:
8645 return NULL;
8646 }
8647
8648
8649 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8650 PyObject *resultobj = 0;
8651 wxCaret *arg1 = (wxCaret *) 0 ;
8652 wxSize result;
8653 void *argp1 = 0 ;
8654 int res1 = 0 ;
8655 PyObject *swig_obj[1] ;
8656
8657 if (!args) SWIG_fail;
8658 swig_obj[0] = args;
8659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8660 if (!SWIG_IsOK(res1)) {
8661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8662 }
8663 arg1 = reinterpret_cast< wxCaret * >(argp1);
8664 {
8665 PyThreadState* __tstate = wxPyBeginAllowThreads();
8666 result = (arg1)->GetSize();
8667 wxPyEndAllowThreads(__tstate);
8668 if (PyErr_Occurred()) SWIG_fail;
8669 }
8670 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8671 return resultobj;
8672 fail:
8673 return NULL;
8674 }
8675
8676
8677 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8678 PyObject *resultobj = 0;
8679 wxCaret *arg1 = (wxCaret *) 0 ;
8680 int *arg2 = (int *) 0 ;
8681 int *arg3 = (int *) 0 ;
8682 void *argp1 = 0 ;
8683 int res1 = 0 ;
8684 int temp2 ;
8685 int res2 = SWIG_TMPOBJ ;
8686 int temp3 ;
8687 int res3 = SWIG_TMPOBJ ;
8688 PyObject *swig_obj[1] ;
8689
8690 arg2 = &temp2;
8691 arg3 = &temp3;
8692 if (!args) SWIG_fail;
8693 swig_obj[0] = args;
8694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8695 if (!SWIG_IsOK(res1)) {
8696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8697 }
8698 arg1 = reinterpret_cast< wxCaret * >(argp1);
8699 {
8700 PyThreadState* __tstate = wxPyBeginAllowThreads();
8701 (arg1)->GetSize(arg2,arg3);
8702 wxPyEndAllowThreads(__tstate);
8703 if (PyErr_Occurred()) SWIG_fail;
8704 }
8705 resultobj = SWIG_Py_Void();
8706 if (SWIG_IsTmpObj(res2)) {
8707 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8708 } else {
8709 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8710 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8711 }
8712 if (SWIG_IsTmpObj(res3)) {
8713 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8714 } else {
8715 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8716 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8717 }
8718 return resultobj;
8719 fail:
8720 return NULL;
8721 }
8722
8723
8724 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8725 PyObject *resultobj = 0;
8726 wxCaret *arg1 = (wxCaret *) 0 ;
8727 wxWindow *result = 0 ;
8728 void *argp1 = 0 ;
8729 int res1 = 0 ;
8730 PyObject *swig_obj[1] ;
8731
8732 if (!args) SWIG_fail;
8733 swig_obj[0] = args;
8734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8735 if (!SWIG_IsOK(res1)) {
8736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8737 }
8738 arg1 = reinterpret_cast< wxCaret * >(argp1);
8739 {
8740 PyThreadState* __tstate = wxPyBeginAllowThreads();
8741 result = (wxWindow *)(arg1)->GetWindow();
8742 wxPyEndAllowThreads(__tstate);
8743 if (PyErr_Occurred()) SWIG_fail;
8744 }
8745 {
8746 resultobj = wxPyMake_wxObject(result, 0);
8747 }
8748 return resultobj;
8749 fail:
8750 return NULL;
8751 }
8752
8753
8754 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8755 PyObject *resultobj = 0;
8756 wxCaret *arg1 = (wxCaret *) 0 ;
8757 int arg2 ;
8758 int arg3 ;
8759 void *argp1 = 0 ;
8760 int res1 = 0 ;
8761 int val2 ;
8762 int ecode2 = 0 ;
8763 int val3 ;
8764 int ecode3 = 0 ;
8765 PyObject * obj0 = 0 ;
8766 PyObject * obj1 = 0 ;
8767 PyObject * obj2 = 0 ;
8768 char * kwnames[] = {
8769 (char *) "self",(char *) "x",(char *) "y", NULL
8770 };
8771
8772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8774 if (!SWIG_IsOK(res1)) {
8775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8776 }
8777 arg1 = reinterpret_cast< wxCaret * >(argp1);
8778 ecode2 = SWIG_AsVal_int(obj1, &val2);
8779 if (!SWIG_IsOK(ecode2)) {
8780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8781 }
8782 arg2 = static_cast< int >(val2);
8783 ecode3 = SWIG_AsVal_int(obj2, &val3);
8784 if (!SWIG_IsOK(ecode3)) {
8785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8786 }
8787 arg3 = static_cast< int >(val3);
8788 {
8789 PyThreadState* __tstate = wxPyBeginAllowThreads();
8790 (arg1)->Move(arg2,arg3);
8791 wxPyEndAllowThreads(__tstate);
8792 if (PyErr_Occurred()) SWIG_fail;
8793 }
8794 resultobj = SWIG_Py_Void();
8795 return resultobj;
8796 fail:
8797 return NULL;
8798 }
8799
8800
8801 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8802 PyObject *resultobj = 0;
8803 wxCaret *arg1 = (wxCaret *) 0 ;
8804 wxPoint *arg2 = 0 ;
8805 void *argp1 = 0 ;
8806 int res1 = 0 ;
8807 wxPoint temp2 ;
8808 PyObject * obj0 = 0 ;
8809 PyObject * obj1 = 0 ;
8810 char * kwnames[] = {
8811 (char *) "self",(char *) "pt", NULL
8812 };
8813
8814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8816 if (!SWIG_IsOK(res1)) {
8817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8818 }
8819 arg1 = reinterpret_cast< wxCaret * >(argp1);
8820 {
8821 arg2 = &temp2;
8822 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8823 }
8824 {
8825 PyThreadState* __tstate = wxPyBeginAllowThreads();
8826 (arg1)->Move((wxPoint const &)*arg2);
8827 wxPyEndAllowThreads(__tstate);
8828 if (PyErr_Occurred()) SWIG_fail;
8829 }
8830 resultobj = SWIG_Py_Void();
8831 return resultobj;
8832 fail:
8833 return NULL;
8834 }
8835
8836
8837 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8838 PyObject *resultobj = 0;
8839 wxCaret *arg1 = (wxCaret *) 0 ;
8840 int arg2 ;
8841 int arg3 ;
8842 void *argp1 = 0 ;
8843 int res1 = 0 ;
8844 int val2 ;
8845 int ecode2 = 0 ;
8846 int val3 ;
8847 int ecode3 = 0 ;
8848 PyObject * obj0 = 0 ;
8849 PyObject * obj1 = 0 ;
8850 PyObject * obj2 = 0 ;
8851 char * kwnames[] = {
8852 (char *) "self",(char *) "width",(char *) "height", NULL
8853 };
8854
8855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8857 if (!SWIG_IsOK(res1)) {
8858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8859 }
8860 arg1 = reinterpret_cast< wxCaret * >(argp1);
8861 ecode2 = SWIG_AsVal_int(obj1, &val2);
8862 if (!SWIG_IsOK(ecode2)) {
8863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8864 }
8865 arg2 = static_cast< int >(val2);
8866 ecode3 = SWIG_AsVal_int(obj2, &val3);
8867 if (!SWIG_IsOK(ecode3)) {
8868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8869 }
8870 arg3 = static_cast< int >(val3);
8871 {
8872 PyThreadState* __tstate = wxPyBeginAllowThreads();
8873 (arg1)->SetSize(arg2,arg3);
8874 wxPyEndAllowThreads(__tstate);
8875 if (PyErr_Occurred()) SWIG_fail;
8876 }
8877 resultobj = SWIG_Py_Void();
8878 return resultobj;
8879 fail:
8880 return NULL;
8881 }
8882
8883
8884 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8885 PyObject *resultobj = 0;
8886 wxCaret *arg1 = (wxCaret *) 0 ;
8887 wxSize *arg2 = 0 ;
8888 void *argp1 = 0 ;
8889 int res1 = 0 ;
8890 wxSize temp2 ;
8891 PyObject * obj0 = 0 ;
8892 PyObject * obj1 = 0 ;
8893 char * kwnames[] = {
8894 (char *) "self",(char *) "size", NULL
8895 };
8896
8897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8899 if (!SWIG_IsOK(res1)) {
8900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8901 }
8902 arg1 = reinterpret_cast< wxCaret * >(argp1);
8903 {
8904 arg2 = &temp2;
8905 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8906 }
8907 {
8908 PyThreadState* __tstate = wxPyBeginAllowThreads();
8909 (arg1)->SetSize((wxSize const &)*arg2);
8910 wxPyEndAllowThreads(__tstate);
8911 if (PyErr_Occurred()) SWIG_fail;
8912 }
8913 resultobj = SWIG_Py_Void();
8914 return resultobj;
8915 fail:
8916 return NULL;
8917 }
8918
8919
8920 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8921 PyObject *resultobj = 0;
8922 wxCaret *arg1 = (wxCaret *) 0 ;
8923 int arg2 = (int) true ;
8924 void *argp1 = 0 ;
8925 int res1 = 0 ;
8926 int val2 ;
8927 int ecode2 = 0 ;
8928 PyObject * obj0 = 0 ;
8929 PyObject * obj1 = 0 ;
8930 char * kwnames[] = {
8931 (char *) "self",(char *) "show", NULL
8932 };
8933
8934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8936 if (!SWIG_IsOK(res1)) {
8937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8938 }
8939 arg1 = reinterpret_cast< wxCaret * >(argp1);
8940 if (obj1) {
8941 ecode2 = SWIG_AsVal_int(obj1, &val2);
8942 if (!SWIG_IsOK(ecode2)) {
8943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8944 }
8945 arg2 = static_cast< int >(val2);
8946 }
8947 {
8948 PyThreadState* __tstate = wxPyBeginAllowThreads();
8949 (arg1)->Show(arg2);
8950 wxPyEndAllowThreads(__tstate);
8951 if (PyErr_Occurred()) SWIG_fail;
8952 }
8953 resultobj = SWIG_Py_Void();
8954 return resultobj;
8955 fail:
8956 return NULL;
8957 }
8958
8959
8960 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8961 PyObject *resultobj = 0;
8962 wxCaret *arg1 = (wxCaret *) 0 ;
8963 void *argp1 = 0 ;
8964 int res1 = 0 ;
8965 PyObject *swig_obj[1] ;
8966
8967 if (!args) SWIG_fail;
8968 swig_obj[0] = args;
8969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8970 if (!SWIG_IsOK(res1)) {
8971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8972 }
8973 arg1 = reinterpret_cast< wxCaret * >(argp1);
8974 {
8975 PyThreadState* __tstate = wxPyBeginAllowThreads();
8976 (arg1)->Hide();
8977 wxPyEndAllowThreads(__tstate);
8978 if (PyErr_Occurred()) SWIG_fail;
8979 }
8980 resultobj = SWIG_Py_Void();
8981 return resultobj;
8982 fail:
8983 return NULL;
8984 }
8985
8986
8987 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8988 PyObject *resultobj = 0;
8989 int result;
8990
8991 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8992 {
8993 PyThreadState* __tstate = wxPyBeginAllowThreads();
8994 result = (int)wxCaret::GetBlinkTime();
8995 wxPyEndAllowThreads(__tstate);
8996 if (PyErr_Occurred()) SWIG_fail;
8997 }
8998 resultobj = SWIG_From_int(static_cast< int >(result));
8999 return resultobj;
9000 fail:
9001 return NULL;
9002 }
9003
9004
9005 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9006 PyObject *resultobj = 0;
9007 int arg1 ;
9008 int val1 ;
9009 int ecode1 = 0 ;
9010 PyObject * obj0 = 0 ;
9011 char * kwnames[] = {
9012 (char *) "milliseconds", NULL
9013 };
9014
9015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9016 ecode1 = SWIG_AsVal_int(obj0, &val1);
9017 if (!SWIG_IsOK(ecode1)) {
9018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9019 }
9020 arg1 = static_cast< int >(val1);
9021 {
9022 PyThreadState* __tstate = wxPyBeginAllowThreads();
9023 wxCaret::SetBlinkTime(arg1);
9024 wxPyEndAllowThreads(__tstate);
9025 if (PyErr_Occurred()) SWIG_fail;
9026 }
9027 resultobj = SWIG_Py_Void();
9028 return resultobj;
9029 fail:
9030 return NULL;
9031 }
9032
9033
9034 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9035 PyObject *obj;
9036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9037 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9038 return SWIG_Py_Void();
9039 }
9040
9041 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9042 return SWIG_Python_InitShadowInstance(args);
9043 }
9044
9045 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9046 PyObject *resultobj = 0;
9047 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9048 wxBusyCursor *result = 0 ;
9049 void *argp1 = 0 ;
9050 int res1 = 0 ;
9051 PyObject * obj0 = 0 ;
9052 char * kwnames[] = {
9053 (char *) "cursor", NULL
9054 };
9055
9056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9057 if (obj0) {
9058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9059 if (!SWIG_IsOK(res1)) {
9060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9061 }
9062 arg1 = reinterpret_cast< wxCursor * >(argp1);
9063 }
9064 {
9065 if (!wxPyCheckForApp()) SWIG_fail;
9066 PyThreadState* __tstate = wxPyBeginAllowThreads();
9067 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9068 wxPyEndAllowThreads(__tstate);
9069 if (PyErr_Occurred()) SWIG_fail;
9070 }
9071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9072 return resultobj;
9073 fail:
9074 return NULL;
9075 }
9076
9077
9078 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9079 PyObject *resultobj = 0;
9080 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9081 void *argp1 = 0 ;
9082 int res1 = 0 ;
9083 PyObject *swig_obj[1] ;
9084
9085 if (!args) SWIG_fail;
9086 swig_obj[0] = args;
9087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9088 if (!SWIG_IsOK(res1)) {
9089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9090 }
9091 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9092 {
9093 PyThreadState* __tstate = wxPyBeginAllowThreads();
9094 delete arg1;
9095
9096 wxPyEndAllowThreads(__tstate);
9097 if (PyErr_Occurred()) SWIG_fail;
9098 }
9099 resultobj = SWIG_Py_Void();
9100 return resultobj;
9101 fail:
9102 return NULL;
9103 }
9104
9105
9106 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9107 PyObject *obj;
9108 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9109 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9110 return SWIG_Py_Void();
9111 }
9112
9113 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9114 return SWIG_Python_InitShadowInstance(args);
9115 }
9116
9117 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9118 PyObject *resultobj = 0;
9119 wxWindow *arg1 = (wxWindow *) NULL ;
9120 wxWindowDisabler *result = 0 ;
9121 void *argp1 = 0 ;
9122 int res1 = 0 ;
9123 PyObject * obj0 = 0 ;
9124 char * kwnames[] = {
9125 (char *) "winToSkip", NULL
9126 };
9127
9128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9129 if (obj0) {
9130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9131 if (!SWIG_IsOK(res1)) {
9132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9133 }
9134 arg1 = reinterpret_cast< wxWindow * >(argp1);
9135 }
9136 {
9137 if (!wxPyCheckForApp()) SWIG_fail;
9138 PyThreadState* __tstate = wxPyBeginAllowThreads();
9139 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9140 wxPyEndAllowThreads(__tstate);
9141 if (PyErr_Occurred()) SWIG_fail;
9142 }
9143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9144 return resultobj;
9145 fail:
9146 return NULL;
9147 }
9148
9149
9150 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9151 PyObject *resultobj = 0;
9152 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9153 void *argp1 = 0 ;
9154 int res1 = 0 ;
9155 PyObject *swig_obj[1] ;
9156
9157 if (!args) SWIG_fail;
9158 swig_obj[0] = args;
9159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9160 if (!SWIG_IsOK(res1)) {
9161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9162 }
9163 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9164 {
9165 PyThreadState* __tstate = wxPyBeginAllowThreads();
9166 delete arg1;
9167
9168 wxPyEndAllowThreads(__tstate);
9169 if (PyErr_Occurred()) SWIG_fail;
9170 }
9171 resultobj = SWIG_Py_Void();
9172 return resultobj;
9173 fail:
9174 return NULL;
9175 }
9176
9177
9178 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9179 PyObject *obj;
9180 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9181 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9182 return SWIG_Py_Void();
9183 }
9184
9185 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9186 return SWIG_Python_InitShadowInstance(args);
9187 }
9188
9189 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9190 PyObject *resultobj = 0;
9191 wxString *arg1 = 0 ;
9192 wxBusyInfo *result = 0 ;
9193 bool temp1 = false ;
9194 PyObject * obj0 = 0 ;
9195 char * kwnames[] = {
9196 (char *) "message", NULL
9197 };
9198
9199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9200 {
9201 arg1 = wxString_in_helper(obj0);
9202 if (arg1 == NULL) SWIG_fail;
9203 temp1 = true;
9204 }
9205 {
9206 if (!wxPyCheckForApp()) SWIG_fail;
9207 PyThreadState* __tstate = wxPyBeginAllowThreads();
9208 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9209 wxPyEndAllowThreads(__tstate);
9210 if (PyErr_Occurred()) SWIG_fail;
9211 }
9212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9213 {
9214 if (temp1)
9215 delete arg1;
9216 }
9217 return resultobj;
9218 fail:
9219 {
9220 if (temp1)
9221 delete arg1;
9222 }
9223 return NULL;
9224 }
9225
9226
9227 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9228 PyObject *resultobj = 0;
9229 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9230 void *argp1 = 0 ;
9231 int res1 = 0 ;
9232 PyObject *swig_obj[1] ;
9233
9234 if (!args) SWIG_fail;
9235 swig_obj[0] = args;
9236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9237 if (!SWIG_IsOK(res1)) {
9238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9239 }
9240 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9241 {
9242 PyThreadState* __tstate = wxPyBeginAllowThreads();
9243 delete arg1;
9244
9245 wxPyEndAllowThreads(__tstate);
9246 if (PyErr_Occurred()) SWIG_fail;
9247 }
9248 resultobj = SWIG_Py_Void();
9249 return resultobj;
9250 fail:
9251 return NULL;
9252 }
9253
9254
9255 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9256 PyObject *obj;
9257 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9258 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9259 return SWIG_Py_Void();
9260 }
9261
9262 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9263 return SWIG_Python_InitShadowInstance(args);
9264 }
9265
9266 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9267 PyObject *resultobj = 0;
9268 wxStopWatch *result = 0 ;
9269
9270 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9271 {
9272 PyThreadState* __tstate = wxPyBeginAllowThreads();
9273 result = (wxStopWatch *)new wxStopWatch();
9274 wxPyEndAllowThreads(__tstate);
9275 if (PyErr_Occurred()) SWIG_fail;
9276 }
9277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9278 return resultobj;
9279 fail:
9280 return NULL;
9281 }
9282
9283
9284 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9285 PyObject *resultobj = 0;
9286 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9287 void *argp1 = 0 ;
9288 int res1 = 0 ;
9289 PyObject *swig_obj[1] ;
9290
9291 if (!args) SWIG_fail;
9292 swig_obj[0] = args;
9293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9294 if (!SWIG_IsOK(res1)) {
9295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9296 }
9297 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9298 {
9299 PyThreadState* __tstate = wxPyBeginAllowThreads();
9300 delete arg1;
9301
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_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9313 PyObject *resultobj = 0;
9314 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9315 long arg2 = (long) 0 ;
9316 void *argp1 = 0 ;
9317 int res1 = 0 ;
9318 long val2 ;
9319 int ecode2 = 0 ;
9320 PyObject * obj0 = 0 ;
9321 PyObject * obj1 = 0 ;
9322 char * kwnames[] = {
9323 (char *) "self",(char *) "t0", NULL
9324 };
9325
9326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9328 if (!SWIG_IsOK(res1)) {
9329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9330 }
9331 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9332 if (obj1) {
9333 ecode2 = SWIG_AsVal_long(obj1, &val2);
9334 if (!SWIG_IsOK(ecode2)) {
9335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9336 }
9337 arg2 = static_cast< long >(val2);
9338 }
9339 {
9340 PyThreadState* __tstate = wxPyBeginAllowThreads();
9341 (arg1)->Start(arg2);
9342 wxPyEndAllowThreads(__tstate);
9343 if (PyErr_Occurred()) SWIG_fail;
9344 }
9345 resultobj = SWIG_Py_Void();
9346 return resultobj;
9347 fail:
9348 return NULL;
9349 }
9350
9351
9352 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9353 PyObject *resultobj = 0;
9354 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9355 void *argp1 = 0 ;
9356 int res1 = 0 ;
9357 PyObject *swig_obj[1] ;
9358
9359 if (!args) SWIG_fail;
9360 swig_obj[0] = args;
9361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9362 if (!SWIG_IsOK(res1)) {
9363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9364 }
9365 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9366 {
9367 PyThreadState* __tstate = wxPyBeginAllowThreads();
9368 (arg1)->Pause();
9369 wxPyEndAllowThreads(__tstate);
9370 if (PyErr_Occurred()) SWIG_fail;
9371 }
9372 resultobj = SWIG_Py_Void();
9373 return resultobj;
9374 fail:
9375 return NULL;
9376 }
9377
9378
9379 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9380 PyObject *resultobj = 0;
9381 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9382 void *argp1 = 0 ;
9383 int res1 = 0 ;
9384 PyObject *swig_obj[1] ;
9385
9386 if (!args) SWIG_fail;
9387 swig_obj[0] = args;
9388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9389 if (!SWIG_IsOK(res1)) {
9390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9391 }
9392 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9393 {
9394 PyThreadState* __tstate = wxPyBeginAllowThreads();
9395 (arg1)->Resume();
9396 wxPyEndAllowThreads(__tstate);
9397 if (PyErr_Occurred()) SWIG_fail;
9398 }
9399 resultobj = SWIG_Py_Void();
9400 return resultobj;
9401 fail:
9402 return NULL;
9403 }
9404
9405
9406 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9407 PyObject *resultobj = 0;
9408 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9409 long result;
9410 void *argp1 = 0 ;
9411 int res1 = 0 ;
9412 PyObject *swig_obj[1] ;
9413
9414 if (!args) SWIG_fail;
9415 swig_obj[0] = args;
9416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9417 if (!SWIG_IsOK(res1)) {
9418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9419 }
9420 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9421 {
9422 PyThreadState* __tstate = wxPyBeginAllowThreads();
9423 result = (long)((wxStopWatch const *)arg1)->Time();
9424 wxPyEndAllowThreads(__tstate);
9425 if (PyErr_Occurred()) SWIG_fail;
9426 }
9427 resultobj = SWIG_From_long(static_cast< long >(result));
9428 return resultobj;
9429 fail:
9430 return NULL;
9431 }
9432
9433
9434 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9435 PyObject *obj;
9436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9437 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9438 return SWIG_Py_Void();
9439 }
9440
9441 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9442 return SWIG_Python_InitShadowInstance(args);
9443 }
9444
9445 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9446 PyObject *resultobj = 0;
9447 int arg1 = (int) 9 ;
9448 int arg2 = (int) wxID_FILE1 ;
9449 wxFileHistory *result = 0 ;
9450 int val1 ;
9451 int ecode1 = 0 ;
9452 int val2 ;
9453 int ecode2 = 0 ;
9454 PyObject * obj0 = 0 ;
9455 PyObject * obj1 = 0 ;
9456 char * kwnames[] = {
9457 (char *) "maxFiles",(char *) "idBase", NULL
9458 };
9459
9460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9461 if (obj0) {
9462 ecode1 = SWIG_AsVal_int(obj0, &val1);
9463 if (!SWIG_IsOK(ecode1)) {
9464 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9465 }
9466 arg1 = static_cast< int >(val1);
9467 }
9468 if (obj1) {
9469 ecode2 = SWIG_AsVal_int(obj1, &val2);
9470 if (!SWIG_IsOK(ecode2)) {
9471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9472 }
9473 arg2 = static_cast< int >(val2);
9474 }
9475 {
9476 PyThreadState* __tstate = wxPyBeginAllowThreads();
9477 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9478 wxPyEndAllowThreads(__tstate);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9489 PyObject *resultobj = 0;
9490 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9491 void *argp1 = 0 ;
9492 int res1 = 0 ;
9493 PyObject *swig_obj[1] ;
9494
9495 if (!args) SWIG_fail;
9496 swig_obj[0] = args;
9497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9498 if (!SWIG_IsOK(res1)) {
9499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9500 }
9501 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9502 {
9503 PyThreadState* __tstate = wxPyBeginAllowThreads();
9504 delete arg1;
9505
9506 wxPyEndAllowThreads(__tstate);
9507 if (PyErr_Occurred()) SWIG_fail;
9508 }
9509 resultobj = SWIG_Py_Void();
9510 return resultobj;
9511 fail:
9512 return NULL;
9513 }
9514
9515
9516 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9517 PyObject *resultobj = 0;
9518 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9519 wxString *arg2 = 0 ;
9520 void *argp1 = 0 ;
9521 int res1 = 0 ;
9522 bool temp2 = false ;
9523 PyObject * obj0 = 0 ;
9524 PyObject * obj1 = 0 ;
9525 char * kwnames[] = {
9526 (char *) "self",(char *) "file", NULL
9527 };
9528
9529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9531 if (!SWIG_IsOK(res1)) {
9532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9533 }
9534 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9535 {
9536 arg2 = wxString_in_helper(obj1);
9537 if (arg2 == NULL) SWIG_fail;
9538 temp2 = true;
9539 }
9540 {
9541 PyThreadState* __tstate = wxPyBeginAllowThreads();
9542 (arg1)->AddFileToHistory((wxString const &)*arg2);
9543 wxPyEndAllowThreads(__tstate);
9544 if (PyErr_Occurred()) SWIG_fail;
9545 }
9546 resultobj = SWIG_Py_Void();
9547 {
9548 if (temp2)
9549 delete arg2;
9550 }
9551 return resultobj;
9552 fail:
9553 {
9554 if (temp2)
9555 delete arg2;
9556 }
9557 return NULL;
9558 }
9559
9560
9561 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9562 PyObject *resultobj = 0;
9563 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9564 int arg2 ;
9565 void *argp1 = 0 ;
9566 int res1 = 0 ;
9567 int val2 ;
9568 int ecode2 = 0 ;
9569 PyObject * obj0 = 0 ;
9570 PyObject * obj1 = 0 ;
9571 char * kwnames[] = {
9572 (char *) "self",(char *) "i", NULL
9573 };
9574
9575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9577 if (!SWIG_IsOK(res1)) {
9578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9579 }
9580 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9581 ecode2 = SWIG_AsVal_int(obj1, &val2);
9582 if (!SWIG_IsOK(ecode2)) {
9583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9584 }
9585 arg2 = static_cast< int >(val2);
9586 {
9587 PyThreadState* __tstate = wxPyBeginAllowThreads();
9588 (arg1)->RemoveFileFromHistory(arg2);
9589 wxPyEndAllowThreads(__tstate);
9590 if (PyErr_Occurred()) SWIG_fail;
9591 }
9592 resultobj = SWIG_Py_Void();
9593 return resultobj;
9594 fail:
9595 return NULL;
9596 }
9597
9598
9599 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9600 PyObject *resultobj = 0;
9601 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9602 int result;
9603 void *argp1 = 0 ;
9604 int res1 = 0 ;
9605 PyObject *swig_obj[1] ;
9606
9607 if (!args) SWIG_fail;
9608 swig_obj[0] = args;
9609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9610 if (!SWIG_IsOK(res1)) {
9611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9612 }
9613 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9614 {
9615 PyThreadState* __tstate = wxPyBeginAllowThreads();
9616 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9617 wxPyEndAllowThreads(__tstate);
9618 if (PyErr_Occurred()) SWIG_fail;
9619 }
9620 resultobj = SWIG_From_int(static_cast< int >(result));
9621 return resultobj;
9622 fail:
9623 return NULL;
9624 }
9625
9626
9627 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9628 PyObject *resultobj = 0;
9629 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9630 wxMenu *arg2 = (wxMenu *) 0 ;
9631 void *argp1 = 0 ;
9632 int res1 = 0 ;
9633 void *argp2 = 0 ;
9634 int res2 = 0 ;
9635 PyObject * obj0 = 0 ;
9636 PyObject * obj1 = 0 ;
9637 char * kwnames[] = {
9638 (char *) "self",(char *) "menu", NULL
9639 };
9640
9641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9643 if (!SWIG_IsOK(res1)) {
9644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9645 }
9646 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9647 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9648 if (!SWIG_IsOK(res2)) {
9649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9650 }
9651 arg2 = reinterpret_cast< wxMenu * >(argp2);
9652 {
9653 PyThreadState* __tstate = wxPyBeginAllowThreads();
9654 (arg1)->UseMenu(arg2);
9655 wxPyEndAllowThreads(__tstate);
9656 if (PyErr_Occurred()) SWIG_fail;
9657 }
9658 resultobj = SWIG_Py_Void();
9659 return resultobj;
9660 fail:
9661 return NULL;
9662 }
9663
9664
9665 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9666 PyObject *resultobj = 0;
9667 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9668 wxMenu *arg2 = (wxMenu *) 0 ;
9669 void *argp1 = 0 ;
9670 int res1 = 0 ;
9671 void *argp2 = 0 ;
9672 int res2 = 0 ;
9673 PyObject * obj0 = 0 ;
9674 PyObject * obj1 = 0 ;
9675 char * kwnames[] = {
9676 (char *) "self",(char *) "menu", NULL
9677 };
9678
9679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9681 if (!SWIG_IsOK(res1)) {
9682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9683 }
9684 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9686 if (!SWIG_IsOK(res2)) {
9687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9688 }
9689 arg2 = reinterpret_cast< wxMenu * >(argp2);
9690 {
9691 PyThreadState* __tstate = wxPyBeginAllowThreads();
9692 (arg1)->RemoveMenu(arg2);
9693 wxPyEndAllowThreads(__tstate);
9694 if (PyErr_Occurred()) SWIG_fail;
9695 }
9696 resultobj = SWIG_Py_Void();
9697 return resultobj;
9698 fail:
9699 return NULL;
9700 }
9701
9702
9703 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9704 PyObject *resultobj = 0;
9705 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9706 wxConfigBase *arg2 = 0 ;
9707 void *argp1 = 0 ;
9708 int res1 = 0 ;
9709 void *argp2 = 0 ;
9710 int res2 = 0 ;
9711 PyObject * obj0 = 0 ;
9712 PyObject * obj1 = 0 ;
9713 char * kwnames[] = {
9714 (char *) "self",(char *) "config", NULL
9715 };
9716
9717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9719 if (!SWIG_IsOK(res1)) {
9720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9721 }
9722 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9723 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9724 if (!SWIG_IsOK(res2)) {
9725 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9726 }
9727 if (!argp2) {
9728 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9729 }
9730 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9731 {
9732 PyThreadState* __tstate = wxPyBeginAllowThreads();
9733 (arg1)->Load(*arg2);
9734 wxPyEndAllowThreads(__tstate);
9735 if (PyErr_Occurred()) SWIG_fail;
9736 }
9737 resultobj = SWIG_Py_Void();
9738 return resultobj;
9739 fail:
9740 return NULL;
9741 }
9742
9743
9744 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9745 PyObject *resultobj = 0;
9746 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9747 wxConfigBase *arg2 = 0 ;
9748 void *argp1 = 0 ;
9749 int res1 = 0 ;
9750 void *argp2 = 0 ;
9751 int res2 = 0 ;
9752 PyObject * obj0 = 0 ;
9753 PyObject * obj1 = 0 ;
9754 char * kwnames[] = {
9755 (char *) "self",(char *) "config", NULL
9756 };
9757
9758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9760 if (!SWIG_IsOK(res1)) {
9761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9762 }
9763 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9764 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9765 if (!SWIG_IsOK(res2)) {
9766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9767 }
9768 if (!argp2) {
9769 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9770 }
9771 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9772 {
9773 PyThreadState* __tstate = wxPyBeginAllowThreads();
9774 (arg1)->Save(*arg2);
9775 wxPyEndAllowThreads(__tstate);
9776 if (PyErr_Occurred()) SWIG_fail;
9777 }
9778 resultobj = SWIG_Py_Void();
9779 return resultobj;
9780 fail:
9781 return NULL;
9782 }
9783
9784
9785 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9786 PyObject *resultobj = 0;
9787 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9788 void *argp1 = 0 ;
9789 int res1 = 0 ;
9790 PyObject *swig_obj[1] ;
9791
9792 if (!args) SWIG_fail;
9793 swig_obj[0] = args;
9794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9795 if (!SWIG_IsOK(res1)) {
9796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9797 }
9798 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9799 {
9800 PyThreadState* __tstate = wxPyBeginAllowThreads();
9801 (arg1)->AddFilesToMenu();
9802 wxPyEndAllowThreads(__tstate);
9803 if (PyErr_Occurred()) SWIG_fail;
9804 }
9805 resultobj = SWIG_Py_Void();
9806 return resultobj;
9807 fail:
9808 return NULL;
9809 }
9810
9811
9812 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9813 PyObject *resultobj = 0;
9814 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9815 wxMenu *arg2 = (wxMenu *) 0 ;
9816 void *argp1 = 0 ;
9817 int res1 = 0 ;
9818 void *argp2 = 0 ;
9819 int res2 = 0 ;
9820 PyObject * obj0 = 0 ;
9821 PyObject * obj1 = 0 ;
9822 char * kwnames[] = {
9823 (char *) "self",(char *) "menu", NULL
9824 };
9825
9826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9828 if (!SWIG_IsOK(res1)) {
9829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9830 }
9831 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9832 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9833 if (!SWIG_IsOK(res2)) {
9834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9835 }
9836 arg2 = reinterpret_cast< wxMenu * >(argp2);
9837 {
9838 PyThreadState* __tstate = wxPyBeginAllowThreads();
9839 (arg1)->AddFilesToMenu(arg2);
9840 wxPyEndAllowThreads(__tstate);
9841 if (PyErr_Occurred()) SWIG_fail;
9842 }
9843 resultobj = SWIG_Py_Void();
9844 return resultobj;
9845 fail:
9846 return NULL;
9847 }
9848
9849
9850 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9851 PyObject *resultobj = 0;
9852 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9853 int arg2 ;
9854 wxString result;
9855 void *argp1 = 0 ;
9856 int res1 = 0 ;
9857 int val2 ;
9858 int ecode2 = 0 ;
9859 PyObject * obj0 = 0 ;
9860 PyObject * obj1 = 0 ;
9861 char * kwnames[] = {
9862 (char *) "self",(char *) "i", NULL
9863 };
9864
9865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9867 if (!SWIG_IsOK(res1)) {
9868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9869 }
9870 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9871 ecode2 = SWIG_AsVal_int(obj1, &val2);
9872 if (!SWIG_IsOK(ecode2)) {
9873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9874 }
9875 arg2 = static_cast< int >(val2);
9876 {
9877 PyThreadState* __tstate = wxPyBeginAllowThreads();
9878 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9879 wxPyEndAllowThreads(__tstate);
9880 if (PyErr_Occurred()) SWIG_fail;
9881 }
9882 {
9883 #if wxUSE_UNICODE
9884 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9885 #else
9886 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9887 #endif
9888 }
9889 return resultobj;
9890 fail:
9891 return NULL;
9892 }
9893
9894
9895 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9896 PyObject *resultobj = 0;
9897 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9898 int result;
9899 void *argp1 = 0 ;
9900 int res1 = 0 ;
9901 PyObject *swig_obj[1] ;
9902
9903 if (!args) SWIG_fail;
9904 swig_obj[0] = args;
9905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9906 if (!SWIG_IsOK(res1)) {
9907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9908 }
9909 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9910 {
9911 PyThreadState* __tstate = wxPyBeginAllowThreads();
9912 result = (int)((wxFileHistory const *)arg1)->GetCount();
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 resultobj = SWIG_From_int(static_cast< int >(result));
9917 return resultobj;
9918 fail:
9919 return NULL;
9920 }
9921
9922
9923 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9924 PyObject *obj;
9925 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9926 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9927 return SWIG_Py_Void();
9928 }
9929
9930 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9931 return SWIG_Python_InitShadowInstance(args);
9932 }
9933
9934 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9935 PyObject *resultobj = 0;
9936 wxString *arg1 = 0 ;
9937 wxString const &arg2_defvalue = wxPyEmptyString ;
9938 wxString *arg2 = (wxString *) &arg2_defvalue ;
9939 wxSingleInstanceChecker *result = 0 ;
9940 bool temp1 = false ;
9941 bool temp2 = false ;
9942 PyObject * obj0 = 0 ;
9943 PyObject * obj1 = 0 ;
9944 char * kwnames[] = {
9945 (char *) "name",(char *) "path", NULL
9946 };
9947
9948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9949 {
9950 arg1 = wxString_in_helper(obj0);
9951 if (arg1 == NULL) SWIG_fail;
9952 temp1 = true;
9953 }
9954 if (obj1) {
9955 {
9956 arg2 = wxString_in_helper(obj1);
9957 if (arg2 == NULL) SWIG_fail;
9958 temp2 = true;
9959 }
9960 }
9961 {
9962 PyThreadState* __tstate = wxPyBeginAllowThreads();
9963 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9964 wxPyEndAllowThreads(__tstate);
9965 if (PyErr_Occurred()) SWIG_fail;
9966 }
9967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9968 {
9969 if (temp1)
9970 delete arg1;
9971 }
9972 {
9973 if (temp2)
9974 delete arg2;
9975 }
9976 return resultobj;
9977 fail:
9978 {
9979 if (temp1)
9980 delete arg1;
9981 }
9982 {
9983 if (temp2)
9984 delete arg2;
9985 }
9986 return NULL;
9987 }
9988
9989
9990 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9991 PyObject *resultobj = 0;
9992 wxSingleInstanceChecker *result = 0 ;
9993
9994 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9995 {
9996 PyThreadState* __tstate = wxPyBeginAllowThreads();
9997 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9998 wxPyEndAllowThreads(__tstate);
9999 if (PyErr_Occurred()) SWIG_fail;
10000 }
10001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
10002 return resultobj;
10003 fail:
10004 return NULL;
10005 }
10006
10007
10008 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10009 PyObject *resultobj = 0;
10010 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10011 void *argp1 = 0 ;
10012 int res1 = 0 ;
10013 PyObject *swig_obj[1] ;
10014
10015 if (!args) SWIG_fail;
10016 swig_obj[0] = args;
10017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10018 if (!SWIG_IsOK(res1)) {
10019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10020 }
10021 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10022 {
10023 PyThreadState* __tstate = wxPyBeginAllowThreads();
10024 delete arg1;
10025
10026 wxPyEndAllowThreads(__tstate);
10027 if (PyErr_Occurred()) SWIG_fail;
10028 }
10029 resultobj = SWIG_Py_Void();
10030 return resultobj;
10031 fail:
10032 return NULL;
10033 }
10034
10035
10036 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10037 PyObject *resultobj = 0;
10038 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10039 wxString *arg2 = 0 ;
10040 wxString const &arg3_defvalue = wxPyEmptyString ;
10041 wxString *arg3 = (wxString *) &arg3_defvalue ;
10042 bool result;
10043 void *argp1 = 0 ;
10044 int res1 = 0 ;
10045 bool temp2 = false ;
10046 bool temp3 = false ;
10047 PyObject * obj0 = 0 ;
10048 PyObject * obj1 = 0 ;
10049 PyObject * obj2 = 0 ;
10050 char * kwnames[] = {
10051 (char *) "self",(char *) "name",(char *) "path", NULL
10052 };
10053
10054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10056 if (!SWIG_IsOK(res1)) {
10057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10058 }
10059 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10060 {
10061 arg2 = wxString_in_helper(obj1);
10062 if (arg2 == NULL) SWIG_fail;
10063 temp2 = true;
10064 }
10065 if (obj2) {
10066 {
10067 arg3 = wxString_in_helper(obj2);
10068 if (arg3 == NULL) SWIG_fail;
10069 temp3 = true;
10070 }
10071 }
10072 {
10073 PyThreadState* __tstate = wxPyBeginAllowThreads();
10074 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10075 wxPyEndAllowThreads(__tstate);
10076 if (PyErr_Occurred()) SWIG_fail;
10077 }
10078 {
10079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10080 }
10081 {
10082 if (temp2)
10083 delete arg2;
10084 }
10085 {
10086 if (temp3)
10087 delete arg3;
10088 }
10089 return resultobj;
10090 fail:
10091 {
10092 if (temp2)
10093 delete arg2;
10094 }
10095 {
10096 if (temp3)
10097 delete arg3;
10098 }
10099 return NULL;
10100 }
10101
10102
10103 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10104 PyObject *resultobj = 0;
10105 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10106 bool result;
10107 void *argp1 = 0 ;
10108 int res1 = 0 ;
10109 PyObject *swig_obj[1] ;
10110
10111 if (!args) SWIG_fail;
10112 swig_obj[0] = args;
10113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10114 if (!SWIG_IsOK(res1)) {
10115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10116 }
10117 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10118 {
10119 PyThreadState* __tstate = wxPyBeginAllowThreads();
10120 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10121 wxPyEndAllowThreads(__tstate);
10122 if (PyErr_Occurred()) SWIG_fail;
10123 }
10124 {
10125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10126 }
10127 return resultobj;
10128 fail:
10129 return NULL;
10130 }
10131
10132
10133 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10134 PyObject *obj;
10135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10136 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10137 return SWIG_Py_Void();
10138 }
10139
10140 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10141 return SWIG_Python_InitShadowInstance(args);
10142 }
10143
10144 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10145 PyObject *resultobj = 0;
10146 wxPlatformInfo *result = 0 ;
10147
10148 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10149 {
10150 PyThreadState* __tstate = wxPyBeginAllowThreads();
10151 result = (wxPlatformInfo *)new wxPlatformInfo();
10152 wxPyEndAllowThreads(__tstate);
10153 if (PyErr_Occurred()) SWIG_fail;
10154 }
10155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10156 return resultobj;
10157 fail:
10158 return NULL;
10159 }
10160
10161
10162 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10163 PyObject *resultobj = 0;
10164 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10165 wxPlatformInfo *arg2 = 0 ;
10166 bool result;
10167 void *argp1 = 0 ;
10168 int res1 = 0 ;
10169 void *argp2 = 0 ;
10170 int res2 = 0 ;
10171 PyObject * obj0 = 0 ;
10172 PyObject * obj1 = 0 ;
10173 char * kwnames[] = {
10174 (char *) "self",(char *) "t", NULL
10175 };
10176
10177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10179 if (!SWIG_IsOK(res1)) {
10180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10181 }
10182 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10183 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10184 if (!SWIG_IsOK(res2)) {
10185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10186 }
10187 if (!argp2) {
10188 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10189 }
10190 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10191 {
10192 PyThreadState* __tstate = wxPyBeginAllowThreads();
10193 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10194 wxPyEndAllowThreads(__tstate);
10195 if (PyErr_Occurred()) SWIG_fail;
10196 }
10197 {
10198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10199 }
10200 return resultobj;
10201 fail:
10202 return NULL;
10203 }
10204
10205
10206 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10207 PyObject *resultobj = 0;
10208 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10209 wxPlatformInfo *arg2 = 0 ;
10210 bool result;
10211 void *argp1 = 0 ;
10212 int res1 = 0 ;
10213 void *argp2 = 0 ;
10214 int res2 = 0 ;
10215 PyObject * obj0 = 0 ;
10216 PyObject * obj1 = 0 ;
10217 char * kwnames[] = {
10218 (char *) "self",(char *) "t", NULL
10219 };
10220
10221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10223 if (!SWIG_IsOK(res1)) {
10224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10225 }
10226 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10227 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10228 if (!SWIG_IsOK(res2)) {
10229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10230 }
10231 if (!argp2) {
10232 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10233 }
10234 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10235 {
10236 PyThreadState* __tstate = wxPyBeginAllowThreads();
10237 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10238 wxPyEndAllowThreads(__tstate);
10239 if (PyErr_Occurred()) SWIG_fail;
10240 }
10241 {
10242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10243 }
10244 return resultobj;
10245 fail:
10246 return NULL;
10247 }
10248
10249
10250 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10251 PyObject *resultobj = 0;
10252 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10253 int result;
10254 void *argp1 = 0 ;
10255 int res1 = 0 ;
10256 PyObject *swig_obj[1] ;
10257
10258 if (!args) SWIG_fail;
10259 swig_obj[0] = args;
10260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10261 if (!SWIG_IsOK(res1)) {
10262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10263 }
10264 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10265 {
10266 PyThreadState* __tstate = wxPyBeginAllowThreads();
10267 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10268 wxPyEndAllowThreads(__tstate);
10269 if (PyErr_Occurred()) SWIG_fail;
10270 }
10271 resultobj = SWIG_From_int(static_cast< int >(result));
10272 return resultobj;
10273 fail:
10274 return NULL;
10275 }
10276
10277
10278 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10279 PyObject *resultobj = 0;
10280 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10281 int result;
10282 void *argp1 = 0 ;
10283 int res1 = 0 ;
10284 PyObject *swig_obj[1] ;
10285
10286 if (!args) SWIG_fail;
10287 swig_obj[0] = args;
10288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10289 if (!SWIG_IsOK(res1)) {
10290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10291 }
10292 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10293 {
10294 PyThreadState* __tstate = wxPyBeginAllowThreads();
10295 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10296 wxPyEndAllowThreads(__tstate);
10297 if (PyErr_Occurred()) SWIG_fail;
10298 }
10299 resultobj = SWIG_From_int(static_cast< int >(result));
10300 return resultobj;
10301 fail:
10302 return NULL;
10303 }
10304
10305
10306 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10307 PyObject *resultobj = 0;
10308 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10309 int arg2 ;
10310 int arg3 ;
10311 bool result;
10312 void *argp1 = 0 ;
10313 int res1 = 0 ;
10314 int val2 ;
10315 int ecode2 = 0 ;
10316 int val3 ;
10317 int ecode3 = 0 ;
10318 PyObject * obj0 = 0 ;
10319 PyObject * obj1 = 0 ;
10320 PyObject * obj2 = 0 ;
10321 char * kwnames[] = {
10322 (char *) "self",(char *) "major",(char *) "minor", NULL
10323 };
10324
10325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10327 if (!SWIG_IsOK(res1)) {
10328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10329 }
10330 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10331 ecode2 = SWIG_AsVal_int(obj1, &val2);
10332 if (!SWIG_IsOK(ecode2)) {
10333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10334 }
10335 arg2 = static_cast< int >(val2);
10336 ecode3 = SWIG_AsVal_int(obj2, &val3);
10337 if (!SWIG_IsOK(ecode3)) {
10338 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10339 }
10340 arg3 = static_cast< int >(val3);
10341 {
10342 PyThreadState* __tstate = wxPyBeginAllowThreads();
10343 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10344 wxPyEndAllowThreads(__tstate);
10345 if (PyErr_Occurred()) SWIG_fail;
10346 }
10347 {
10348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10349 }
10350 return resultobj;
10351 fail:
10352 return NULL;
10353 }
10354
10355
10356 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10357 PyObject *resultobj = 0;
10358 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10359 int result;
10360 void *argp1 = 0 ;
10361 int res1 = 0 ;
10362 PyObject *swig_obj[1] ;
10363
10364 if (!args) SWIG_fail;
10365 swig_obj[0] = args;
10366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10367 if (!SWIG_IsOK(res1)) {
10368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10369 }
10370 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10371 {
10372 PyThreadState* __tstate = wxPyBeginAllowThreads();
10373 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10374 wxPyEndAllowThreads(__tstate);
10375 if (PyErr_Occurred()) SWIG_fail;
10376 }
10377 resultobj = SWIG_From_int(static_cast< int >(result));
10378 return resultobj;
10379 fail:
10380 return NULL;
10381 }
10382
10383
10384 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10385 PyObject *resultobj = 0;
10386 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10387 int result;
10388 void *argp1 = 0 ;
10389 int res1 = 0 ;
10390 PyObject *swig_obj[1] ;
10391
10392 if (!args) SWIG_fail;
10393 swig_obj[0] = args;
10394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10395 if (!SWIG_IsOK(res1)) {
10396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10397 }
10398 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10399 {
10400 PyThreadState* __tstate = wxPyBeginAllowThreads();
10401 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10402 wxPyEndAllowThreads(__tstate);
10403 if (PyErr_Occurred()) SWIG_fail;
10404 }
10405 resultobj = SWIG_From_int(static_cast< int >(result));
10406 return resultobj;
10407 fail:
10408 return NULL;
10409 }
10410
10411
10412 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10413 PyObject *resultobj = 0;
10414 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10415 int arg2 ;
10416 int arg3 ;
10417 bool result;
10418 void *argp1 = 0 ;
10419 int res1 = 0 ;
10420 int val2 ;
10421 int ecode2 = 0 ;
10422 int val3 ;
10423 int ecode3 = 0 ;
10424 PyObject * obj0 = 0 ;
10425 PyObject * obj1 = 0 ;
10426 PyObject * obj2 = 0 ;
10427 char * kwnames[] = {
10428 (char *) "self",(char *) "major",(char *) "minor", NULL
10429 };
10430
10431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10433 if (!SWIG_IsOK(res1)) {
10434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10435 }
10436 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10437 ecode2 = SWIG_AsVal_int(obj1, &val2);
10438 if (!SWIG_IsOK(ecode2)) {
10439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10440 }
10441 arg2 = static_cast< int >(val2);
10442 ecode3 = SWIG_AsVal_int(obj2, &val3);
10443 if (!SWIG_IsOK(ecode3)) {
10444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10445 }
10446 arg3 = static_cast< int >(val3);
10447 {
10448 PyThreadState* __tstate = wxPyBeginAllowThreads();
10449 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10450 wxPyEndAllowThreads(__tstate);
10451 if (PyErr_Occurred()) SWIG_fail;
10452 }
10453 {
10454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10455 }
10456 return resultobj;
10457 fail:
10458 return NULL;
10459 }
10460
10461
10462 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10463 PyObject *resultobj = 0;
10464 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10465 bool result;
10466 void *argp1 = 0 ;
10467 int res1 = 0 ;
10468 PyObject *swig_obj[1] ;
10469
10470 if (!args) SWIG_fail;
10471 swig_obj[0] = args;
10472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10473 if (!SWIG_IsOK(res1)) {
10474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10475 }
10476 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10477 {
10478 PyThreadState* __tstate = wxPyBeginAllowThreads();
10479 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10480 wxPyEndAllowThreads(__tstate);
10481 if (PyErr_Occurred()) SWIG_fail;
10482 }
10483 {
10484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10485 }
10486 return resultobj;
10487 fail:
10488 return NULL;
10489 }
10490
10491
10492 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10493 PyObject *resultobj = 0;
10494 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10495 wxOperatingSystemId result;
10496 void *argp1 = 0 ;
10497 int res1 = 0 ;
10498 PyObject *swig_obj[1] ;
10499
10500 if (!args) SWIG_fail;
10501 swig_obj[0] = args;
10502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10503 if (!SWIG_IsOK(res1)) {
10504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10505 }
10506 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10507 {
10508 PyThreadState* __tstate = wxPyBeginAllowThreads();
10509 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10510 wxPyEndAllowThreads(__tstate);
10511 if (PyErr_Occurred()) SWIG_fail;
10512 }
10513 resultobj = SWIG_From_int(static_cast< int >(result));
10514 return resultobj;
10515 fail:
10516 return NULL;
10517 }
10518
10519
10520 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10521 PyObject *resultobj = 0;
10522 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10523 wxPortId result;
10524 void *argp1 = 0 ;
10525 int res1 = 0 ;
10526 PyObject *swig_obj[1] ;
10527
10528 if (!args) SWIG_fail;
10529 swig_obj[0] = args;
10530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10531 if (!SWIG_IsOK(res1)) {
10532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10533 }
10534 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10535 {
10536 PyThreadState* __tstate = wxPyBeginAllowThreads();
10537 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10538 wxPyEndAllowThreads(__tstate);
10539 if (PyErr_Occurred()) SWIG_fail;
10540 }
10541 resultobj = SWIG_From_int(static_cast< int >(result));
10542 return resultobj;
10543 fail:
10544 return NULL;
10545 }
10546
10547
10548 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10549 PyObject *resultobj = 0;
10550 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10551 wxArchitecture result;
10552 void *argp1 = 0 ;
10553 int res1 = 0 ;
10554 PyObject *swig_obj[1] ;
10555
10556 if (!args) SWIG_fail;
10557 swig_obj[0] = args;
10558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10559 if (!SWIG_IsOK(res1)) {
10560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10561 }
10562 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10563 {
10564 PyThreadState* __tstate = wxPyBeginAllowThreads();
10565 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10566 wxPyEndAllowThreads(__tstate);
10567 if (PyErr_Occurred()) SWIG_fail;
10568 }
10569 resultobj = SWIG_From_int(static_cast< int >(result));
10570 return resultobj;
10571 fail:
10572 return NULL;
10573 }
10574
10575
10576 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10577 PyObject *resultobj = 0;
10578 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10579 wxEndianness result;
10580 void *argp1 = 0 ;
10581 int res1 = 0 ;
10582 PyObject *swig_obj[1] ;
10583
10584 if (!args) SWIG_fail;
10585 swig_obj[0] = args;
10586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10587 if (!SWIG_IsOK(res1)) {
10588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10589 }
10590 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10591 {
10592 PyThreadState* __tstate = wxPyBeginAllowThreads();
10593 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10594 wxPyEndAllowThreads(__tstate);
10595 if (PyErr_Occurred()) SWIG_fail;
10596 }
10597 resultobj = SWIG_From_int(static_cast< int >(result));
10598 return resultobj;
10599 fail:
10600 return NULL;
10601 }
10602
10603
10604 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10605 PyObject *resultobj = 0;
10606 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10607 wxString result;
10608 void *argp1 = 0 ;
10609 int res1 = 0 ;
10610 PyObject *swig_obj[1] ;
10611
10612 if (!args) SWIG_fail;
10613 swig_obj[0] = args;
10614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10615 if (!SWIG_IsOK(res1)) {
10616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10617 }
10618 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10619 {
10620 PyThreadState* __tstate = wxPyBeginAllowThreads();
10621 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10622 wxPyEndAllowThreads(__tstate);
10623 if (PyErr_Occurred()) SWIG_fail;
10624 }
10625 {
10626 #if wxUSE_UNICODE
10627 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10628 #else
10629 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10630 #endif
10631 }
10632 return resultobj;
10633 fail:
10634 return NULL;
10635 }
10636
10637
10638 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10639 PyObject *resultobj = 0;
10640 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10641 wxString result;
10642 void *argp1 = 0 ;
10643 int res1 = 0 ;
10644 PyObject *swig_obj[1] ;
10645
10646 if (!args) SWIG_fail;
10647 swig_obj[0] = args;
10648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10649 if (!SWIG_IsOK(res1)) {
10650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10651 }
10652 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10653 {
10654 PyThreadState* __tstate = wxPyBeginAllowThreads();
10655 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10656 wxPyEndAllowThreads(__tstate);
10657 if (PyErr_Occurred()) SWIG_fail;
10658 }
10659 {
10660 #if wxUSE_UNICODE
10661 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10662 #else
10663 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10664 #endif
10665 }
10666 return resultobj;
10667 fail:
10668 return NULL;
10669 }
10670
10671
10672 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10673 PyObject *resultobj = 0;
10674 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10675 wxString result;
10676 void *argp1 = 0 ;
10677 int res1 = 0 ;
10678 PyObject *swig_obj[1] ;
10679
10680 if (!args) SWIG_fail;
10681 swig_obj[0] = args;
10682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10683 if (!SWIG_IsOK(res1)) {
10684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10685 }
10686 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10687 {
10688 PyThreadState* __tstate = wxPyBeginAllowThreads();
10689 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10690 wxPyEndAllowThreads(__tstate);
10691 if (PyErr_Occurred()) SWIG_fail;
10692 }
10693 {
10694 #if wxUSE_UNICODE
10695 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10696 #else
10697 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10698 #endif
10699 }
10700 return resultobj;
10701 fail:
10702 return NULL;
10703 }
10704
10705
10706 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10707 PyObject *resultobj = 0;
10708 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10709 wxString result;
10710 void *argp1 = 0 ;
10711 int res1 = 0 ;
10712 PyObject *swig_obj[1] ;
10713
10714 if (!args) SWIG_fail;
10715 swig_obj[0] = args;
10716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10717 if (!SWIG_IsOK(res1)) {
10718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10719 }
10720 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10721 {
10722 PyThreadState* __tstate = wxPyBeginAllowThreads();
10723 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10724 wxPyEndAllowThreads(__tstate);
10725 if (PyErr_Occurred()) SWIG_fail;
10726 }
10727 {
10728 #if wxUSE_UNICODE
10729 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10730 #else
10731 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10732 #endif
10733 }
10734 return resultobj;
10735 fail:
10736 return NULL;
10737 }
10738
10739
10740 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10741 PyObject *resultobj = 0;
10742 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10743 wxString result;
10744 void *argp1 = 0 ;
10745 int res1 = 0 ;
10746 PyObject *swig_obj[1] ;
10747
10748 if (!args) SWIG_fail;
10749 swig_obj[0] = args;
10750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10751 if (!SWIG_IsOK(res1)) {
10752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10753 }
10754 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10755 {
10756 PyThreadState* __tstate = wxPyBeginAllowThreads();
10757 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10758 wxPyEndAllowThreads(__tstate);
10759 if (PyErr_Occurred()) SWIG_fail;
10760 }
10761 {
10762 #if wxUSE_UNICODE
10763 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10764 #else
10765 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10766 #endif
10767 }
10768 return resultobj;
10769 fail:
10770 return NULL;
10771 }
10772
10773
10774 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10775 PyObject *resultobj = 0;
10776 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10777 wxString result;
10778 void *argp1 = 0 ;
10779 int res1 = 0 ;
10780 PyObject *swig_obj[1] ;
10781
10782 if (!args) SWIG_fail;
10783 swig_obj[0] = args;
10784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10785 if (!SWIG_IsOK(res1)) {
10786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10787 }
10788 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10789 {
10790 PyThreadState* __tstate = wxPyBeginAllowThreads();
10791 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10792 wxPyEndAllowThreads(__tstate);
10793 if (PyErr_Occurred()) SWIG_fail;
10794 }
10795 {
10796 #if wxUSE_UNICODE
10797 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10798 #else
10799 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10800 #endif
10801 }
10802 return resultobj;
10803 fail:
10804 return NULL;
10805 }
10806
10807
10808 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10809 PyObject *resultobj = 0;
10810 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10811 int arg2 ;
10812 int arg3 ;
10813 void *argp1 = 0 ;
10814 int res1 = 0 ;
10815 int val2 ;
10816 int ecode2 = 0 ;
10817 int val3 ;
10818 int ecode3 = 0 ;
10819 PyObject * obj0 = 0 ;
10820 PyObject * obj1 = 0 ;
10821 PyObject * obj2 = 0 ;
10822 char * kwnames[] = {
10823 (char *) "self",(char *) "major",(char *) "minor", NULL
10824 };
10825
10826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10828 if (!SWIG_IsOK(res1)) {
10829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10830 }
10831 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10832 ecode2 = SWIG_AsVal_int(obj1, &val2);
10833 if (!SWIG_IsOK(ecode2)) {
10834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10835 }
10836 arg2 = static_cast< int >(val2);
10837 ecode3 = SWIG_AsVal_int(obj2, &val3);
10838 if (!SWIG_IsOK(ecode3)) {
10839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10840 }
10841 arg3 = static_cast< int >(val3);
10842 {
10843 PyThreadState* __tstate = wxPyBeginAllowThreads();
10844 (arg1)->SetOSVersion(arg2,arg3);
10845 wxPyEndAllowThreads(__tstate);
10846 if (PyErr_Occurred()) SWIG_fail;
10847 }
10848 resultobj = SWIG_Py_Void();
10849 return resultobj;
10850 fail:
10851 return NULL;
10852 }
10853
10854
10855 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10856 PyObject *resultobj = 0;
10857 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10858 int arg2 ;
10859 int arg3 ;
10860 void *argp1 = 0 ;
10861 int res1 = 0 ;
10862 int val2 ;
10863 int ecode2 = 0 ;
10864 int val3 ;
10865 int ecode3 = 0 ;
10866 PyObject * obj0 = 0 ;
10867 PyObject * obj1 = 0 ;
10868 PyObject * obj2 = 0 ;
10869 char * kwnames[] = {
10870 (char *) "self",(char *) "major",(char *) "minor", NULL
10871 };
10872
10873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10875 if (!SWIG_IsOK(res1)) {
10876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10877 }
10878 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10879 ecode2 = SWIG_AsVal_int(obj1, &val2);
10880 if (!SWIG_IsOK(ecode2)) {
10881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10882 }
10883 arg2 = static_cast< int >(val2);
10884 ecode3 = SWIG_AsVal_int(obj2, &val3);
10885 if (!SWIG_IsOK(ecode3)) {
10886 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10887 }
10888 arg3 = static_cast< int >(val3);
10889 {
10890 PyThreadState* __tstate = wxPyBeginAllowThreads();
10891 (arg1)->SetToolkitVersion(arg2,arg3);
10892 wxPyEndAllowThreads(__tstate);
10893 if (PyErr_Occurred()) SWIG_fail;
10894 }
10895 resultobj = SWIG_Py_Void();
10896 return resultobj;
10897 fail:
10898 return NULL;
10899 }
10900
10901
10902 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10903 PyObject *resultobj = 0;
10904 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10905 wxOperatingSystemId arg2 ;
10906 void *argp1 = 0 ;
10907 int res1 = 0 ;
10908 int val2 ;
10909 int ecode2 = 0 ;
10910 PyObject * obj0 = 0 ;
10911 PyObject * obj1 = 0 ;
10912 char * kwnames[] = {
10913 (char *) "self",(char *) "n", NULL
10914 };
10915
10916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10918 if (!SWIG_IsOK(res1)) {
10919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10920 }
10921 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10922 ecode2 = SWIG_AsVal_int(obj1, &val2);
10923 if (!SWIG_IsOK(ecode2)) {
10924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10925 }
10926 arg2 = static_cast< wxOperatingSystemId >(val2);
10927 {
10928 PyThreadState* __tstate = wxPyBeginAllowThreads();
10929 (arg1)->SetOperatingSystemId(arg2);
10930 wxPyEndAllowThreads(__tstate);
10931 if (PyErr_Occurred()) SWIG_fail;
10932 }
10933 resultobj = SWIG_Py_Void();
10934 return resultobj;
10935 fail:
10936 return NULL;
10937 }
10938
10939
10940 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10941 PyObject *resultobj = 0;
10942 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10943 wxPortId arg2 ;
10944 void *argp1 = 0 ;
10945 int res1 = 0 ;
10946 int val2 ;
10947 int ecode2 = 0 ;
10948 PyObject * obj0 = 0 ;
10949 PyObject * obj1 = 0 ;
10950 char * kwnames[] = {
10951 (char *) "self",(char *) "n", NULL
10952 };
10953
10954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10956 if (!SWIG_IsOK(res1)) {
10957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10958 }
10959 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10960 ecode2 = SWIG_AsVal_int(obj1, &val2);
10961 if (!SWIG_IsOK(ecode2)) {
10962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10963 }
10964 arg2 = static_cast< wxPortId >(val2);
10965 {
10966 PyThreadState* __tstate = wxPyBeginAllowThreads();
10967 (arg1)->SetPortId(arg2);
10968 wxPyEndAllowThreads(__tstate);
10969 if (PyErr_Occurred()) SWIG_fail;
10970 }
10971 resultobj = SWIG_Py_Void();
10972 return resultobj;
10973 fail:
10974 return NULL;
10975 }
10976
10977
10978 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10979 PyObject *resultobj = 0;
10980 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10981 wxArchitecture arg2 ;
10982 void *argp1 = 0 ;
10983 int res1 = 0 ;
10984 int val2 ;
10985 int ecode2 = 0 ;
10986 PyObject * obj0 = 0 ;
10987 PyObject * obj1 = 0 ;
10988 char * kwnames[] = {
10989 (char *) "self",(char *) "n", NULL
10990 };
10991
10992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10994 if (!SWIG_IsOK(res1)) {
10995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10996 }
10997 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10998 ecode2 = SWIG_AsVal_int(obj1, &val2);
10999 if (!SWIG_IsOK(ecode2)) {
11000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
11001 }
11002 arg2 = static_cast< wxArchitecture >(val2);
11003 {
11004 PyThreadState* __tstate = wxPyBeginAllowThreads();
11005 (arg1)->SetArchitecture(arg2);
11006 wxPyEndAllowThreads(__tstate);
11007 if (PyErr_Occurred()) SWIG_fail;
11008 }
11009 resultobj = SWIG_Py_Void();
11010 return resultobj;
11011 fail:
11012 return NULL;
11013 }
11014
11015
11016 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11017 PyObject *resultobj = 0;
11018 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11019 wxEndianness arg2 ;
11020 void *argp1 = 0 ;
11021 int res1 = 0 ;
11022 int val2 ;
11023 int ecode2 = 0 ;
11024 PyObject * obj0 = 0 ;
11025 PyObject * obj1 = 0 ;
11026 char * kwnames[] = {
11027 (char *) "self",(char *) "n", NULL
11028 };
11029
11030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11032 if (!SWIG_IsOK(res1)) {
11033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11034 }
11035 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11036 ecode2 = SWIG_AsVal_int(obj1, &val2);
11037 if (!SWIG_IsOK(ecode2)) {
11038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11039 }
11040 arg2 = static_cast< wxEndianness >(val2);
11041 {
11042 PyThreadState* __tstate = wxPyBeginAllowThreads();
11043 (arg1)->SetEndianness(arg2);
11044 wxPyEndAllowThreads(__tstate);
11045 if (PyErr_Occurred()) SWIG_fail;
11046 }
11047 resultobj = SWIG_Py_Void();
11048 return resultobj;
11049 fail:
11050 return NULL;
11051 }
11052
11053
11054 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11055 PyObject *resultobj = 0;
11056 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11057 bool result;
11058 void *argp1 = 0 ;
11059 int res1 = 0 ;
11060 PyObject *swig_obj[1] ;
11061
11062 if (!args) SWIG_fail;
11063 swig_obj[0] = args;
11064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11065 if (!SWIG_IsOK(res1)) {
11066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11067 }
11068 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11069 {
11070 PyThreadState* __tstate = wxPyBeginAllowThreads();
11071 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11072 wxPyEndAllowThreads(__tstate);
11073 if (PyErr_Occurred()) SWIG_fail;
11074 }
11075 {
11076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11077 }
11078 return resultobj;
11079 fail:
11080 return NULL;
11081 }
11082
11083
11084 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11085 PyObject *obj;
11086 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11087 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11088 return SWIG_Py_Void();
11089 }
11090
11091 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11092 return SWIG_Python_InitShadowInstance(args);
11093 }
11094
11095 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11096 PyObject *resultobj = 0;
11097 wxWindow *arg1 = (wxWindow *) 0 ;
11098 wxDC *arg2 = 0 ;
11099 bool result;
11100 void *argp1 = 0 ;
11101 int res1 = 0 ;
11102 void *argp2 = 0 ;
11103 int res2 = 0 ;
11104 PyObject * obj0 = 0 ;
11105 PyObject * obj1 = 0 ;
11106 char * kwnames[] = {
11107 (char *) "window",(char *) "dc", NULL
11108 };
11109
11110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11112 if (!SWIG_IsOK(res1)) {
11113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11114 }
11115 arg1 = reinterpret_cast< wxWindow * >(argp1);
11116 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11117 if (!SWIG_IsOK(res2)) {
11118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11119 }
11120 if (!argp2) {
11121 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11122 }
11123 arg2 = reinterpret_cast< wxDC * >(argp2);
11124 {
11125 PyThreadState* __tstate = wxPyBeginAllowThreads();
11126 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11127 wxPyEndAllowThreads(__tstate);
11128 if (PyErr_Occurred()) SWIG_fail;
11129 }
11130 {
11131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11132 }
11133 return resultobj;
11134 fail:
11135 return NULL;
11136 }
11137
11138
11139 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11140 PyObject *resultobj = 0;
11141 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11142 void *argp1 = 0 ;
11143 int res1 = 0 ;
11144 PyObject *swig_obj[1] ;
11145
11146 if (!args) SWIG_fail;
11147 swig_obj[0] = args;
11148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11149 if (!SWIG_IsOK(res1)) {
11150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11151 }
11152 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11153 {
11154 PyThreadState* __tstate = wxPyBeginAllowThreads();
11155 delete arg1;
11156
11157 wxPyEndAllowThreads(__tstate);
11158 if (PyErr_Occurred()) SWIG_fail;
11159 }
11160 resultobj = SWIG_Py_Void();
11161 return resultobj;
11162 fail:
11163 return NULL;
11164 }
11165
11166
11167 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11168 PyObject *resultobj = 0;
11169 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11170 wxString result;
11171 void *argp1 = 0 ;
11172 int res1 = 0 ;
11173 PyObject *swig_obj[1] ;
11174
11175 if (!args) SWIG_fail;
11176 swig_obj[0] = args;
11177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11178 if (!SWIG_IsOK(res1)) {
11179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11180 }
11181 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11182 {
11183 PyThreadState* __tstate = wxPyBeginAllowThreads();
11184 result = (arg1)->GetTip();
11185 wxPyEndAllowThreads(__tstate);
11186 if (PyErr_Occurred()) SWIG_fail;
11187 }
11188 {
11189 #if wxUSE_UNICODE
11190 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11191 #else
11192 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11193 #endif
11194 }
11195 return resultobj;
11196 fail:
11197 return NULL;
11198 }
11199
11200
11201 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11202 PyObject *resultobj = 0;
11203 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11204 size_t result;
11205 void *argp1 = 0 ;
11206 int res1 = 0 ;
11207 PyObject *swig_obj[1] ;
11208
11209 if (!args) SWIG_fail;
11210 swig_obj[0] = args;
11211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11212 if (!SWIG_IsOK(res1)) {
11213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11214 }
11215 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11216 {
11217 PyThreadState* __tstate = wxPyBeginAllowThreads();
11218 result = (size_t)(arg1)->GetCurrentTip();
11219 wxPyEndAllowThreads(__tstate);
11220 if (PyErr_Occurred()) SWIG_fail;
11221 }
11222 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11223 return resultobj;
11224 fail:
11225 return NULL;
11226 }
11227
11228
11229 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11230 PyObject *resultobj = 0;
11231 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11232 wxString *arg2 = 0 ;
11233 wxString result;
11234 void *argp1 = 0 ;
11235 int res1 = 0 ;
11236 bool temp2 = false ;
11237 PyObject * obj0 = 0 ;
11238 PyObject * obj1 = 0 ;
11239 char * kwnames[] = {
11240 (char *) "self",(char *) "tip", NULL
11241 };
11242
11243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11245 if (!SWIG_IsOK(res1)) {
11246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11247 }
11248 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11249 {
11250 arg2 = wxString_in_helper(obj1);
11251 if (arg2 == NULL) SWIG_fail;
11252 temp2 = true;
11253 }
11254 {
11255 PyThreadState* __tstate = wxPyBeginAllowThreads();
11256 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11257 wxPyEndAllowThreads(__tstate);
11258 if (PyErr_Occurred()) SWIG_fail;
11259 }
11260 {
11261 #if wxUSE_UNICODE
11262 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11263 #else
11264 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11265 #endif
11266 }
11267 {
11268 if (temp2)
11269 delete arg2;
11270 }
11271 return resultobj;
11272 fail:
11273 {
11274 if (temp2)
11275 delete arg2;
11276 }
11277 return NULL;
11278 }
11279
11280
11281 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11282 PyObject *obj;
11283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11284 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11285 return SWIG_Py_Void();
11286 }
11287
11288 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11289 PyObject *resultobj = 0;
11290 size_t arg1 ;
11291 wxPyTipProvider *result = 0 ;
11292 size_t val1 ;
11293 int ecode1 = 0 ;
11294 PyObject * obj0 = 0 ;
11295 char * kwnames[] = {
11296 (char *) "currentTip", NULL
11297 };
11298
11299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11300 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11301 if (!SWIG_IsOK(ecode1)) {
11302 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11303 }
11304 arg1 = static_cast< size_t >(val1);
11305 {
11306 PyThreadState* __tstate = wxPyBeginAllowThreads();
11307 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11308 wxPyEndAllowThreads(__tstate);
11309 if (PyErr_Occurred()) SWIG_fail;
11310 }
11311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11312 return resultobj;
11313 fail:
11314 return NULL;
11315 }
11316
11317
11318 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11319 PyObject *resultobj = 0;
11320 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11321 PyObject *arg2 = (PyObject *) 0 ;
11322 PyObject *arg3 = (PyObject *) 0 ;
11323 void *argp1 = 0 ;
11324 int res1 = 0 ;
11325 PyObject * obj0 = 0 ;
11326 PyObject * obj1 = 0 ;
11327 PyObject * obj2 = 0 ;
11328 char * kwnames[] = {
11329 (char *) "self",(char *) "self",(char *) "_class", NULL
11330 };
11331
11332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11334 if (!SWIG_IsOK(res1)) {
11335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11336 }
11337 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11338 arg2 = obj1;
11339 arg3 = obj2;
11340 {
11341 PyThreadState* __tstate = wxPyBeginAllowThreads();
11342 (arg1)->_setCallbackInfo(arg2,arg3);
11343 wxPyEndAllowThreads(__tstate);
11344 if (PyErr_Occurred()) SWIG_fail;
11345 }
11346 resultobj = SWIG_Py_Void();
11347 return resultobj;
11348 fail:
11349 return NULL;
11350 }
11351
11352
11353 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11354 PyObject *obj;
11355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11356 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11357 return SWIG_Py_Void();
11358 }
11359
11360 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11361 return SWIG_Python_InitShadowInstance(args);
11362 }
11363
11364 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11365 PyObject *resultobj = 0;
11366 wxWindow *arg1 = (wxWindow *) 0 ;
11367 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11368 bool arg3 = (bool) true ;
11369 bool result;
11370 void *argp1 = 0 ;
11371 int res1 = 0 ;
11372 void *argp2 = 0 ;
11373 int res2 = 0 ;
11374 bool val3 ;
11375 int ecode3 = 0 ;
11376 PyObject * obj0 = 0 ;
11377 PyObject * obj1 = 0 ;
11378 PyObject * obj2 = 0 ;
11379 char * kwnames[] = {
11380 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11381 };
11382
11383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11385 if (!SWIG_IsOK(res1)) {
11386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11387 }
11388 arg1 = reinterpret_cast< wxWindow * >(argp1);
11389 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11390 if (!SWIG_IsOK(res2)) {
11391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11392 }
11393 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11394 if (obj2) {
11395 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11396 if (!SWIG_IsOK(ecode3)) {
11397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11398 }
11399 arg3 = static_cast< bool >(val3);
11400 }
11401 {
11402 if (!wxPyCheckForApp()) SWIG_fail;
11403 PyThreadState* __tstate = wxPyBeginAllowThreads();
11404 result = (bool)wxShowTip(arg1,arg2,arg3);
11405 wxPyEndAllowThreads(__tstate);
11406 if (PyErr_Occurred()) SWIG_fail;
11407 }
11408 {
11409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11410 }
11411 return resultobj;
11412 fail:
11413 return NULL;
11414 }
11415
11416
11417 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11418 PyObject *resultobj = 0;
11419 wxString *arg1 = 0 ;
11420 size_t arg2 ;
11421 wxTipProvider *result = 0 ;
11422 bool temp1 = false ;
11423 size_t val2 ;
11424 int ecode2 = 0 ;
11425 PyObject * obj0 = 0 ;
11426 PyObject * obj1 = 0 ;
11427 char * kwnames[] = {
11428 (char *) "filename",(char *) "currentTip", NULL
11429 };
11430
11431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11432 {
11433 arg1 = wxString_in_helper(obj0);
11434 if (arg1 == NULL) SWIG_fail;
11435 temp1 = true;
11436 }
11437 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11438 if (!SWIG_IsOK(ecode2)) {
11439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11440 }
11441 arg2 = static_cast< size_t >(val2);
11442 {
11443 if (!wxPyCheckForApp()) SWIG_fail;
11444 PyThreadState* __tstate = wxPyBeginAllowThreads();
11445 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11446 wxPyEndAllowThreads(__tstate);
11447 if (PyErr_Occurred()) SWIG_fail;
11448 }
11449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11450 {
11451 if (temp1)
11452 delete arg1;
11453 }
11454 return resultobj;
11455 fail:
11456 {
11457 if (temp1)
11458 delete arg1;
11459 }
11460 return NULL;
11461 }
11462
11463
11464 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11465 PyObject *resultobj = 0;
11466 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11467 int arg2 = (int) wxID_ANY ;
11468 wxPyTimer *result = 0 ;
11469 void *argp1 = 0 ;
11470 int res1 = 0 ;
11471 int val2 ;
11472 int ecode2 = 0 ;
11473 PyObject * obj0 = 0 ;
11474 PyObject * obj1 = 0 ;
11475 char * kwnames[] = {
11476 (char *) "owner",(char *) "id", NULL
11477 };
11478
11479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11480 if (obj0) {
11481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11482 if (!SWIG_IsOK(res1)) {
11483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11484 }
11485 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11486 }
11487 if (obj1) {
11488 ecode2 = SWIG_AsVal_int(obj1, &val2);
11489 if (!SWIG_IsOK(ecode2)) {
11490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11491 }
11492 arg2 = static_cast< int >(val2);
11493 }
11494 {
11495 if (!wxPyCheckForApp()) SWIG_fail;
11496 PyThreadState* __tstate = wxPyBeginAllowThreads();
11497 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11498 wxPyEndAllowThreads(__tstate);
11499 if (PyErr_Occurred()) SWIG_fail;
11500 }
11501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11502 return resultobj;
11503 fail:
11504 return NULL;
11505 }
11506
11507
11508 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11509 PyObject *resultobj = 0;
11510 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11511 void *argp1 = 0 ;
11512 int res1 = 0 ;
11513 PyObject *swig_obj[1] ;
11514
11515 if (!args) SWIG_fail;
11516 swig_obj[0] = args;
11517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11518 if (!SWIG_IsOK(res1)) {
11519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11520 }
11521 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11522 {
11523 PyThreadState* __tstate = wxPyBeginAllowThreads();
11524 delete arg1;
11525
11526 wxPyEndAllowThreads(__tstate);
11527 if (PyErr_Occurred()) SWIG_fail;
11528 }
11529 resultobj = SWIG_Py_Void();
11530 return resultobj;
11531 fail:
11532 return NULL;
11533 }
11534
11535
11536 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11537 PyObject *resultobj = 0;
11538 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11539 PyObject *arg2 = (PyObject *) 0 ;
11540 PyObject *arg3 = (PyObject *) 0 ;
11541 int arg4 = (int) 0 ;
11542 void *argp1 = 0 ;
11543 int res1 = 0 ;
11544 int val4 ;
11545 int ecode4 = 0 ;
11546 PyObject * obj0 = 0 ;
11547 PyObject * obj1 = 0 ;
11548 PyObject * obj2 = 0 ;
11549 PyObject * obj3 = 0 ;
11550 char * kwnames[] = {
11551 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11552 };
11553
11554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11556 if (!SWIG_IsOK(res1)) {
11557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11558 }
11559 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11560 arg2 = obj1;
11561 arg3 = obj2;
11562 if (obj3) {
11563 ecode4 = SWIG_AsVal_int(obj3, &val4);
11564 if (!SWIG_IsOK(ecode4)) {
11565 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11566 }
11567 arg4 = static_cast< int >(val4);
11568 }
11569 {
11570 PyThreadState* __tstate = wxPyBeginAllowThreads();
11571 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11572 wxPyEndAllowThreads(__tstate);
11573 if (PyErr_Occurred()) SWIG_fail;
11574 }
11575 resultobj = SWIG_Py_Void();
11576 return resultobj;
11577 fail:
11578 return NULL;
11579 }
11580
11581
11582 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11583 PyObject *resultobj = 0;
11584 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11585 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11586 int arg3 = (int) wxID_ANY ;
11587 void *argp1 = 0 ;
11588 int res1 = 0 ;
11589 void *argp2 = 0 ;
11590 int res2 = 0 ;
11591 int val3 ;
11592 int ecode3 = 0 ;
11593 PyObject * obj0 = 0 ;
11594 PyObject * obj1 = 0 ;
11595 PyObject * obj2 = 0 ;
11596 char * kwnames[] = {
11597 (char *) "self",(char *) "owner",(char *) "id", NULL
11598 };
11599
11600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11602 if (!SWIG_IsOK(res1)) {
11603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11604 }
11605 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11606 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11607 if (!SWIG_IsOK(res2)) {
11608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11609 }
11610 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11611 if (obj2) {
11612 ecode3 = SWIG_AsVal_int(obj2, &val3);
11613 if (!SWIG_IsOK(ecode3)) {
11614 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11615 }
11616 arg3 = static_cast< int >(val3);
11617 }
11618 {
11619 PyThreadState* __tstate = wxPyBeginAllowThreads();
11620 (arg1)->SetOwner(arg2,arg3);
11621 wxPyEndAllowThreads(__tstate);
11622 if (PyErr_Occurred()) SWIG_fail;
11623 }
11624 resultobj = SWIG_Py_Void();
11625 return resultobj;
11626 fail:
11627 return NULL;
11628 }
11629
11630
11631 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11632 PyObject *resultobj = 0;
11633 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11634 wxEvtHandler *result = 0 ;
11635 void *argp1 = 0 ;
11636 int res1 = 0 ;
11637 PyObject *swig_obj[1] ;
11638
11639 if (!args) SWIG_fail;
11640 swig_obj[0] = args;
11641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11642 if (!SWIG_IsOK(res1)) {
11643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11644 }
11645 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11646 {
11647 PyThreadState* __tstate = wxPyBeginAllowThreads();
11648 result = (wxEvtHandler *)(arg1)->GetOwner();
11649 wxPyEndAllowThreads(__tstate);
11650 if (PyErr_Occurred()) SWIG_fail;
11651 }
11652 {
11653 resultobj = wxPyMake_wxObject(result, 0);
11654 }
11655 return resultobj;
11656 fail:
11657 return NULL;
11658 }
11659
11660
11661 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11662 PyObject *resultobj = 0;
11663 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11664 int arg2 = (int) -1 ;
11665 bool arg3 = (bool) false ;
11666 bool result;
11667 void *argp1 = 0 ;
11668 int res1 = 0 ;
11669 int val2 ;
11670 int ecode2 = 0 ;
11671 bool val3 ;
11672 int ecode3 = 0 ;
11673 PyObject * obj0 = 0 ;
11674 PyObject * obj1 = 0 ;
11675 PyObject * obj2 = 0 ;
11676 char * kwnames[] = {
11677 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11678 };
11679
11680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11682 if (!SWIG_IsOK(res1)) {
11683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11684 }
11685 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11686 if (obj1) {
11687 ecode2 = SWIG_AsVal_int(obj1, &val2);
11688 if (!SWIG_IsOK(ecode2)) {
11689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11690 }
11691 arg2 = static_cast< int >(val2);
11692 }
11693 if (obj2) {
11694 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11695 if (!SWIG_IsOK(ecode3)) {
11696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11697 }
11698 arg3 = static_cast< bool >(val3);
11699 }
11700 {
11701 PyThreadState* __tstate = wxPyBeginAllowThreads();
11702 result = (bool)(arg1)->Start(arg2,arg3);
11703 wxPyEndAllowThreads(__tstate);
11704 if (PyErr_Occurred()) SWIG_fail;
11705 }
11706 {
11707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11708 }
11709 return resultobj;
11710 fail:
11711 return NULL;
11712 }
11713
11714
11715 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11716 PyObject *resultobj = 0;
11717 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11718 void *argp1 = 0 ;
11719 int res1 = 0 ;
11720 PyObject *swig_obj[1] ;
11721
11722 if (!args) SWIG_fail;
11723 swig_obj[0] = args;
11724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11725 if (!SWIG_IsOK(res1)) {
11726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11727 }
11728 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11729 {
11730 PyThreadState* __tstate = wxPyBeginAllowThreads();
11731 (arg1)->Stop();
11732 wxPyEndAllowThreads(__tstate);
11733 if (PyErr_Occurred()) SWIG_fail;
11734 }
11735 resultobj = SWIG_Py_Void();
11736 return resultobj;
11737 fail:
11738 return NULL;
11739 }
11740
11741
11742 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11743 PyObject *resultobj = 0;
11744 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11745 void *argp1 = 0 ;
11746 int res1 = 0 ;
11747 PyObject *swig_obj[1] ;
11748
11749 if (!args) SWIG_fail;
11750 swig_obj[0] = args;
11751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11752 if (!SWIG_IsOK(res1)) {
11753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11754 }
11755 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11756 {
11757 PyThreadState* __tstate = wxPyBeginAllowThreads();
11758 (arg1)->Notify();
11759 wxPyEndAllowThreads(__tstate);
11760 if (PyErr_Occurred()) SWIG_fail;
11761 }
11762 resultobj = SWIG_Py_Void();
11763 return resultobj;
11764 fail:
11765 return NULL;
11766 }
11767
11768
11769 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11770 PyObject *resultobj = 0;
11771 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11772 bool result;
11773 void *argp1 = 0 ;
11774 int res1 = 0 ;
11775 PyObject *swig_obj[1] ;
11776
11777 if (!args) SWIG_fail;
11778 swig_obj[0] = args;
11779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11780 if (!SWIG_IsOK(res1)) {
11781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11782 }
11783 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11784 {
11785 PyThreadState* __tstate = wxPyBeginAllowThreads();
11786 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11787 wxPyEndAllowThreads(__tstate);
11788 if (PyErr_Occurred()) SWIG_fail;
11789 }
11790 {
11791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11792 }
11793 return resultobj;
11794 fail:
11795 return NULL;
11796 }
11797
11798
11799 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11800 PyObject *resultobj = 0;
11801 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11802 int result;
11803 void *argp1 = 0 ;
11804 int res1 = 0 ;
11805 PyObject *swig_obj[1] ;
11806
11807 if (!args) SWIG_fail;
11808 swig_obj[0] = args;
11809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11810 if (!SWIG_IsOK(res1)) {
11811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11812 }
11813 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11814 {
11815 PyThreadState* __tstate = wxPyBeginAllowThreads();
11816 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11817 wxPyEndAllowThreads(__tstate);
11818 if (PyErr_Occurred()) SWIG_fail;
11819 }
11820 resultobj = SWIG_From_int(static_cast< int >(result));
11821 return resultobj;
11822 fail:
11823 return NULL;
11824 }
11825
11826
11827 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11828 PyObject *resultobj = 0;
11829 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11830 int result;
11831 void *argp1 = 0 ;
11832 int res1 = 0 ;
11833 PyObject *swig_obj[1] ;
11834
11835 if (!args) SWIG_fail;
11836 swig_obj[0] = args;
11837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11838 if (!SWIG_IsOK(res1)) {
11839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11840 }
11841 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11842 {
11843 PyThreadState* __tstate = wxPyBeginAllowThreads();
11844 result = (int)((wxPyTimer const *)arg1)->GetId();
11845 wxPyEndAllowThreads(__tstate);
11846 if (PyErr_Occurred()) SWIG_fail;
11847 }
11848 resultobj = SWIG_From_int(static_cast< int >(result));
11849 return resultobj;
11850 fail:
11851 return NULL;
11852 }
11853
11854
11855 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11856 PyObject *resultobj = 0;
11857 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11858 bool result;
11859 void *argp1 = 0 ;
11860 int res1 = 0 ;
11861 PyObject *swig_obj[1] ;
11862
11863 if (!args) SWIG_fail;
11864 swig_obj[0] = args;
11865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11866 if (!SWIG_IsOK(res1)) {
11867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11868 }
11869 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11870 {
11871 PyThreadState* __tstate = wxPyBeginAllowThreads();
11872 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11873 wxPyEndAllowThreads(__tstate);
11874 if (PyErr_Occurred()) SWIG_fail;
11875 }
11876 {
11877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11878 }
11879 return resultobj;
11880 fail:
11881 return NULL;
11882 }
11883
11884
11885 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11886 PyObject *obj;
11887 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11888 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11889 return SWIG_Py_Void();
11890 }
11891
11892 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11893 return SWIG_Python_InitShadowInstance(args);
11894 }
11895
11896 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11897 PyObject *resultobj = 0;
11898 int arg1 = (int) 0 ;
11899 int arg2 = (int) 0 ;
11900 wxTimerEvent *result = 0 ;
11901 int val1 ;
11902 int ecode1 = 0 ;
11903 int val2 ;
11904 int ecode2 = 0 ;
11905 PyObject * obj0 = 0 ;
11906 PyObject * obj1 = 0 ;
11907 char * kwnames[] = {
11908 (char *) "timerid",(char *) "interval", NULL
11909 };
11910
11911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11912 if (obj0) {
11913 ecode1 = SWIG_AsVal_int(obj0, &val1);
11914 if (!SWIG_IsOK(ecode1)) {
11915 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11916 }
11917 arg1 = static_cast< int >(val1);
11918 }
11919 if (obj1) {
11920 ecode2 = SWIG_AsVal_int(obj1, &val2);
11921 if (!SWIG_IsOK(ecode2)) {
11922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11923 }
11924 arg2 = static_cast< int >(val2);
11925 }
11926 {
11927 PyThreadState* __tstate = wxPyBeginAllowThreads();
11928 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11929 wxPyEndAllowThreads(__tstate);
11930 if (PyErr_Occurred()) SWIG_fail;
11931 }
11932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11933 return resultobj;
11934 fail:
11935 return NULL;
11936 }
11937
11938
11939 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11940 PyObject *resultobj = 0;
11941 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11942 int result;
11943 void *argp1 = 0 ;
11944 int res1 = 0 ;
11945 PyObject *swig_obj[1] ;
11946
11947 if (!args) SWIG_fail;
11948 swig_obj[0] = args;
11949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11950 if (!SWIG_IsOK(res1)) {
11951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11952 }
11953 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11954 {
11955 PyThreadState* __tstate = wxPyBeginAllowThreads();
11956 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11957 wxPyEndAllowThreads(__tstate);
11958 if (PyErr_Occurred()) SWIG_fail;
11959 }
11960 resultobj = SWIG_From_int(static_cast< int >(result));
11961 return resultobj;
11962 fail:
11963 return NULL;
11964 }
11965
11966
11967 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11968 PyObject *obj;
11969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11970 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11971 return SWIG_Py_Void();
11972 }
11973
11974 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11975 return SWIG_Python_InitShadowInstance(args);
11976 }
11977
11978 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11979 PyObject *resultobj = 0;
11980 wxTimer *arg1 = 0 ;
11981 wxTimerRunner *result = 0 ;
11982 void *argp1 = 0 ;
11983 int res1 = 0 ;
11984
11985 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11987 if (!SWIG_IsOK(res1)) {
11988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11989 }
11990 if (!argp1) {
11991 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11992 }
11993 arg1 = reinterpret_cast< wxTimer * >(argp1);
11994 {
11995 if (!wxPyCheckForApp()) SWIG_fail;
11996 PyThreadState* __tstate = wxPyBeginAllowThreads();
11997 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11998 wxPyEndAllowThreads(__tstate);
11999 if (PyErr_Occurred()) SWIG_fail;
12000 }
12001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12002 return resultobj;
12003 fail:
12004 return NULL;
12005 }
12006
12007
12008 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12009 PyObject *resultobj = 0;
12010 wxTimer *arg1 = 0 ;
12011 int arg2 ;
12012 bool arg3 = (bool) false ;
12013 wxTimerRunner *result = 0 ;
12014 void *argp1 = 0 ;
12015 int res1 = 0 ;
12016 int val2 ;
12017 int ecode2 = 0 ;
12018 bool val3 ;
12019 int ecode3 = 0 ;
12020
12021 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12023 if (!SWIG_IsOK(res1)) {
12024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12025 }
12026 if (!argp1) {
12027 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12028 }
12029 arg1 = reinterpret_cast< wxTimer * >(argp1);
12030 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12031 if (!SWIG_IsOK(ecode2)) {
12032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12033 }
12034 arg2 = static_cast< int >(val2);
12035 if (swig_obj[2]) {
12036 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12037 if (!SWIG_IsOK(ecode3)) {
12038 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12039 }
12040 arg3 = static_cast< bool >(val3);
12041 }
12042 {
12043 if (!wxPyCheckForApp()) SWIG_fail;
12044 PyThreadState* __tstate = wxPyBeginAllowThreads();
12045 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12046 wxPyEndAllowThreads(__tstate);
12047 if (PyErr_Occurred()) SWIG_fail;
12048 }
12049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12050 return resultobj;
12051 fail:
12052 return NULL;
12053 }
12054
12055
12056 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12057 int argc;
12058 PyObject *argv[4];
12059
12060 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12061 --argc;
12062 if (argc == 1) {
12063 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12064 }
12065 if ((argc >= 2) && (argc <= 3)) {
12066 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12067 }
12068
12069 fail:
12070 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12071 return NULL;
12072 }
12073
12074
12075 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12076 PyObject *resultobj = 0;
12077 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12078 void *argp1 = 0 ;
12079 int res1 = 0 ;
12080 PyObject *swig_obj[1] ;
12081
12082 if (!args) SWIG_fail;
12083 swig_obj[0] = args;
12084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12085 if (!SWIG_IsOK(res1)) {
12086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12087 }
12088 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12089 {
12090 PyThreadState* __tstate = wxPyBeginAllowThreads();
12091 delete arg1;
12092
12093 wxPyEndAllowThreads(__tstate);
12094 if (PyErr_Occurred()) SWIG_fail;
12095 }
12096 resultobj = SWIG_Py_Void();
12097 return resultobj;
12098 fail:
12099 return NULL;
12100 }
12101
12102
12103 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12104 PyObject *resultobj = 0;
12105 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12106 int arg2 ;
12107 bool arg3 = (bool) false ;
12108 void *argp1 = 0 ;
12109 int res1 = 0 ;
12110 int val2 ;
12111 int ecode2 = 0 ;
12112 bool val3 ;
12113 int ecode3 = 0 ;
12114 PyObject * obj0 = 0 ;
12115 PyObject * obj1 = 0 ;
12116 PyObject * obj2 = 0 ;
12117 char * kwnames[] = {
12118 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12119 };
12120
12121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12123 if (!SWIG_IsOK(res1)) {
12124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12125 }
12126 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12127 ecode2 = SWIG_AsVal_int(obj1, &val2);
12128 if (!SWIG_IsOK(ecode2)) {
12129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12130 }
12131 arg2 = static_cast< int >(val2);
12132 if (obj2) {
12133 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12134 if (!SWIG_IsOK(ecode3)) {
12135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12136 }
12137 arg3 = static_cast< bool >(val3);
12138 }
12139 {
12140 PyThreadState* __tstate = wxPyBeginAllowThreads();
12141 (arg1)->Start(arg2,arg3);
12142 wxPyEndAllowThreads(__tstate);
12143 if (PyErr_Occurred()) SWIG_fail;
12144 }
12145 resultobj = SWIG_Py_Void();
12146 return resultobj;
12147 fail:
12148 return NULL;
12149 }
12150
12151
12152 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12153 PyObject *obj;
12154 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12155 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12156 return SWIG_Py_Void();
12157 }
12158
12159 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12160 return SWIG_Python_InitShadowInstance(args);
12161 }
12162
12163 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12164 PyObject *resultobj = 0;
12165 wxLog *result = 0 ;
12166
12167 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12168 {
12169 PyThreadState* __tstate = wxPyBeginAllowThreads();
12170 result = (wxLog *)new wxLog();
12171 wxPyEndAllowThreads(__tstate);
12172 if (PyErr_Occurred()) SWIG_fail;
12173 }
12174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12175 return resultobj;
12176 fail:
12177 return NULL;
12178 }
12179
12180
12181 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12182 PyObject *resultobj = 0;
12183 wxLog *arg1 = (wxLog *) 0 ;
12184 void *argp1 = 0 ;
12185 int res1 = 0 ;
12186 PyObject *swig_obj[1] ;
12187
12188 if (!args) SWIG_fail;
12189 swig_obj[0] = args;
12190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12191 if (!SWIG_IsOK(res1)) {
12192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12193 }
12194 arg1 = reinterpret_cast< wxLog * >(argp1);
12195 {
12196 PyThreadState* __tstate = wxPyBeginAllowThreads();
12197 delete arg1;
12198
12199 wxPyEndAllowThreads(__tstate);
12200 if (PyErr_Occurred()) SWIG_fail;
12201 }
12202 resultobj = SWIG_Py_Void();
12203 return resultobj;
12204 fail:
12205 return NULL;
12206 }
12207
12208
12209 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12210 PyObject *resultobj = 0;
12211 bool result;
12212
12213 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12214 {
12215 PyThreadState* __tstate = wxPyBeginAllowThreads();
12216 result = (bool)wxLog::IsEnabled();
12217 wxPyEndAllowThreads(__tstate);
12218 if (PyErr_Occurred()) SWIG_fail;
12219 }
12220 {
12221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12222 }
12223 return resultobj;
12224 fail:
12225 return NULL;
12226 }
12227
12228
12229 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12230 PyObject *resultobj = 0;
12231 bool arg1 = (bool) true ;
12232 bool result;
12233 bool val1 ;
12234 int ecode1 = 0 ;
12235 PyObject * obj0 = 0 ;
12236 char * kwnames[] = {
12237 (char *) "doIt", NULL
12238 };
12239
12240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12241 if (obj0) {
12242 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12243 if (!SWIG_IsOK(ecode1)) {
12244 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12245 }
12246 arg1 = static_cast< bool >(val1);
12247 }
12248 {
12249 PyThreadState* __tstate = wxPyBeginAllowThreads();
12250 result = (bool)wxLog::EnableLogging(arg1);
12251 wxPyEndAllowThreads(__tstate);
12252 if (PyErr_Occurred()) SWIG_fail;
12253 }
12254 {
12255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12256 }
12257 return resultobj;
12258 fail:
12259 return NULL;
12260 }
12261
12262
12263 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12264 PyObject *resultobj = 0;
12265 wxLogLevel arg1 ;
12266 wxChar *arg2 = (wxChar *) 0 ;
12267 time_t arg3 ;
12268 unsigned long val1 ;
12269 int ecode1 = 0 ;
12270 void *argp2 = 0 ;
12271 int res2 = 0 ;
12272 unsigned int val3 ;
12273 int ecode3 = 0 ;
12274 PyObject * obj0 = 0 ;
12275 PyObject * obj1 = 0 ;
12276 PyObject * obj2 = 0 ;
12277 char * kwnames[] = {
12278 (char *) "level",(char *) "szString",(char *) "t", NULL
12279 };
12280
12281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12282 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12283 if (!SWIG_IsOK(ecode1)) {
12284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12285 }
12286 arg1 = static_cast< wxLogLevel >(val1);
12287 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12288 if (!SWIG_IsOK(res2)) {
12289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12290 }
12291 arg2 = reinterpret_cast< wxChar * >(argp2);
12292 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12293 if (!SWIG_IsOK(ecode3)) {
12294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12295 }
12296 arg3 = static_cast< time_t >(val3);
12297 {
12298 PyThreadState* __tstate = wxPyBeginAllowThreads();
12299 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12300 wxPyEndAllowThreads(__tstate);
12301 if (PyErr_Occurred()) SWIG_fail;
12302 }
12303 resultobj = SWIG_Py_Void();
12304 return resultobj;
12305 fail:
12306 return NULL;
12307 }
12308
12309
12310 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12311 PyObject *resultobj = 0;
12312 wxLog *arg1 = (wxLog *) 0 ;
12313 void *argp1 = 0 ;
12314 int res1 = 0 ;
12315 PyObject *swig_obj[1] ;
12316
12317 if (!args) SWIG_fail;
12318 swig_obj[0] = args;
12319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12320 if (!SWIG_IsOK(res1)) {
12321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12322 }
12323 arg1 = reinterpret_cast< wxLog * >(argp1);
12324 {
12325 PyThreadState* __tstate = wxPyBeginAllowThreads();
12326 (arg1)->Flush();
12327 wxPyEndAllowThreads(__tstate);
12328 if (PyErr_Occurred()) SWIG_fail;
12329 }
12330 resultobj = SWIG_Py_Void();
12331 return resultobj;
12332 fail:
12333 return NULL;
12334 }
12335
12336
12337 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12338 PyObject *resultobj = 0;
12339
12340 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12341 {
12342 PyThreadState* __tstate = wxPyBeginAllowThreads();
12343 wxLog::FlushActive();
12344 wxPyEndAllowThreads(__tstate);
12345 if (PyErr_Occurred()) SWIG_fail;
12346 }
12347 resultobj = SWIG_Py_Void();
12348 return resultobj;
12349 fail:
12350 return NULL;
12351 }
12352
12353
12354 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12355 PyObject *resultobj = 0;
12356 wxLog *result = 0 ;
12357
12358 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12359 {
12360 PyThreadState* __tstate = wxPyBeginAllowThreads();
12361 result = (wxLog *)wxLog::GetActiveTarget();
12362 wxPyEndAllowThreads(__tstate);
12363 if (PyErr_Occurred()) SWIG_fail;
12364 }
12365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12366 return resultobj;
12367 fail:
12368 return NULL;
12369 }
12370
12371
12372 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12373 PyObject *resultobj = 0;
12374 wxLog *arg1 = (wxLog *) 0 ;
12375 wxLog *result = 0 ;
12376 int res1 = 0 ;
12377 PyObject * obj0 = 0 ;
12378 char * kwnames[] = {
12379 (char *) "pLogger", NULL
12380 };
12381
12382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12383 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12384 if (!SWIG_IsOK(res1)) {
12385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12386 }
12387 {
12388 PyThreadState* __tstate = wxPyBeginAllowThreads();
12389 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12390 wxPyEndAllowThreads(__tstate);
12391 if (PyErr_Occurred()) SWIG_fail;
12392 }
12393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12394 return resultobj;
12395 fail:
12396 return NULL;
12397 }
12398
12399
12400 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12401 PyObject *resultobj = 0;
12402
12403 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12404 {
12405 PyThreadState* __tstate = wxPyBeginAllowThreads();
12406 wxLog::Suspend();
12407 wxPyEndAllowThreads(__tstate);
12408 if (PyErr_Occurred()) SWIG_fail;
12409 }
12410 resultobj = SWIG_Py_Void();
12411 return resultobj;
12412 fail:
12413 return NULL;
12414 }
12415
12416
12417 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12418 PyObject *resultobj = 0;
12419
12420 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12421 {
12422 PyThreadState* __tstate = wxPyBeginAllowThreads();
12423 wxLog::Resume();
12424 wxPyEndAllowThreads(__tstate);
12425 if (PyErr_Occurred()) SWIG_fail;
12426 }
12427 resultobj = SWIG_Py_Void();
12428 return resultobj;
12429 fail:
12430 return NULL;
12431 }
12432
12433
12434 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12435 PyObject *resultobj = 0;
12436 bool arg1 = (bool) true ;
12437 bool val1 ;
12438 int ecode1 = 0 ;
12439 PyObject * obj0 = 0 ;
12440 char * kwnames[] = {
12441 (char *) "bVerbose", NULL
12442 };
12443
12444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12445 if (obj0) {
12446 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12447 if (!SWIG_IsOK(ecode1)) {
12448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12449 }
12450 arg1 = static_cast< bool >(val1);
12451 }
12452 {
12453 PyThreadState* __tstate = wxPyBeginAllowThreads();
12454 wxLog::SetVerbose(arg1);
12455 wxPyEndAllowThreads(__tstate);
12456 if (PyErr_Occurred()) SWIG_fail;
12457 }
12458 resultobj = SWIG_Py_Void();
12459 return resultobj;
12460 fail:
12461 return NULL;
12462 }
12463
12464
12465 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12466 PyObject *resultobj = 0;
12467 wxLogLevel arg1 ;
12468 unsigned long val1 ;
12469 int ecode1 = 0 ;
12470 PyObject * obj0 = 0 ;
12471 char * kwnames[] = {
12472 (char *) "logLevel", NULL
12473 };
12474
12475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12476 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12477 if (!SWIG_IsOK(ecode1)) {
12478 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12479 }
12480 arg1 = static_cast< wxLogLevel >(val1);
12481 {
12482 PyThreadState* __tstate = wxPyBeginAllowThreads();
12483 wxLog::SetLogLevel(arg1);
12484 wxPyEndAllowThreads(__tstate);
12485 if (PyErr_Occurred()) SWIG_fail;
12486 }
12487 resultobj = SWIG_Py_Void();
12488 return resultobj;
12489 fail:
12490 return NULL;
12491 }
12492
12493
12494 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12495 PyObject *resultobj = 0;
12496
12497 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12498 {
12499 PyThreadState* __tstate = wxPyBeginAllowThreads();
12500 wxLog::DontCreateOnDemand();
12501 wxPyEndAllowThreads(__tstate);
12502 if (PyErr_Occurred()) SWIG_fail;
12503 }
12504 resultobj = SWIG_Py_Void();
12505 return resultobj;
12506 fail:
12507 return NULL;
12508 }
12509
12510
12511 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12512 PyObject *resultobj = 0;
12513 bool arg1 = (bool) true ;
12514 bool val1 ;
12515 int ecode1 = 0 ;
12516 PyObject * obj0 = 0 ;
12517 char * kwnames[] = {
12518 (char *) "bRepetCounting", NULL
12519 };
12520
12521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12522 if (obj0) {
12523 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12524 if (!SWIG_IsOK(ecode1)) {
12525 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12526 }
12527 arg1 = static_cast< bool >(val1);
12528 }
12529 {
12530 PyThreadState* __tstate = wxPyBeginAllowThreads();
12531 wxLog::SetRepetitionCounting(arg1);
12532 wxPyEndAllowThreads(__tstate);
12533 if (PyErr_Occurred()) SWIG_fail;
12534 }
12535 resultobj = SWIG_Py_Void();
12536 return resultobj;
12537 fail:
12538 return NULL;
12539 }
12540
12541
12542 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12543 PyObject *resultobj = 0;
12544 bool result;
12545
12546 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12547 {
12548 PyThreadState* __tstate = wxPyBeginAllowThreads();
12549 result = (bool)wxLog::GetRepetitionCounting();
12550 wxPyEndAllowThreads(__tstate);
12551 if (PyErr_Occurred()) SWIG_fail;
12552 }
12553 {
12554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12555 }
12556 return resultobj;
12557 fail:
12558 return NULL;
12559 }
12560
12561
12562 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12563 PyObject *resultobj = 0;
12564 wxTraceMask arg1 ;
12565 unsigned long val1 ;
12566 int ecode1 = 0 ;
12567 PyObject * obj0 = 0 ;
12568 char * kwnames[] = {
12569 (char *) "ulMask", NULL
12570 };
12571
12572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12573 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12574 if (!SWIG_IsOK(ecode1)) {
12575 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12576 }
12577 arg1 = static_cast< wxTraceMask >(val1);
12578 {
12579 PyThreadState* __tstate = wxPyBeginAllowThreads();
12580 wxLog::SetTraceMask(arg1);
12581 wxPyEndAllowThreads(__tstate);
12582 if (PyErr_Occurred()) SWIG_fail;
12583 }
12584 resultobj = SWIG_Py_Void();
12585 return resultobj;
12586 fail:
12587 return NULL;
12588 }
12589
12590
12591 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12592 PyObject *resultobj = 0;
12593 wxString *arg1 = 0 ;
12594 bool temp1 = false ;
12595 PyObject * obj0 = 0 ;
12596 char * kwnames[] = {
12597 (char *) "str", NULL
12598 };
12599
12600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12601 {
12602 arg1 = wxString_in_helper(obj0);
12603 if (arg1 == NULL) SWIG_fail;
12604 temp1 = true;
12605 }
12606 {
12607 PyThreadState* __tstate = wxPyBeginAllowThreads();
12608 wxLog::AddTraceMask((wxString const &)*arg1);
12609 wxPyEndAllowThreads(__tstate);
12610 if (PyErr_Occurred()) SWIG_fail;
12611 }
12612 resultobj = SWIG_Py_Void();
12613 {
12614 if (temp1)
12615 delete arg1;
12616 }
12617 return resultobj;
12618 fail:
12619 {
12620 if (temp1)
12621 delete arg1;
12622 }
12623 return NULL;
12624 }
12625
12626
12627 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12628 PyObject *resultobj = 0;
12629 wxString *arg1 = 0 ;
12630 bool temp1 = false ;
12631 PyObject * obj0 = 0 ;
12632 char * kwnames[] = {
12633 (char *) "str", NULL
12634 };
12635
12636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12637 {
12638 arg1 = wxString_in_helper(obj0);
12639 if (arg1 == NULL) SWIG_fail;
12640 temp1 = true;
12641 }
12642 {
12643 PyThreadState* __tstate = wxPyBeginAllowThreads();
12644 wxLog::RemoveTraceMask((wxString const &)*arg1);
12645 wxPyEndAllowThreads(__tstate);
12646 if (PyErr_Occurred()) SWIG_fail;
12647 }
12648 resultobj = SWIG_Py_Void();
12649 {
12650 if (temp1)
12651 delete arg1;
12652 }
12653 return resultobj;
12654 fail:
12655 {
12656 if (temp1)
12657 delete arg1;
12658 }
12659 return NULL;
12660 }
12661
12662
12663 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12664 PyObject *resultobj = 0;
12665
12666 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12667 {
12668 PyThreadState* __tstate = wxPyBeginAllowThreads();
12669 wxLog::ClearTraceMasks();
12670 wxPyEndAllowThreads(__tstate);
12671 if (PyErr_Occurred()) SWIG_fail;
12672 }
12673 resultobj = SWIG_Py_Void();
12674 return resultobj;
12675 fail:
12676 return NULL;
12677 }
12678
12679
12680 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12681 PyObject *resultobj = 0;
12682 wxArrayString *result = 0 ;
12683
12684 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12685 {
12686 PyThreadState* __tstate = wxPyBeginAllowThreads();
12687 {
12688 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12689 result = (wxArrayString *) &_result_ref;
12690 }
12691 wxPyEndAllowThreads(__tstate);
12692 if (PyErr_Occurred()) SWIG_fail;
12693 }
12694 {
12695 resultobj = wxArrayString2PyList_helper(*result);
12696 }
12697 return resultobj;
12698 fail:
12699 return NULL;
12700 }
12701
12702
12703 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12704 PyObject *resultobj = 0;
12705 wxChar *arg1 = (wxChar *) 0 ;
12706 void *argp1 = 0 ;
12707 int res1 = 0 ;
12708 PyObject * obj0 = 0 ;
12709 char * kwnames[] = {
12710 (char *) "ts", NULL
12711 };
12712
12713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12715 if (!SWIG_IsOK(res1)) {
12716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12717 }
12718 arg1 = reinterpret_cast< wxChar * >(argp1);
12719 {
12720 PyThreadState* __tstate = wxPyBeginAllowThreads();
12721 wxLog::SetTimestamp((wxChar const *)arg1);
12722 wxPyEndAllowThreads(__tstate);
12723 if (PyErr_Occurred()) SWIG_fail;
12724 }
12725 resultobj = SWIG_Py_Void();
12726 return resultobj;
12727 fail:
12728 return NULL;
12729 }
12730
12731
12732 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12733 PyObject *resultobj = 0;
12734 bool result;
12735
12736 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12737 {
12738 PyThreadState* __tstate = wxPyBeginAllowThreads();
12739 result = (bool)wxLog::GetVerbose();
12740 wxPyEndAllowThreads(__tstate);
12741 if (PyErr_Occurred()) SWIG_fail;
12742 }
12743 {
12744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12745 }
12746 return resultobj;
12747 fail:
12748 return NULL;
12749 }
12750
12751
12752 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12753 PyObject *resultobj = 0;
12754 wxTraceMask result;
12755
12756 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12757 {
12758 PyThreadState* __tstate = wxPyBeginAllowThreads();
12759 result = (wxTraceMask)wxLog::GetTraceMask();
12760 wxPyEndAllowThreads(__tstate);
12761 if (PyErr_Occurred()) SWIG_fail;
12762 }
12763 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12764 return resultobj;
12765 fail:
12766 return NULL;
12767 }
12768
12769
12770 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12771 PyObject *resultobj = 0;
12772 wxChar *arg1 = (wxChar *) 0 ;
12773 bool result;
12774 void *argp1 = 0 ;
12775 int res1 = 0 ;
12776 PyObject * obj0 = 0 ;
12777 char * kwnames[] = {
12778 (char *) "mask", NULL
12779 };
12780
12781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12783 if (!SWIG_IsOK(res1)) {
12784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12785 }
12786 arg1 = reinterpret_cast< wxChar * >(argp1);
12787 {
12788 PyThreadState* __tstate = wxPyBeginAllowThreads();
12789 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12790 wxPyEndAllowThreads(__tstate);
12791 if (PyErr_Occurred()) SWIG_fail;
12792 }
12793 {
12794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12795 }
12796 return resultobj;
12797 fail:
12798 return NULL;
12799 }
12800
12801
12802 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12803 PyObject *resultobj = 0;
12804 wxLogLevel result;
12805
12806 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12807 {
12808 PyThreadState* __tstate = wxPyBeginAllowThreads();
12809 result = (wxLogLevel)wxLog::GetLogLevel();
12810 wxPyEndAllowThreads(__tstate);
12811 if (PyErr_Occurred()) SWIG_fail;
12812 }
12813 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12814 return resultobj;
12815 fail:
12816 return NULL;
12817 }
12818
12819
12820 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12821 PyObject *resultobj = 0;
12822 wxChar *result = 0 ;
12823
12824 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12825 {
12826 PyThreadState* __tstate = wxPyBeginAllowThreads();
12827 result = (wxChar *)wxLog::GetTimestamp();
12828 wxPyEndAllowThreads(__tstate);
12829 if (PyErr_Occurred()) SWIG_fail;
12830 }
12831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12832 return resultobj;
12833 fail:
12834 return NULL;
12835 }
12836
12837
12838 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12839 PyObject *resultobj = 0;
12840 wxString result;
12841
12842 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12843 {
12844 PyThreadState* __tstate = wxPyBeginAllowThreads();
12845 result = wxLog_TimeStamp();
12846 wxPyEndAllowThreads(__tstate);
12847 if (PyErr_Occurred()) SWIG_fail;
12848 }
12849 {
12850 #if wxUSE_UNICODE
12851 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12852 #else
12853 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12854 #endif
12855 }
12856 return resultobj;
12857 fail:
12858 return NULL;
12859 }
12860
12861
12862 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12863 PyObject *resultobj = 0;
12864 wxLog *arg1 = (wxLog *) 0 ;
12865 void *argp1 = 0 ;
12866 int res1 = 0 ;
12867 PyObject *swig_obj[1] ;
12868
12869 if (!args) SWIG_fail;
12870 swig_obj[0] = args;
12871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12872 if (!SWIG_IsOK(res1)) {
12873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12874 }
12875 arg1 = reinterpret_cast< wxLog * >(argp1);
12876 {
12877 PyThreadState* __tstate = wxPyBeginAllowThreads();
12878 wxLog_Destroy(arg1);
12879 wxPyEndAllowThreads(__tstate);
12880 if (PyErr_Occurred()) SWIG_fail;
12881 }
12882 resultobj = SWIG_Py_Void();
12883 return resultobj;
12884 fail:
12885 return NULL;
12886 }
12887
12888
12889 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12890 PyObject *obj;
12891 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12892 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12893 return SWIG_Py_Void();
12894 }
12895
12896 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12897 return SWIG_Python_InitShadowInstance(args);
12898 }
12899
12900 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12901 PyObject *resultobj = 0;
12902 wxLogStderr *result = 0 ;
12903
12904 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12905 {
12906 PyThreadState* __tstate = wxPyBeginAllowThreads();
12907 result = (wxLogStderr *)new wxLogStderr();
12908 wxPyEndAllowThreads(__tstate);
12909 if (PyErr_Occurred()) SWIG_fail;
12910 }
12911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12912 return resultobj;
12913 fail:
12914 return NULL;
12915 }
12916
12917
12918 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12919 PyObject *obj;
12920 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12921 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12922 return SWIG_Py_Void();
12923 }
12924
12925 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12926 return SWIG_Python_InitShadowInstance(args);
12927 }
12928
12929 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12930 PyObject *resultobj = 0;
12931 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12932 wxLogTextCtrl *result = 0 ;
12933 void *argp1 = 0 ;
12934 int res1 = 0 ;
12935 PyObject * obj0 = 0 ;
12936 char * kwnames[] = {
12937 (char *) "pTextCtrl", NULL
12938 };
12939
12940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12942 if (!SWIG_IsOK(res1)) {
12943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12944 }
12945 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12946 {
12947 PyThreadState* __tstate = wxPyBeginAllowThreads();
12948 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12949 wxPyEndAllowThreads(__tstate);
12950 if (PyErr_Occurred()) SWIG_fail;
12951 }
12952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12953 return resultobj;
12954 fail:
12955 return NULL;
12956 }
12957
12958
12959 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12960 PyObject *obj;
12961 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12962 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12963 return SWIG_Py_Void();
12964 }
12965
12966 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12967 return SWIG_Python_InitShadowInstance(args);
12968 }
12969
12970 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12971 PyObject *resultobj = 0;
12972 wxLogGui *result = 0 ;
12973
12974 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12975 {
12976 PyThreadState* __tstate = wxPyBeginAllowThreads();
12977 result = (wxLogGui *)new wxLogGui();
12978 wxPyEndAllowThreads(__tstate);
12979 if (PyErr_Occurred()) SWIG_fail;
12980 }
12981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12982 return resultobj;
12983 fail:
12984 return NULL;
12985 }
12986
12987
12988 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12989 PyObject *obj;
12990 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12991 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12992 return SWIG_Py_Void();
12993 }
12994
12995 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12996 return SWIG_Python_InitShadowInstance(args);
12997 }
12998
12999 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13000 PyObject *resultobj = 0;
13001 wxFrame *arg1 = (wxFrame *) 0 ;
13002 wxString *arg2 = 0 ;
13003 bool arg3 = (bool) true ;
13004 bool arg4 = (bool) true ;
13005 wxLogWindow *result = 0 ;
13006 void *argp1 = 0 ;
13007 int res1 = 0 ;
13008 bool temp2 = false ;
13009 bool val3 ;
13010 int ecode3 = 0 ;
13011 bool val4 ;
13012 int ecode4 = 0 ;
13013 PyObject * obj0 = 0 ;
13014 PyObject * obj1 = 0 ;
13015 PyObject * obj2 = 0 ;
13016 PyObject * obj3 = 0 ;
13017 char * kwnames[] = {
13018 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13019 };
13020
13021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13023 if (!SWIG_IsOK(res1)) {
13024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13025 }
13026 arg1 = reinterpret_cast< wxFrame * >(argp1);
13027 {
13028 arg2 = wxString_in_helper(obj1);
13029 if (arg2 == NULL) SWIG_fail;
13030 temp2 = true;
13031 }
13032 if (obj2) {
13033 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13034 if (!SWIG_IsOK(ecode3)) {
13035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13036 }
13037 arg3 = static_cast< bool >(val3);
13038 }
13039 if (obj3) {
13040 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13041 if (!SWIG_IsOK(ecode4)) {
13042 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13043 }
13044 arg4 = static_cast< bool >(val4);
13045 }
13046 {
13047 PyThreadState* __tstate = wxPyBeginAllowThreads();
13048 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13049 wxPyEndAllowThreads(__tstate);
13050 if (PyErr_Occurred()) SWIG_fail;
13051 }
13052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13053 {
13054 if (temp2)
13055 delete arg2;
13056 }
13057 return resultobj;
13058 fail:
13059 {
13060 if (temp2)
13061 delete arg2;
13062 }
13063 return NULL;
13064 }
13065
13066
13067 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13068 PyObject *resultobj = 0;
13069 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13070 bool arg2 = (bool) true ;
13071 void *argp1 = 0 ;
13072 int res1 = 0 ;
13073 bool val2 ;
13074 int ecode2 = 0 ;
13075 PyObject * obj0 = 0 ;
13076 PyObject * obj1 = 0 ;
13077 char * kwnames[] = {
13078 (char *) "self",(char *) "bShow", NULL
13079 };
13080
13081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13083 if (!SWIG_IsOK(res1)) {
13084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13085 }
13086 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13087 if (obj1) {
13088 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13089 if (!SWIG_IsOK(ecode2)) {
13090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13091 }
13092 arg2 = static_cast< bool >(val2);
13093 }
13094 {
13095 PyThreadState* __tstate = wxPyBeginAllowThreads();
13096 (arg1)->Show(arg2);
13097 wxPyEndAllowThreads(__tstate);
13098 if (PyErr_Occurred()) SWIG_fail;
13099 }
13100 resultobj = SWIG_Py_Void();
13101 return resultobj;
13102 fail:
13103 return NULL;
13104 }
13105
13106
13107 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13108 PyObject *resultobj = 0;
13109 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13110 wxFrame *result = 0 ;
13111 void *argp1 = 0 ;
13112 int res1 = 0 ;
13113 PyObject *swig_obj[1] ;
13114
13115 if (!args) SWIG_fail;
13116 swig_obj[0] = args;
13117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13118 if (!SWIG_IsOK(res1)) {
13119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13120 }
13121 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13122 {
13123 PyThreadState* __tstate = wxPyBeginAllowThreads();
13124 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13125 wxPyEndAllowThreads(__tstate);
13126 if (PyErr_Occurred()) SWIG_fail;
13127 }
13128 {
13129 resultobj = wxPyMake_wxObject(result, (bool)0);
13130 }
13131 return resultobj;
13132 fail:
13133 return NULL;
13134 }
13135
13136
13137 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13138 PyObject *resultobj = 0;
13139 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13140 wxLog *result = 0 ;
13141 void *argp1 = 0 ;
13142 int res1 = 0 ;
13143 PyObject *swig_obj[1] ;
13144
13145 if (!args) SWIG_fail;
13146 swig_obj[0] = args;
13147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13148 if (!SWIG_IsOK(res1)) {
13149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13150 }
13151 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13152 {
13153 PyThreadState* __tstate = wxPyBeginAllowThreads();
13154 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13155 wxPyEndAllowThreads(__tstate);
13156 if (PyErr_Occurred()) SWIG_fail;
13157 }
13158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13159 return resultobj;
13160 fail:
13161 return NULL;
13162 }
13163
13164
13165 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13166 PyObject *resultobj = 0;
13167 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13168 bool result;
13169 void *argp1 = 0 ;
13170 int res1 = 0 ;
13171 PyObject *swig_obj[1] ;
13172
13173 if (!args) SWIG_fail;
13174 swig_obj[0] = args;
13175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13176 if (!SWIG_IsOK(res1)) {
13177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13178 }
13179 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13180 {
13181 PyThreadState* __tstate = wxPyBeginAllowThreads();
13182 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13183 wxPyEndAllowThreads(__tstate);
13184 if (PyErr_Occurred()) SWIG_fail;
13185 }
13186 {
13187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13188 }
13189 return resultobj;
13190 fail:
13191 return NULL;
13192 }
13193
13194
13195 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13196 PyObject *resultobj = 0;
13197 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13198 bool arg2 ;
13199 void *argp1 = 0 ;
13200 int res1 = 0 ;
13201 bool val2 ;
13202 int ecode2 = 0 ;
13203 PyObject * obj0 = 0 ;
13204 PyObject * obj1 = 0 ;
13205 char * kwnames[] = {
13206 (char *) "self",(char *) "bDoPass", NULL
13207 };
13208
13209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13211 if (!SWIG_IsOK(res1)) {
13212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13213 }
13214 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13215 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13216 if (!SWIG_IsOK(ecode2)) {
13217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13218 }
13219 arg2 = static_cast< bool >(val2);
13220 {
13221 PyThreadState* __tstate = wxPyBeginAllowThreads();
13222 (arg1)->PassMessages(arg2);
13223 wxPyEndAllowThreads(__tstate);
13224 if (PyErr_Occurred()) SWIG_fail;
13225 }
13226 resultobj = SWIG_Py_Void();
13227 return resultobj;
13228 fail:
13229 return NULL;
13230 }
13231
13232
13233 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13234 PyObject *obj;
13235 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13236 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13237 return SWIG_Py_Void();
13238 }
13239
13240 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13241 return SWIG_Python_InitShadowInstance(args);
13242 }
13243
13244 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13245 PyObject *resultobj = 0;
13246 wxLog *arg1 = (wxLog *) 0 ;
13247 wxLogChain *result = 0 ;
13248 void *argp1 = 0 ;
13249 int res1 = 0 ;
13250 PyObject * obj0 = 0 ;
13251 char * kwnames[] = {
13252 (char *) "logger", NULL
13253 };
13254
13255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13257 if (!SWIG_IsOK(res1)) {
13258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13259 }
13260 arg1 = reinterpret_cast< wxLog * >(argp1);
13261 {
13262 PyThreadState* __tstate = wxPyBeginAllowThreads();
13263 result = (wxLogChain *)new wxLogChain(arg1);
13264 wxPyEndAllowThreads(__tstate);
13265 if (PyErr_Occurred()) SWIG_fail;
13266 }
13267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13268 return resultobj;
13269 fail:
13270 return NULL;
13271 }
13272
13273
13274 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13275 PyObject *resultobj = 0;
13276 wxLogChain *arg1 = (wxLogChain *) 0 ;
13277 wxLog *arg2 = (wxLog *) 0 ;
13278 void *argp1 = 0 ;
13279 int res1 = 0 ;
13280 void *argp2 = 0 ;
13281 int res2 = 0 ;
13282 PyObject * obj0 = 0 ;
13283 PyObject * obj1 = 0 ;
13284 char * kwnames[] = {
13285 (char *) "self",(char *) "logger", NULL
13286 };
13287
13288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13290 if (!SWIG_IsOK(res1)) {
13291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13292 }
13293 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13294 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13295 if (!SWIG_IsOK(res2)) {
13296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13297 }
13298 arg2 = reinterpret_cast< wxLog * >(argp2);
13299 {
13300 PyThreadState* __tstate = wxPyBeginAllowThreads();
13301 (arg1)->SetLog(arg2);
13302 wxPyEndAllowThreads(__tstate);
13303 if (PyErr_Occurred()) SWIG_fail;
13304 }
13305 resultobj = SWIG_Py_Void();
13306 return resultobj;
13307 fail:
13308 return NULL;
13309 }
13310
13311
13312 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13313 PyObject *resultobj = 0;
13314 wxLogChain *arg1 = (wxLogChain *) 0 ;
13315 bool arg2 ;
13316 void *argp1 = 0 ;
13317 int res1 = 0 ;
13318 bool val2 ;
13319 int ecode2 = 0 ;
13320 PyObject * obj0 = 0 ;
13321 PyObject * obj1 = 0 ;
13322 char * kwnames[] = {
13323 (char *) "self",(char *) "bDoPass", NULL
13324 };
13325
13326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13328 if (!SWIG_IsOK(res1)) {
13329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13330 }
13331 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13332 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13333 if (!SWIG_IsOK(ecode2)) {
13334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13335 }
13336 arg2 = static_cast< bool >(val2);
13337 {
13338 PyThreadState* __tstate = wxPyBeginAllowThreads();
13339 (arg1)->PassMessages(arg2);
13340 wxPyEndAllowThreads(__tstate);
13341 if (PyErr_Occurred()) SWIG_fail;
13342 }
13343 resultobj = SWIG_Py_Void();
13344 return resultobj;
13345 fail:
13346 return NULL;
13347 }
13348
13349
13350 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13351 PyObject *resultobj = 0;
13352 wxLogChain *arg1 = (wxLogChain *) 0 ;
13353 bool result;
13354 void *argp1 = 0 ;
13355 int res1 = 0 ;
13356 PyObject *swig_obj[1] ;
13357
13358 if (!args) SWIG_fail;
13359 swig_obj[0] = args;
13360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13361 if (!SWIG_IsOK(res1)) {
13362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13363 }
13364 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13365 {
13366 PyThreadState* __tstate = wxPyBeginAllowThreads();
13367 result = (bool)(arg1)->IsPassingMessages();
13368 wxPyEndAllowThreads(__tstate);
13369 if (PyErr_Occurred()) SWIG_fail;
13370 }
13371 {
13372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13373 }
13374 return resultobj;
13375 fail:
13376 return NULL;
13377 }
13378
13379
13380 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13381 PyObject *resultobj = 0;
13382 wxLogChain *arg1 = (wxLogChain *) 0 ;
13383 wxLog *result = 0 ;
13384 void *argp1 = 0 ;
13385 int res1 = 0 ;
13386 PyObject *swig_obj[1] ;
13387
13388 if (!args) SWIG_fail;
13389 swig_obj[0] = args;
13390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13391 if (!SWIG_IsOK(res1)) {
13392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13393 }
13394 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13395 {
13396 PyThreadState* __tstate = wxPyBeginAllowThreads();
13397 result = (wxLog *)(arg1)->GetOldLog();
13398 wxPyEndAllowThreads(__tstate);
13399 if (PyErr_Occurred()) SWIG_fail;
13400 }
13401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13402 return resultobj;
13403 fail:
13404 return NULL;
13405 }
13406
13407
13408 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13409 PyObject *obj;
13410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13411 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13412 return SWIG_Py_Void();
13413 }
13414
13415 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13416 return SWIG_Python_InitShadowInstance(args);
13417 }
13418
13419 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13420 PyObject *resultobj = 0;
13421 wxLogBuffer *result = 0 ;
13422
13423 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13424 {
13425 PyThreadState* __tstate = wxPyBeginAllowThreads();
13426 result = (wxLogBuffer *)new wxLogBuffer();
13427 wxPyEndAllowThreads(__tstate);
13428 if (PyErr_Occurred()) SWIG_fail;
13429 }
13430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13431 return resultobj;
13432 fail:
13433 return NULL;
13434 }
13435
13436
13437 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13438 PyObject *resultobj = 0;
13439 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13440 wxString *result = 0 ;
13441 void *argp1 = 0 ;
13442 int res1 = 0 ;
13443 PyObject *swig_obj[1] ;
13444
13445 if (!args) SWIG_fail;
13446 swig_obj[0] = args;
13447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13448 if (!SWIG_IsOK(res1)) {
13449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13450 }
13451 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13452 {
13453 PyThreadState* __tstate = wxPyBeginAllowThreads();
13454 {
13455 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13456 result = (wxString *) &_result_ref;
13457 }
13458 wxPyEndAllowThreads(__tstate);
13459 if (PyErr_Occurred()) SWIG_fail;
13460 }
13461 {
13462 #if wxUSE_UNICODE
13463 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13464 #else
13465 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13466 #endif
13467 }
13468 return resultobj;
13469 fail:
13470 return NULL;
13471 }
13472
13473
13474 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13475 PyObject *obj;
13476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13477 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13478 return SWIG_Py_Void();
13479 }
13480
13481 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13482 return SWIG_Python_InitShadowInstance(args);
13483 }
13484
13485 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13486 PyObject *resultobj = 0;
13487 unsigned long result;
13488
13489 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13490 {
13491 PyThreadState* __tstate = wxPyBeginAllowThreads();
13492 result = (unsigned long)wxSysErrorCode();
13493 wxPyEndAllowThreads(__tstate);
13494 if (PyErr_Occurred()) SWIG_fail;
13495 }
13496 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13497 return resultobj;
13498 fail:
13499 return NULL;
13500 }
13501
13502
13503 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13504 PyObject *resultobj = 0;
13505 unsigned long arg1 = (unsigned long) 0 ;
13506 wxString result;
13507 unsigned long val1 ;
13508 int ecode1 = 0 ;
13509 PyObject * obj0 = 0 ;
13510 char * kwnames[] = {
13511 (char *) "nErrCode", NULL
13512 };
13513
13514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13515 if (obj0) {
13516 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13517 if (!SWIG_IsOK(ecode1)) {
13518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13519 }
13520 arg1 = static_cast< unsigned long >(val1);
13521 }
13522 {
13523 PyThreadState* __tstate = wxPyBeginAllowThreads();
13524 result = wxSysErrorMsg(arg1);
13525 wxPyEndAllowThreads(__tstate);
13526 if (PyErr_Occurred()) SWIG_fail;
13527 }
13528 {
13529 #if wxUSE_UNICODE
13530 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13531 #else
13532 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13533 #endif
13534 }
13535 return resultobj;
13536 fail:
13537 return NULL;
13538 }
13539
13540
13541 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13542 PyObject *resultobj = 0;
13543 wxString *arg1 = 0 ;
13544 bool temp1 = false ;
13545 PyObject * obj0 = 0 ;
13546 char * kwnames[] = {
13547 (char *) "msg", NULL
13548 };
13549
13550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13551 {
13552 arg1 = wxString_in_helper(obj0);
13553 if (arg1 == NULL) SWIG_fail;
13554 temp1 = true;
13555 }
13556 {
13557 PyThreadState* __tstate = wxPyBeginAllowThreads();
13558 wxPyLogFatalError((wxString const &)*arg1);
13559 wxPyEndAllowThreads(__tstate);
13560 if (PyErr_Occurred()) SWIG_fail;
13561 }
13562 resultobj = SWIG_Py_Void();
13563 {
13564 if (temp1)
13565 delete arg1;
13566 }
13567 return resultobj;
13568 fail:
13569 {
13570 if (temp1)
13571 delete arg1;
13572 }
13573 return NULL;
13574 }
13575
13576
13577 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13578 PyObject *resultobj = 0;
13579 wxString *arg1 = 0 ;
13580 bool temp1 = false ;
13581 PyObject * obj0 = 0 ;
13582 char * kwnames[] = {
13583 (char *) "msg", NULL
13584 };
13585
13586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13587 {
13588 arg1 = wxString_in_helper(obj0);
13589 if (arg1 == NULL) SWIG_fail;
13590 temp1 = true;
13591 }
13592 {
13593 PyThreadState* __tstate = wxPyBeginAllowThreads();
13594 wxPyLogError((wxString const &)*arg1);
13595 wxPyEndAllowThreads(__tstate);
13596 if (PyErr_Occurred()) SWIG_fail;
13597 }
13598 resultobj = SWIG_Py_Void();
13599 {
13600 if (temp1)
13601 delete arg1;
13602 }
13603 return resultobj;
13604 fail:
13605 {
13606 if (temp1)
13607 delete arg1;
13608 }
13609 return NULL;
13610 }
13611
13612
13613 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13614 PyObject *resultobj = 0;
13615 wxString *arg1 = 0 ;
13616 bool temp1 = false ;
13617 PyObject * obj0 = 0 ;
13618 char * kwnames[] = {
13619 (char *) "msg", NULL
13620 };
13621
13622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13623 {
13624 arg1 = wxString_in_helper(obj0);
13625 if (arg1 == NULL) SWIG_fail;
13626 temp1 = true;
13627 }
13628 {
13629 PyThreadState* __tstate = wxPyBeginAllowThreads();
13630 wxPyLogWarning((wxString const &)*arg1);
13631 wxPyEndAllowThreads(__tstate);
13632 if (PyErr_Occurred()) SWIG_fail;
13633 }
13634 resultobj = SWIG_Py_Void();
13635 {
13636 if (temp1)
13637 delete arg1;
13638 }
13639 return resultobj;
13640 fail:
13641 {
13642 if (temp1)
13643 delete arg1;
13644 }
13645 return NULL;
13646 }
13647
13648
13649 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13650 PyObject *resultobj = 0;
13651 wxString *arg1 = 0 ;
13652 bool temp1 = false ;
13653 PyObject * obj0 = 0 ;
13654 char * kwnames[] = {
13655 (char *) "msg", NULL
13656 };
13657
13658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13659 {
13660 arg1 = wxString_in_helper(obj0);
13661 if (arg1 == NULL) SWIG_fail;
13662 temp1 = true;
13663 }
13664 {
13665 PyThreadState* __tstate = wxPyBeginAllowThreads();
13666 wxPyLogMessage((wxString const &)*arg1);
13667 wxPyEndAllowThreads(__tstate);
13668 if (PyErr_Occurred()) SWIG_fail;
13669 }
13670 resultobj = SWIG_Py_Void();
13671 {
13672 if (temp1)
13673 delete arg1;
13674 }
13675 return resultobj;
13676 fail:
13677 {
13678 if (temp1)
13679 delete arg1;
13680 }
13681 return NULL;
13682 }
13683
13684
13685 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13686 PyObject *resultobj = 0;
13687 wxString *arg1 = 0 ;
13688 bool temp1 = false ;
13689 PyObject * obj0 = 0 ;
13690 char * kwnames[] = {
13691 (char *) "msg", NULL
13692 };
13693
13694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13695 {
13696 arg1 = wxString_in_helper(obj0);
13697 if (arg1 == NULL) SWIG_fail;
13698 temp1 = true;
13699 }
13700 {
13701 PyThreadState* __tstate = wxPyBeginAllowThreads();
13702 wxPyLogInfo((wxString const &)*arg1);
13703 wxPyEndAllowThreads(__tstate);
13704 if (PyErr_Occurred()) SWIG_fail;
13705 }
13706 resultobj = SWIG_Py_Void();
13707 {
13708 if (temp1)
13709 delete arg1;
13710 }
13711 return resultobj;
13712 fail:
13713 {
13714 if (temp1)
13715 delete arg1;
13716 }
13717 return NULL;
13718 }
13719
13720
13721 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13722 PyObject *resultobj = 0;
13723 wxString *arg1 = 0 ;
13724 bool temp1 = false ;
13725 PyObject * obj0 = 0 ;
13726 char * kwnames[] = {
13727 (char *) "msg", NULL
13728 };
13729
13730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13731 {
13732 arg1 = wxString_in_helper(obj0);
13733 if (arg1 == NULL) SWIG_fail;
13734 temp1 = true;
13735 }
13736 {
13737 PyThreadState* __tstate = wxPyBeginAllowThreads();
13738 wxPyLogDebug((wxString const &)*arg1);
13739 wxPyEndAllowThreads(__tstate);
13740 if (PyErr_Occurred()) SWIG_fail;
13741 }
13742 resultobj = SWIG_Py_Void();
13743 {
13744 if (temp1)
13745 delete arg1;
13746 }
13747 return resultobj;
13748 fail:
13749 {
13750 if (temp1)
13751 delete arg1;
13752 }
13753 return NULL;
13754 }
13755
13756
13757 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13758 PyObject *resultobj = 0;
13759 wxString *arg1 = 0 ;
13760 bool temp1 = false ;
13761 PyObject * obj0 = 0 ;
13762 char * kwnames[] = {
13763 (char *) "msg", NULL
13764 };
13765
13766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13767 {
13768 arg1 = wxString_in_helper(obj0);
13769 if (arg1 == NULL) SWIG_fail;
13770 temp1 = true;
13771 }
13772 {
13773 PyThreadState* __tstate = wxPyBeginAllowThreads();
13774 wxPyLogVerbose((wxString const &)*arg1);
13775 wxPyEndAllowThreads(__tstate);
13776 if (PyErr_Occurred()) SWIG_fail;
13777 }
13778 resultobj = SWIG_Py_Void();
13779 {
13780 if (temp1)
13781 delete arg1;
13782 }
13783 return resultobj;
13784 fail:
13785 {
13786 if (temp1)
13787 delete arg1;
13788 }
13789 return NULL;
13790 }
13791
13792
13793 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13794 PyObject *resultobj = 0;
13795 wxString *arg1 = 0 ;
13796 bool temp1 = false ;
13797 PyObject * obj0 = 0 ;
13798 char * kwnames[] = {
13799 (char *) "msg", NULL
13800 };
13801
13802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13803 {
13804 arg1 = wxString_in_helper(obj0);
13805 if (arg1 == NULL) SWIG_fail;
13806 temp1 = true;
13807 }
13808 {
13809 PyThreadState* __tstate = wxPyBeginAllowThreads();
13810 wxPyLogStatus((wxString const &)*arg1);
13811 wxPyEndAllowThreads(__tstate);
13812 if (PyErr_Occurred()) SWIG_fail;
13813 }
13814 resultobj = SWIG_Py_Void();
13815 {
13816 if (temp1)
13817 delete arg1;
13818 }
13819 return resultobj;
13820 fail:
13821 {
13822 if (temp1)
13823 delete arg1;
13824 }
13825 return NULL;
13826 }
13827
13828
13829 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13830 PyObject *resultobj = 0;
13831 wxFrame *arg1 = (wxFrame *) 0 ;
13832 wxString *arg2 = 0 ;
13833 void *argp1 = 0 ;
13834 int res1 = 0 ;
13835 bool temp2 = false ;
13836 PyObject * obj0 = 0 ;
13837 PyObject * obj1 = 0 ;
13838 char * kwnames[] = {
13839 (char *) "pFrame",(char *) "msg", NULL
13840 };
13841
13842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13844 if (!SWIG_IsOK(res1)) {
13845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13846 }
13847 arg1 = reinterpret_cast< wxFrame * >(argp1);
13848 {
13849 arg2 = wxString_in_helper(obj1);
13850 if (arg2 == NULL) SWIG_fail;
13851 temp2 = true;
13852 }
13853 {
13854 PyThreadState* __tstate = wxPyBeginAllowThreads();
13855 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13856 wxPyEndAllowThreads(__tstate);
13857 if (PyErr_Occurred()) SWIG_fail;
13858 }
13859 resultobj = SWIG_Py_Void();
13860 {
13861 if (temp2)
13862 delete arg2;
13863 }
13864 return resultobj;
13865 fail:
13866 {
13867 if (temp2)
13868 delete arg2;
13869 }
13870 return NULL;
13871 }
13872
13873
13874 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13875 PyObject *resultobj = 0;
13876 wxString *arg1 = 0 ;
13877 bool temp1 = false ;
13878 PyObject * obj0 = 0 ;
13879 char * kwnames[] = {
13880 (char *) "msg", NULL
13881 };
13882
13883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13884 {
13885 arg1 = wxString_in_helper(obj0);
13886 if (arg1 == NULL) SWIG_fail;
13887 temp1 = true;
13888 }
13889 {
13890 PyThreadState* __tstate = wxPyBeginAllowThreads();
13891 wxPyLogSysError((wxString const &)*arg1);
13892 wxPyEndAllowThreads(__tstate);
13893 if (PyErr_Occurred()) SWIG_fail;
13894 }
13895 resultobj = SWIG_Py_Void();
13896 {
13897 if (temp1)
13898 delete arg1;
13899 }
13900 return resultobj;
13901 fail:
13902 {
13903 if (temp1)
13904 delete arg1;
13905 }
13906 return NULL;
13907 }
13908
13909
13910 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13911 PyObject *resultobj = 0;
13912 unsigned long arg1 ;
13913 wxString *arg2 = 0 ;
13914 unsigned long val1 ;
13915 int ecode1 = 0 ;
13916 bool temp2 = false ;
13917 PyObject * obj0 = 0 ;
13918 PyObject * obj1 = 0 ;
13919 char * kwnames[] = {
13920 (char *) "level",(char *) "msg", NULL
13921 };
13922
13923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13924 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13925 if (!SWIG_IsOK(ecode1)) {
13926 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13927 }
13928 arg1 = static_cast< unsigned long >(val1);
13929 {
13930 arg2 = wxString_in_helper(obj1);
13931 if (arg2 == NULL) SWIG_fail;
13932 temp2 = true;
13933 }
13934 {
13935 PyThreadState* __tstate = wxPyBeginAllowThreads();
13936 wxPyLogGeneric(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_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13956 PyObject *resultobj = 0;
13957 unsigned long arg1 ;
13958 wxString *arg2 = 0 ;
13959 unsigned long val1 ;
13960 int ecode1 = 0 ;
13961 bool temp2 = false ;
13962
13963 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13964 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13965 if (!SWIG_IsOK(ecode1)) {
13966 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13967 }
13968 arg1 = static_cast< unsigned long >(val1);
13969 {
13970 arg2 = wxString_in_helper(swig_obj[1]);
13971 if (arg2 == NULL) SWIG_fail;
13972 temp2 = true;
13973 }
13974 {
13975 PyThreadState* __tstate = wxPyBeginAllowThreads();
13976 wxPyLogTrace(arg1,(wxString const &)*arg2);
13977 wxPyEndAllowThreads(__tstate);
13978 if (PyErr_Occurred()) SWIG_fail;
13979 }
13980 resultobj = SWIG_Py_Void();
13981 {
13982 if (temp2)
13983 delete arg2;
13984 }
13985 return resultobj;
13986 fail:
13987 {
13988 if (temp2)
13989 delete arg2;
13990 }
13991 return NULL;
13992 }
13993
13994
13995 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13996 PyObject *resultobj = 0;
13997 wxString *arg1 = 0 ;
13998 wxString *arg2 = 0 ;
13999 bool temp1 = false ;
14000 bool temp2 = false ;
14001
14002 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14003 {
14004 arg1 = wxString_in_helper(swig_obj[0]);
14005 if (arg1 == NULL) SWIG_fail;
14006 temp1 = true;
14007 }
14008 {
14009 arg2 = wxString_in_helper(swig_obj[1]);
14010 if (arg2 == NULL) SWIG_fail;
14011 temp2 = true;
14012 }
14013 {
14014 PyThreadState* __tstate = wxPyBeginAllowThreads();
14015 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14016 wxPyEndAllowThreads(__tstate);
14017 if (PyErr_Occurred()) SWIG_fail;
14018 }
14019 resultobj = SWIG_Py_Void();
14020 {
14021 if (temp1)
14022 delete arg1;
14023 }
14024 {
14025 if (temp2)
14026 delete arg2;
14027 }
14028 return resultobj;
14029 fail:
14030 {
14031 if (temp1)
14032 delete arg1;
14033 }
14034 {
14035 if (temp2)
14036 delete arg2;
14037 }
14038 return NULL;
14039 }
14040
14041
14042 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14043 int argc;
14044 PyObject *argv[3];
14045
14046 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14047 --argc;
14048 if (argc == 2) {
14049 int _v = 0;
14050 {
14051 {
14052 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14053 }
14054 }
14055 if (!_v) goto check_1;
14056 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14057 }
14058 check_1:
14059
14060 if (argc == 2) {
14061 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14062 }
14063
14064 fail:
14065 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14066 return NULL;
14067 }
14068
14069
14070 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14071 PyObject *resultobj = 0;
14072 wxString *arg1 = 0 ;
14073 wxString *arg2 = 0 ;
14074 bool temp1 = false ;
14075 bool temp2 = false ;
14076 PyObject * obj0 = 0 ;
14077 PyObject * obj1 = 0 ;
14078 char * kwnames[] = {
14079 (char *) "title",(char *) "text", NULL
14080 };
14081
14082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14083 {
14084 arg1 = wxString_in_helper(obj0);
14085 if (arg1 == NULL) SWIG_fail;
14086 temp1 = true;
14087 }
14088 {
14089 arg2 = wxString_in_helper(obj1);
14090 if (arg2 == NULL) SWIG_fail;
14091 temp2 = true;
14092 }
14093 {
14094 PyThreadState* __tstate = wxPyBeginAllowThreads();
14095 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14096 wxPyEndAllowThreads(__tstate);
14097 if (PyErr_Occurred()) SWIG_fail;
14098 }
14099 resultobj = SWIG_Py_Void();
14100 {
14101 if (temp1)
14102 delete arg1;
14103 }
14104 {
14105 if (temp2)
14106 delete arg2;
14107 }
14108 return resultobj;
14109 fail:
14110 {
14111 if (temp1)
14112 delete arg1;
14113 }
14114 {
14115 if (temp2)
14116 delete arg2;
14117 }
14118 return NULL;
14119 }
14120
14121
14122 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14123 PyObject *resultobj = 0;
14124 wxLogNull *result = 0 ;
14125
14126 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14127 {
14128 PyThreadState* __tstate = wxPyBeginAllowThreads();
14129 result = (wxLogNull *)new wxLogNull();
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14134 return resultobj;
14135 fail:
14136 return NULL;
14137 }
14138
14139
14140 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14141 PyObject *resultobj = 0;
14142 wxLogNull *arg1 = (wxLogNull *) 0 ;
14143 void *argp1 = 0 ;
14144 int res1 = 0 ;
14145 PyObject *swig_obj[1] ;
14146
14147 if (!args) SWIG_fail;
14148 swig_obj[0] = args;
14149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14150 if (!SWIG_IsOK(res1)) {
14151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14152 }
14153 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14154 {
14155 PyThreadState* __tstate = wxPyBeginAllowThreads();
14156 delete arg1;
14157
14158 wxPyEndAllowThreads(__tstate);
14159 if (PyErr_Occurred()) SWIG_fail;
14160 }
14161 resultobj = SWIG_Py_Void();
14162 return resultobj;
14163 fail:
14164 return NULL;
14165 }
14166
14167
14168 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14169 PyObject *obj;
14170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14171 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14172 return SWIG_Py_Void();
14173 }
14174
14175 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14176 return SWIG_Python_InitShadowInstance(args);
14177 }
14178
14179 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14180 PyObject *resultobj = 0;
14181 wxPyLog *result = 0 ;
14182
14183 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14184 {
14185 PyThreadState* __tstate = wxPyBeginAllowThreads();
14186 result = (wxPyLog *)new wxPyLog();
14187 wxPyEndAllowThreads(__tstate);
14188 if (PyErr_Occurred()) SWIG_fail;
14189 }
14190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14191 return resultobj;
14192 fail:
14193 return NULL;
14194 }
14195
14196
14197 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14198 PyObject *resultobj = 0;
14199 wxPyLog *arg1 = (wxPyLog *) 0 ;
14200 PyObject *arg2 = (PyObject *) 0 ;
14201 PyObject *arg3 = (PyObject *) 0 ;
14202 void *argp1 = 0 ;
14203 int res1 = 0 ;
14204 PyObject * obj0 = 0 ;
14205 PyObject * obj1 = 0 ;
14206 PyObject * obj2 = 0 ;
14207 char * kwnames[] = {
14208 (char *) "self",(char *) "self",(char *) "_class", NULL
14209 };
14210
14211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14213 if (!SWIG_IsOK(res1)) {
14214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14215 }
14216 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14217 arg2 = obj1;
14218 arg3 = obj2;
14219 {
14220 PyThreadState* __tstate = wxPyBeginAllowThreads();
14221 (arg1)->_setCallbackInfo(arg2,arg3);
14222 wxPyEndAllowThreads(__tstate);
14223 if (PyErr_Occurred()) SWIG_fail;
14224 }
14225 resultobj = SWIG_Py_Void();
14226 return resultobj;
14227 fail:
14228 return NULL;
14229 }
14230
14231
14232 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14233 PyObject *obj;
14234 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14235 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14236 return SWIG_Py_Void();
14237 }
14238
14239 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14240 return SWIG_Python_InitShadowInstance(args);
14241 }
14242
14243 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14244 PyObject *resultobj = 0;
14245 int arg1 ;
14246 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14247 int arg3 = (int) wxKILL_NOCHILDREN ;
14248 wxKillError result;
14249 int val1 ;
14250 int ecode1 = 0 ;
14251 int val2 ;
14252 int ecode2 = 0 ;
14253 int val3 ;
14254 int ecode3 = 0 ;
14255 PyObject * obj0 = 0 ;
14256 PyObject * obj1 = 0 ;
14257 PyObject * obj2 = 0 ;
14258 char * kwnames[] = {
14259 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14260 };
14261
14262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14263 ecode1 = SWIG_AsVal_int(obj0, &val1);
14264 if (!SWIG_IsOK(ecode1)) {
14265 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14266 }
14267 arg1 = static_cast< int >(val1);
14268 if (obj1) {
14269 ecode2 = SWIG_AsVal_int(obj1, &val2);
14270 if (!SWIG_IsOK(ecode2)) {
14271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14272 }
14273 arg2 = static_cast< wxSignal >(val2);
14274 }
14275 if (obj2) {
14276 ecode3 = SWIG_AsVal_int(obj2, &val3);
14277 if (!SWIG_IsOK(ecode3)) {
14278 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14279 }
14280 arg3 = static_cast< int >(val3);
14281 }
14282 {
14283 PyThreadState* __tstate = wxPyBeginAllowThreads();
14284 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14285 wxPyEndAllowThreads(__tstate);
14286 if (PyErr_Occurred()) SWIG_fail;
14287 }
14288 resultobj = SWIG_From_int(static_cast< int >(result));
14289 return resultobj;
14290 fail:
14291 return NULL;
14292 }
14293
14294
14295 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14296 PyObject *resultobj = 0;
14297 int arg1 ;
14298 bool result;
14299 int val1 ;
14300 int ecode1 = 0 ;
14301 PyObject * obj0 = 0 ;
14302 char * kwnames[] = {
14303 (char *) "pid", NULL
14304 };
14305
14306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14307 ecode1 = SWIG_AsVal_int(obj0, &val1);
14308 if (!SWIG_IsOK(ecode1)) {
14309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14310 }
14311 arg1 = static_cast< int >(val1);
14312 {
14313 PyThreadState* __tstate = wxPyBeginAllowThreads();
14314 result = (bool)wxPyProcess::Exists(arg1);
14315 wxPyEndAllowThreads(__tstate);
14316 if (PyErr_Occurred()) SWIG_fail;
14317 }
14318 {
14319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14320 }
14321 return resultobj;
14322 fail:
14323 return NULL;
14324 }
14325
14326
14327 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14328 PyObject *resultobj = 0;
14329 wxString *arg1 = 0 ;
14330 int arg2 = (int) wxEXEC_ASYNC ;
14331 wxPyProcess *result = 0 ;
14332 bool temp1 = false ;
14333 int val2 ;
14334 int ecode2 = 0 ;
14335 PyObject * obj0 = 0 ;
14336 PyObject * obj1 = 0 ;
14337 char * kwnames[] = {
14338 (char *) "cmd",(char *) "flags", NULL
14339 };
14340
14341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14342 {
14343 arg1 = wxString_in_helper(obj0);
14344 if (arg1 == NULL) SWIG_fail;
14345 temp1 = true;
14346 }
14347 if (obj1) {
14348 ecode2 = SWIG_AsVal_int(obj1, &val2);
14349 if (!SWIG_IsOK(ecode2)) {
14350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14351 }
14352 arg2 = static_cast< int >(val2);
14353 }
14354 {
14355 PyThreadState* __tstate = wxPyBeginAllowThreads();
14356 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14357 wxPyEndAllowThreads(__tstate);
14358 if (PyErr_Occurred()) SWIG_fail;
14359 }
14360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14361 {
14362 if (temp1)
14363 delete arg1;
14364 }
14365 return resultobj;
14366 fail:
14367 {
14368 if (temp1)
14369 delete arg1;
14370 }
14371 return NULL;
14372 }
14373
14374
14375 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14376 PyObject *resultobj = 0;
14377 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14378 int arg2 = (int) -1 ;
14379 wxPyProcess *result = 0 ;
14380 void *argp1 = 0 ;
14381 int res1 = 0 ;
14382 int val2 ;
14383 int ecode2 = 0 ;
14384 PyObject * obj0 = 0 ;
14385 PyObject * obj1 = 0 ;
14386 char * kwnames[] = {
14387 (char *) "parent",(char *) "id", NULL
14388 };
14389
14390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14391 if (obj0) {
14392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14393 if (!SWIG_IsOK(res1)) {
14394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14395 }
14396 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14397 }
14398 if (obj1) {
14399 ecode2 = SWIG_AsVal_int(obj1, &val2);
14400 if (!SWIG_IsOK(ecode2)) {
14401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14402 }
14403 arg2 = static_cast< int >(val2);
14404 }
14405 {
14406 PyThreadState* __tstate = wxPyBeginAllowThreads();
14407 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14408 wxPyEndAllowThreads(__tstate);
14409 if (PyErr_Occurred()) SWIG_fail;
14410 }
14411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14412 return resultobj;
14413 fail:
14414 return NULL;
14415 }
14416
14417
14418 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14419 PyObject *resultobj = 0;
14420 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14421 void *argp1 = 0 ;
14422 int res1 = 0 ;
14423 PyObject *swig_obj[1] ;
14424
14425 if (!args) SWIG_fail;
14426 swig_obj[0] = args;
14427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14428 if (!SWIG_IsOK(res1)) {
14429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14430 }
14431 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14432 {
14433 PyThreadState* __tstate = wxPyBeginAllowThreads();
14434 delete arg1;
14435
14436 wxPyEndAllowThreads(__tstate);
14437 if (PyErr_Occurred()) SWIG_fail;
14438 }
14439 resultobj = SWIG_Py_Void();
14440 return resultobj;
14441 fail:
14442 return NULL;
14443 }
14444
14445
14446 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14447 PyObject *resultobj = 0;
14448 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14449 PyObject *arg2 = (PyObject *) 0 ;
14450 PyObject *arg3 = (PyObject *) 0 ;
14451 void *argp1 = 0 ;
14452 int res1 = 0 ;
14453 PyObject * obj0 = 0 ;
14454 PyObject * obj1 = 0 ;
14455 PyObject * obj2 = 0 ;
14456 char * kwnames[] = {
14457 (char *) "self",(char *) "self",(char *) "_class", NULL
14458 };
14459
14460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14462 if (!SWIG_IsOK(res1)) {
14463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14464 }
14465 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14466 arg2 = obj1;
14467 arg3 = obj2;
14468 {
14469 PyThreadState* __tstate = wxPyBeginAllowThreads();
14470 (arg1)->_setCallbackInfo(arg2,arg3);
14471 wxPyEndAllowThreads(__tstate);
14472 if (PyErr_Occurred()) SWIG_fail;
14473 }
14474 resultobj = SWIG_Py_Void();
14475 return resultobj;
14476 fail:
14477 return NULL;
14478 }
14479
14480
14481 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14482 PyObject *resultobj = 0;
14483 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14484 long result;
14485 void *argp1 = 0 ;
14486 int res1 = 0 ;
14487 PyObject *swig_obj[1] ;
14488
14489 if (!args) SWIG_fail;
14490 swig_obj[0] = args;
14491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14492 if (!SWIG_IsOK(res1)) {
14493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14494 }
14495 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14496 {
14497 PyThreadState* __tstate = wxPyBeginAllowThreads();
14498 result = (long)((wxPyProcess const *)arg1)->GetPid();
14499 wxPyEndAllowThreads(__tstate);
14500 if (PyErr_Occurred()) SWIG_fail;
14501 }
14502 resultobj = SWIG_From_long(static_cast< long >(result));
14503 return resultobj;
14504 fail:
14505 return NULL;
14506 }
14507
14508
14509 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14510 PyObject *resultobj = 0;
14511 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14512 int arg2 ;
14513 int arg3 ;
14514 void *argp1 = 0 ;
14515 int res1 = 0 ;
14516 int val2 ;
14517 int ecode2 = 0 ;
14518 int val3 ;
14519 int ecode3 = 0 ;
14520 PyObject * obj0 = 0 ;
14521 PyObject * obj1 = 0 ;
14522 PyObject * obj2 = 0 ;
14523 char * kwnames[] = {
14524 (char *) "self",(char *) "pid",(char *) "status", NULL
14525 };
14526
14527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14529 if (!SWIG_IsOK(res1)) {
14530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14531 }
14532 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14533 ecode2 = SWIG_AsVal_int(obj1, &val2);
14534 if (!SWIG_IsOK(ecode2)) {
14535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14536 }
14537 arg2 = static_cast< int >(val2);
14538 ecode3 = SWIG_AsVal_int(obj2, &val3);
14539 if (!SWIG_IsOK(ecode3)) {
14540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14541 }
14542 arg3 = static_cast< int >(val3);
14543 {
14544 PyThreadState* __tstate = wxPyBeginAllowThreads();
14545 (arg1)->OnTerminate(arg2,arg3);
14546 wxPyEndAllowThreads(__tstate);
14547 if (PyErr_Occurred()) SWIG_fail;
14548 }
14549 resultobj = SWIG_Py_Void();
14550 return resultobj;
14551 fail:
14552 return NULL;
14553 }
14554
14555
14556 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14557 PyObject *resultobj = 0;
14558 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14559 void *argp1 = 0 ;
14560 int res1 = 0 ;
14561 PyObject *swig_obj[1] ;
14562
14563 if (!args) SWIG_fail;
14564 swig_obj[0] = args;
14565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14566 if (!SWIG_IsOK(res1)) {
14567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14568 }
14569 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14570 {
14571 PyThreadState* __tstate = wxPyBeginAllowThreads();
14572 (arg1)->Redirect();
14573 wxPyEndAllowThreads(__tstate);
14574 if (PyErr_Occurred()) SWIG_fail;
14575 }
14576 resultobj = SWIG_Py_Void();
14577 return resultobj;
14578 fail:
14579 return NULL;
14580 }
14581
14582
14583 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14584 PyObject *resultobj = 0;
14585 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14586 bool result;
14587 void *argp1 = 0 ;
14588 int res1 = 0 ;
14589 PyObject *swig_obj[1] ;
14590
14591 if (!args) SWIG_fail;
14592 swig_obj[0] = args;
14593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14594 if (!SWIG_IsOK(res1)) {
14595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14596 }
14597 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14598 {
14599 PyThreadState* __tstate = wxPyBeginAllowThreads();
14600 result = (bool)(arg1)->IsRedirected();
14601 wxPyEndAllowThreads(__tstate);
14602 if (PyErr_Occurred()) SWIG_fail;
14603 }
14604 {
14605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14606 }
14607 return resultobj;
14608 fail:
14609 return NULL;
14610 }
14611
14612
14613 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14614 PyObject *resultobj = 0;
14615 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14616 void *argp1 = 0 ;
14617 int res1 = 0 ;
14618 PyObject *swig_obj[1] ;
14619
14620 if (!args) SWIG_fail;
14621 swig_obj[0] = args;
14622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14623 if (!SWIG_IsOK(res1)) {
14624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14625 }
14626 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14627 {
14628 PyThreadState* __tstate = wxPyBeginAllowThreads();
14629 (arg1)->Detach();
14630 wxPyEndAllowThreads(__tstate);
14631 if (PyErr_Occurred()) SWIG_fail;
14632 }
14633 resultobj = SWIG_Py_Void();
14634 return resultobj;
14635 fail:
14636 return NULL;
14637 }
14638
14639
14640 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14641 PyObject *resultobj = 0;
14642 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14643 wxInputStream *result = 0 ;
14644 void *argp1 = 0 ;
14645 int res1 = 0 ;
14646 PyObject *swig_obj[1] ;
14647
14648 if (!args) SWIG_fail;
14649 swig_obj[0] = args;
14650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14651 if (!SWIG_IsOK(res1)) {
14652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14653 }
14654 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14655 {
14656 PyThreadState* __tstate = wxPyBeginAllowThreads();
14657 result = (wxInputStream *)(arg1)->GetInputStream();
14658 wxPyEndAllowThreads(__tstate);
14659 if (PyErr_Occurred()) SWIG_fail;
14660 }
14661 {
14662 wxPyInputStream * _ptr = NULL;
14663
14664 if (result) {
14665 _ptr = new wxPyInputStream(result);
14666 }
14667 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14668 }
14669 return resultobj;
14670 fail:
14671 return NULL;
14672 }
14673
14674
14675 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14676 PyObject *resultobj = 0;
14677 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14678 wxInputStream *result = 0 ;
14679 void *argp1 = 0 ;
14680 int res1 = 0 ;
14681 PyObject *swig_obj[1] ;
14682
14683 if (!args) SWIG_fail;
14684 swig_obj[0] = args;
14685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14686 if (!SWIG_IsOK(res1)) {
14687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14688 }
14689 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14690 {
14691 PyThreadState* __tstate = wxPyBeginAllowThreads();
14692 result = (wxInputStream *)(arg1)->GetErrorStream();
14693 wxPyEndAllowThreads(__tstate);
14694 if (PyErr_Occurred()) SWIG_fail;
14695 }
14696 {
14697 wxPyInputStream * _ptr = NULL;
14698
14699 if (result) {
14700 _ptr = new wxPyInputStream(result);
14701 }
14702 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14703 }
14704 return resultobj;
14705 fail:
14706 return NULL;
14707 }
14708
14709
14710 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14711 PyObject *resultobj = 0;
14712 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14713 wxOutputStream *result = 0 ;
14714 void *argp1 = 0 ;
14715 int res1 = 0 ;
14716 PyObject *swig_obj[1] ;
14717
14718 if (!args) SWIG_fail;
14719 swig_obj[0] = args;
14720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14721 if (!SWIG_IsOK(res1)) {
14722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14723 }
14724 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14725 {
14726 PyThreadState* __tstate = wxPyBeginAllowThreads();
14727 result = (wxOutputStream *)(arg1)->GetOutputStream();
14728 wxPyEndAllowThreads(__tstate);
14729 if (PyErr_Occurred()) SWIG_fail;
14730 }
14731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14732 return resultobj;
14733 fail:
14734 return NULL;
14735 }
14736
14737
14738 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14739 PyObject *resultobj = 0;
14740 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14741 void *argp1 = 0 ;
14742 int res1 = 0 ;
14743 PyObject *swig_obj[1] ;
14744
14745 if (!args) SWIG_fail;
14746 swig_obj[0] = args;
14747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14748 if (!SWIG_IsOK(res1)) {
14749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14750 }
14751 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14752 {
14753 PyThreadState* __tstate = wxPyBeginAllowThreads();
14754 (arg1)->CloseOutput();
14755 wxPyEndAllowThreads(__tstate);
14756 if (PyErr_Occurred()) SWIG_fail;
14757 }
14758 resultobj = SWIG_Py_Void();
14759 return resultobj;
14760 fail:
14761 return NULL;
14762 }
14763
14764
14765 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14766 PyObject *resultobj = 0;
14767 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14768 bool result;
14769 void *argp1 = 0 ;
14770 int res1 = 0 ;
14771 PyObject *swig_obj[1] ;
14772
14773 if (!args) SWIG_fail;
14774 swig_obj[0] = args;
14775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14776 if (!SWIG_IsOK(res1)) {
14777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14778 }
14779 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14780 {
14781 PyThreadState* __tstate = wxPyBeginAllowThreads();
14782 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14783 wxPyEndAllowThreads(__tstate);
14784 if (PyErr_Occurred()) SWIG_fail;
14785 }
14786 {
14787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14788 }
14789 return resultobj;
14790 fail:
14791 return NULL;
14792 }
14793
14794
14795 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14796 PyObject *resultobj = 0;
14797 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14798 bool result;
14799 void *argp1 = 0 ;
14800 int res1 = 0 ;
14801 PyObject *swig_obj[1] ;
14802
14803 if (!args) SWIG_fail;
14804 swig_obj[0] = args;
14805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14806 if (!SWIG_IsOK(res1)) {
14807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14808 }
14809 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14810 {
14811 PyThreadState* __tstate = wxPyBeginAllowThreads();
14812 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14813 wxPyEndAllowThreads(__tstate);
14814 if (PyErr_Occurred()) SWIG_fail;
14815 }
14816 {
14817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14818 }
14819 return resultobj;
14820 fail:
14821 return NULL;
14822 }
14823
14824
14825 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14826 PyObject *resultobj = 0;
14827 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14828 bool result;
14829 void *argp1 = 0 ;
14830 int res1 = 0 ;
14831 PyObject *swig_obj[1] ;
14832
14833 if (!args) SWIG_fail;
14834 swig_obj[0] = args;
14835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14836 if (!SWIG_IsOK(res1)) {
14837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14838 }
14839 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14840 {
14841 PyThreadState* __tstate = wxPyBeginAllowThreads();
14842 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14843 wxPyEndAllowThreads(__tstate);
14844 if (PyErr_Occurred()) SWIG_fail;
14845 }
14846 {
14847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14848 }
14849 return resultobj;
14850 fail:
14851 return NULL;
14852 }
14853
14854
14855 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14856 PyObject *obj;
14857 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14858 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14859 return SWIG_Py_Void();
14860 }
14861
14862 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14863 return SWIG_Python_InitShadowInstance(args);
14864 }
14865
14866 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14867 PyObject *resultobj = 0;
14868 int arg1 = (int) 0 ;
14869 int arg2 = (int) 0 ;
14870 int arg3 = (int) 0 ;
14871 wxProcessEvent *result = 0 ;
14872 int val1 ;
14873 int ecode1 = 0 ;
14874 int val2 ;
14875 int ecode2 = 0 ;
14876 int val3 ;
14877 int ecode3 = 0 ;
14878 PyObject * obj0 = 0 ;
14879 PyObject * obj1 = 0 ;
14880 PyObject * obj2 = 0 ;
14881 char * kwnames[] = {
14882 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14883 };
14884
14885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14886 if (obj0) {
14887 ecode1 = SWIG_AsVal_int(obj0, &val1);
14888 if (!SWIG_IsOK(ecode1)) {
14889 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14890 }
14891 arg1 = static_cast< int >(val1);
14892 }
14893 if (obj1) {
14894 ecode2 = SWIG_AsVal_int(obj1, &val2);
14895 if (!SWIG_IsOK(ecode2)) {
14896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14897 }
14898 arg2 = static_cast< int >(val2);
14899 }
14900 if (obj2) {
14901 ecode3 = SWIG_AsVal_int(obj2, &val3);
14902 if (!SWIG_IsOK(ecode3)) {
14903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14904 }
14905 arg3 = static_cast< int >(val3);
14906 }
14907 {
14908 PyThreadState* __tstate = wxPyBeginAllowThreads();
14909 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14910 wxPyEndAllowThreads(__tstate);
14911 if (PyErr_Occurred()) SWIG_fail;
14912 }
14913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14914 return resultobj;
14915 fail:
14916 return NULL;
14917 }
14918
14919
14920 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14921 PyObject *resultobj = 0;
14922 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14923 int result;
14924 void *argp1 = 0 ;
14925 int res1 = 0 ;
14926 PyObject *swig_obj[1] ;
14927
14928 if (!args) SWIG_fail;
14929 swig_obj[0] = args;
14930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14931 if (!SWIG_IsOK(res1)) {
14932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14933 }
14934 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14935 {
14936 PyThreadState* __tstate = wxPyBeginAllowThreads();
14937 result = (int)(arg1)->GetPid();
14938 wxPyEndAllowThreads(__tstate);
14939 if (PyErr_Occurred()) SWIG_fail;
14940 }
14941 resultobj = SWIG_From_int(static_cast< int >(result));
14942 return resultobj;
14943 fail:
14944 return NULL;
14945 }
14946
14947
14948 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14949 PyObject *resultobj = 0;
14950 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14951 int result;
14952 void *argp1 = 0 ;
14953 int res1 = 0 ;
14954 PyObject *swig_obj[1] ;
14955
14956 if (!args) SWIG_fail;
14957 swig_obj[0] = args;
14958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14959 if (!SWIG_IsOK(res1)) {
14960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14961 }
14962 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14963 {
14964 PyThreadState* __tstate = wxPyBeginAllowThreads();
14965 result = (int)(arg1)->GetExitCode();
14966 wxPyEndAllowThreads(__tstate);
14967 if (PyErr_Occurred()) SWIG_fail;
14968 }
14969 resultobj = SWIG_From_int(static_cast< int >(result));
14970 return resultobj;
14971 fail:
14972 return NULL;
14973 }
14974
14975
14976 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14977 PyObject *resultobj = 0;
14978 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14979 int arg2 ;
14980 void *argp1 = 0 ;
14981 int res1 = 0 ;
14982 int val2 ;
14983 int ecode2 = 0 ;
14984 PyObject *swig_obj[2] ;
14985
14986 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14988 if (!SWIG_IsOK(res1)) {
14989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14990 }
14991 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14992 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14993 if (!SWIG_IsOK(ecode2)) {
14994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14995 }
14996 arg2 = static_cast< int >(val2);
14997 if (arg1) (arg1)->m_pid = arg2;
14998
14999 resultobj = SWIG_Py_Void();
15000 return resultobj;
15001 fail:
15002 return NULL;
15003 }
15004
15005
15006 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15007 PyObject *resultobj = 0;
15008 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15009 int result;
15010 void *argp1 = 0 ;
15011 int res1 = 0 ;
15012 PyObject *swig_obj[1] ;
15013
15014 if (!args) SWIG_fail;
15015 swig_obj[0] = args;
15016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15017 if (!SWIG_IsOK(res1)) {
15018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15019 }
15020 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15021 result = (int) ((arg1)->m_pid);
15022 resultobj = SWIG_From_int(static_cast< int >(result));
15023 return resultobj;
15024 fail:
15025 return NULL;
15026 }
15027
15028
15029 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15030 PyObject *resultobj = 0;
15031 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15032 int arg2 ;
15033 void *argp1 = 0 ;
15034 int res1 = 0 ;
15035 int val2 ;
15036 int ecode2 = 0 ;
15037 PyObject *swig_obj[2] ;
15038
15039 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15041 if (!SWIG_IsOK(res1)) {
15042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15043 }
15044 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15045 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15046 if (!SWIG_IsOK(ecode2)) {
15047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15048 }
15049 arg2 = static_cast< int >(val2);
15050 if (arg1) (arg1)->m_exitcode = arg2;
15051
15052 resultobj = SWIG_Py_Void();
15053 return resultobj;
15054 fail:
15055 return NULL;
15056 }
15057
15058
15059 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15060 PyObject *resultobj = 0;
15061 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15062 int result;
15063 void *argp1 = 0 ;
15064 int res1 = 0 ;
15065 PyObject *swig_obj[1] ;
15066
15067 if (!args) SWIG_fail;
15068 swig_obj[0] = args;
15069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15070 if (!SWIG_IsOK(res1)) {
15071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15072 }
15073 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15074 result = (int) ((arg1)->m_exitcode);
15075 resultobj = SWIG_From_int(static_cast< int >(result));
15076 return resultobj;
15077 fail:
15078 return NULL;
15079 }
15080
15081
15082 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15083 PyObject *obj;
15084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15085 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15086 return SWIG_Py_Void();
15087 }
15088
15089 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15090 return SWIG_Python_InitShadowInstance(args);
15091 }
15092
15093 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15094 PyObject *resultobj = 0;
15095 wxString *arg1 = 0 ;
15096 int arg2 = (int) wxEXEC_ASYNC ;
15097 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15098 long result;
15099 bool temp1 = false ;
15100 int val2 ;
15101 int ecode2 = 0 ;
15102 void *argp3 = 0 ;
15103 int res3 = 0 ;
15104 PyObject * obj0 = 0 ;
15105 PyObject * obj1 = 0 ;
15106 PyObject * obj2 = 0 ;
15107 char * kwnames[] = {
15108 (char *) "command",(char *) "flags",(char *) "process", NULL
15109 };
15110
15111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15112 {
15113 arg1 = wxString_in_helper(obj0);
15114 if (arg1 == NULL) SWIG_fail;
15115 temp1 = true;
15116 }
15117 if (obj1) {
15118 ecode2 = SWIG_AsVal_int(obj1, &val2);
15119 if (!SWIG_IsOK(ecode2)) {
15120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15121 }
15122 arg2 = static_cast< int >(val2);
15123 }
15124 if (obj2) {
15125 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15126 if (!SWIG_IsOK(res3)) {
15127 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15128 }
15129 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15130 }
15131 {
15132 if (!wxPyCheckForApp()) SWIG_fail;
15133 PyThreadState* __tstate = wxPyBeginAllowThreads();
15134 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15135 wxPyEndAllowThreads(__tstate);
15136 if (PyErr_Occurred()) SWIG_fail;
15137 }
15138 resultobj = SWIG_From_long(static_cast< long >(result));
15139 {
15140 if (temp1)
15141 delete arg1;
15142 }
15143 return resultobj;
15144 fail:
15145 {
15146 if (temp1)
15147 delete arg1;
15148 }
15149 return NULL;
15150 }
15151
15152
15153 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15154 PyObject *resultobj = 0;
15155 long arg1 ;
15156 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15157 wxKillError *arg3 = (wxKillError *) 0 ;
15158 int arg4 = (int) wxKILL_NOCHILDREN ;
15159 int result;
15160 long val1 ;
15161 int ecode1 = 0 ;
15162 int val2 ;
15163 int ecode2 = 0 ;
15164 wxKillError temp3 ;
15165 int val4 ;
15166 int ecode4 = 0 ;
15167 PyObject * obj0 = 0 ;
15168 PyObject * obj1 = 0 ;
15169 PyObject * obj2 = 0 ;
15170 char * kwnames[] = {
15171 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15172 };
15173
15174 {
15175 arg3 = &temp3;
15176 }
15177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15178 ecode1 = SWIG_AsVal_long(obj0, &val1);
15179 if (!SWIG_IsOK(ecode1)) {
15180 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15181 }
15182 arg1 = static_cast< long >(val1);
15183 if (obj1) {
15184 ecode2 = SWIG_AsVal_int(obj1, &val2);
15185 if (!SWIG_IsOK(ecode2)) {
15186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15187 }
15188 arg2 = static_cast< wxSignal >(val2);
15189 }
15190 if (obj2) {
15191 ecode4 = SWIG_AsVal_int(obj2, &val4);
15192 if (!SWIG_IsOK(ecode4)) {
15193 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15194 }
15195 arg4 = static_cast< int >(val4);
15196 }
15197 {
15198 PyThreadState* __tstate = wxPyBeginAllowThreads();
15199 result = (int)wxKill(arg1,arg2,arg3,arg4);
15200 wxPyEndAllowThreads(__tstate);
15201 if (PyErr_Occurred()) SWIG_fail;
15202 }
15203 resultobj = SWIG_From_int(static_cast< int >(result));
15204 {
15205 PyObject* o;
15206 o = PyInt_FromLong((long) (*arg3));
15207
15208
15209
15210 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15211
15212 }
15213 return resultobj;
15214 fail:
15215 return NULL;
15216 }
15217
15218
15219 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15220 PyObject *resultobj = 0;
15221 int arg1 = (int) wxJOYSTICK1 ;
15222 wxJoystick *result = 0 ;
15223 int val1 ;
15224 int ecode1 = 0 ;
15225 PyObject * obj0 = 0 ;
15226 char * kwnames[] = {
15227 (char *) "joystick", NULL
15228 };
15229
15230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15231 if (obj0) {
15232 ecode1 = SWIG_AsVal_int(obj0, &val1);
15233 if (!SWIG_IsOK(ecode1)) {
15234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15235 }
15236 arg1 = static_cast< int >(val1);
15237 }
15238 {
15239 if (!wxPyCheckForApp()) SWIG_fail;
15240 PyThreadState* __tstate = wxPyBeginAllowThreads();
15241 result = (wxJoystick *)new wxJoystick(arg1);
15242 wxPyEndAllowThreads(__tstate);
15243 if (PyErr_Occurred()) SWIG_fail;
15244 }
15245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15246 return resultobj;
15247 fail:
15248 return NULL;
15249 }
15250
15251
15252 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15253 PyObject *resultobj = 0;
15254 wxJoystick *arg1 = (wxJoystick *) 0 ;
15255 void *argp1 = 0 ;
15256 int res1 = 0 ;
15257 PyObject *swig_obj[1] ;
15258
15259 if (!args) SWIG_fail;
15260 swig_obj[0] = args;
15261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15262 if (!SWIG_IsOK(res1)) {
15263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15264 }
15265 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15266 {
15267 PyThreadState* __tstate = wxPyBeginAllowThreads();
15268 delete arg1;
15269
15270 wxPyEndAllowThreads(__tstate);
15271 if (PyErr_Occurred()) SWIG_fail;
15272 }
15273 resultobj = SWIG_Py_Void();
15274 return resultobj;
15275 fail:
15276 return NULL;
15277 }
15278
15279
15280 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15281 PyObject *resultobj = 0;
15282 wxJoystick *arg1 = (wxJoystick *) 0 ;
15283 wxPoint result;
15284 void *argp1 = 0 ;
15285 int res1 = 0 ;
15286 PyObject *swig_obj[1] ;
15287
15288 if (!args) SWIG_fail;
15289 swig_obj[0] = args;
15290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15291 if (!SWIG_IsOK(res1)) {
15292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15293 }
15294 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15295 {
15296 PyThreadState* __tstate = wxPyBeginAllowThreads();
15297 result = (arg1)->GetPosition();
15298 wxPyEndAllowThreads(__tstate);
15299 if (PyErr_Occurred()) SWIG_fail;
15300 }
15301 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15302 return resultobj;
15303 fail:
15304 return NULL;
15305 }
15306
15307
15308 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15309 PyObject *resultobj = 0;
15310 wxJoystick *arg1 = (wxJoystick *) 0 ;
15311 int result;
15312 void *argp1 = 0 ;
15313 int res1 = 0 ;
15314 PyObject *swig_obj[1] ;
15315
15316 if (!args) SWIG_fail;
15317 swig_obj[0] = args;
15318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15319 if (!SWIG_IsOK(res1)) {
15320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15321 }
15322 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15323 {
15324 PyThreadState* __tstate = wxPyBeginAllowThreads();
15325 result = (int)(arg1)->GetZPosition();
15326 wxPyEndAllowThreads(__tstate);
15327 if (PyErr_Occurred()) SWIG_fail;
15328 }
15329 resultobj = SWIG_From_int(static_cast< int >(result));
15330 return resultobj;
15331 fail:
15332 return NULL;
15333 }
15334
15335
15336 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15337 PyObject *resultobj = 0;
15338 wxJoystick *arg1 = (wxJoystick *) 0 ;
15339 int result;
15340 void *argp1 = 0 ;
15341 int res1 = 0 ;
15342 PyObject *swig_obj[1] ;
15343
15344 if (!args) SWIG_fail;
15345 swig_obj[0] = args;
15346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15347 if (!SWIG_IsOK(res1)) {
15348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15349 }
15350 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15351 {
15352 PyThreadState* __tstate = wxPyBeginAllowThreads();
15353 result = (int)(arg1)->GetButtonState();
15354 wxPyEndAllowThreads(__tstate);
15355 if (PyErr_Occurred()) SWIG_fail;
15356 }
15357 resultobj = SWIG_From_int(static_cast< int >(result));
15358 return resultobj;
15359 fail:
15360 return NULL;
15361 }
15362
15363
15364 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15365 PyObject *resultobj = 0;
15366 wxJoystick *arg1 = (wxJoystick *) 0 ;
15367 int result;
15368 void *argp1 = 0 ;
15369 int res1 = 0 ;
15370 PyObject *swig_obj[1] ;
15371
15372 if (!args) SWIG_fail;
15373 swig_obj[0] = args;
15374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15375 if (!SWIG_IsOK(res1)) {
15376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15377 }
15378 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15379 {
15380 PyThreadState* __tstate = wxPyBeginAllowThreads();
15381 result = (int)(arg1)->GetPOVPosition();
15382 wxPyEndAllowThreads(__tstate);
15383 if (PyErr_Occurred()) SWIG_fail;
15384 }
15385 resultobj = SWIG_From_int(static_cast< int >(result));
15386 return resultobj;
15387 fail:
15388 return NULL;
15389 }
15390
15391
15392 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15393 PyObject *resultobj = 0;
15394 wxJoystick *arg1 = (wxJoystick *) 0 ;
15395 int result;
15396 void *argp1 = 0 ;
15397 int res1 = 0 ;
15398 PyObject *swig_obj[1] ;
15399
15400 if (!args) SWIG_fail;
15401 swig_obj[0] = args;
15402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15403 if (!SWIG_IsOK(res1)) {
15404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15405 }
15406 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15407 {
15408 PyThreadState* __tstate = wxPyBeginAllowThreads();
15409 result = (int)(arg1)->GetPOVCTSPosition();
15410 wxPyEndAllowThreads(__tstate);
15411 if (PyErr_Occurred()) SWIG_fail;
15412 }
15413 resultobj = SWIG_From_int(static_cast< int >(result));
15414 return resultobj;
15415 fail:
15416 return NULL;
15417 }
15418
15419
15420 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15421 PyObject *resultobj = 0;
15422 wxJoystick *arg1 = (wxJoystick *) 0 ;
15423 int result;
15424 void *argp1 = 0 ;
15425 int res1 = 0 ;
15426 PyObject *swig_obj[1] ;
15427
15428 if (!args) SWIG_fail;
15429 swig_obj[0] = args;
15430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15431 if (!SWIG_IsOK(res1)) {
15432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15433 }
15434 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15435 {
15436 PyThreadState* __tstate = wxPyBeginAllowThreads();
15437 result = (int)(arg1)->GetRudderPosition();
15438 wxPyEndAllowThreads(__tstate);
15439 if (PyErr_Occurred()) SWIG_fail;
15440 }
15441 resultobj = SWIG_From_int(static_cast< int >(result));
15442 return resultobj;
15443 fail:
15444 return NULL;
15445 }
15446
15447
15448 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15449 PyObject *resultobj = 0;
15450 wxJoystick *arg1 = (wxJoystick *) 0 ;
15451 int result;
15452 void *argp1 = 0 ;
15453 int res1 = 0 ;
15454 PyObject *swig_obj[1] ;
15455
15456 if (!args) SWIG_fail;
15457 swig_obj[0] = args;
15458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15459 if (!SWIG_IsOK(res1)) {
15460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15461 }
15462 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15463 {
15464 PyThreadState* __tstate = wxPyBeginAllowThreads();
15465 result = (int)(arg1)->GetUPosition();
15466 wxPyEndAllowThreads(__tstate);
15467 if (PyErr_Occurred()) SWIG_fail;
15468 }
15469 resultobj = SWIG_From_int(static_cast< int >(result));
15470 return resultobj;
15471 fail:
15472 return NULL;
15473 }
15474
15475
15476 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15477 PyObject *resultobj = 0;
15478 wxJoystick *arg1 = (wxJoystick *) 0 ;
15479 int result;
15480 void *argp1 = 0 ;
15481 int res1 = 0 ;
15482 PyObject *swig_obj[1] ;
15483
15484 if (!args) SWIG_fail;
15485 swig_obj[0] = args;
15486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15487 if (!SWIG_IsOK(res1)) {
15488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15489 }
15490 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15491 {
15492 PyThreadState* __tstate = wxPyBeginAllowThreads();
15493 result = (int)(arg1)->GetVPosition();
15494 wxPyEndAllowThreads(__tstate);
15495 if (PyErr_Occurred()) SWIG_fail;
15496 }
15497 resultobj = SWIG_From_int(static_cast< int >(result));
15498 return resultobj;
15499 fail:
15500 return NULL;
15501 }
15502
15503
15504 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(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_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15517 }
15518 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15519 {
15520 PyThreadState* __tstate = wxPyBeginAllowThreads();
15521 result = (int)(arg1)->GetMovementThreshold();
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_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15533 PyObject *resultobj = 0;
15534 wxJoystick *arg1 = (wxJoystick *) 0 ;
15535 int arg2 ;
15536 void *argp1 = 0 ;
15537 int res1 = 0 ;
15538 int val2 ;
15539 int ecode2 = 0 ;
15540 PyObject * obj0 = 0 ;
15541 PyObject * obj1 = 0 ;
15542 char * kwnames[] = {
15543 (char *) "self",(char *) "threshold", NULL
15544 };
15545
15546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15548 if (!SWIG_IsOK(res1)) {
15549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15550 }
15551 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15552 ecode2 = SWIG_AsVal_int(obj1, &val2);
15553 if (!SWIG_IsOK(ecode2)) {
15554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15555 }
15556 arg2 = static_cast< int >(val2);
15557 {
15558 PyThreadState* __tstate = wxPyBeginAllowThreads();
15559 (arg1)->SetMovementThreshold(arg2);
15560 wxPyEndAllowThreads(__tstate);
15561 if (PyErr_Occurred()) SWIG_fail;
15562 }
15563 resultobj = SWIG_Py_Void();
15564 return resultobj;
15565 fail:
15566 return NULL;
15567 }
15568
15569
15570 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15571 PyObject *resultobj = 0;
15572 wxJoystick *arg1 = (wxJoystick *) 0 ;
15573 bool result;
15574 void *argp1 = 0 ;
15575 int res1 = 0 ;
15576 PyObject *swig_obj[1] ;
15577
15578 if (!args) SWIG_fail;
15579 swig_obj[0] = args;
15580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15581 if (!SWIG_IsOK(res1)) {
15582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15583 }
15584 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15585 {
15586 PyThreadState* __tstate = wxPyBeginAllowThreads();
15587 result = (bool)(arg1)->IsOk();
15588 wxPyEndAllowThreads(__tstate);
15589 if (PyErr_Occurred()) SWIG_fail;
15590 }
15591 {
15592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15593 }
15594 return resultobj;
15595 fail:
15596 return NULL;
15597 }
15598
15599
15600 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15601 PyObject *resultobj = 0;
15602 wxJoystick *arg1 = (wxJoystick *) 0 ;
15603 int result;
15604 void *argp1 = 0 ;
15605 int res1 = 0 ;
15606 PyObject *swig_obj[1] ;
15607
15608 if (!args) SWIG_fail;
15609 swig_obj[0] = args;
15610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15611 if (!SWIG_IsOK(res1)) {
15612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15613 }
15614 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15615 {
15616 PyThreadState* __tstate = wxPyBeginAllowThreads();
15617 result = (int)(arg1)->GetNumberJoysticks();
15618 wxPyEndAllowThreads(__tstate);
15619 if (PyErr_Occurred()) SWIG_fail;
15620 }
15621 resultobj = SWIG_From_int(static_cast< int >(result));
15622 return resultobj;
15623 fail:
15624 return NULL;
15625 }
15626
15627
15628 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15629 PyObject *resultobj = 0;
15630 wxJoystick *arg1 = (wxJoystick *) 0 ;
15631 int result;
15632 void *argp1 = 0 ;
15633 int res1 = 0 ;
15634 PyObject *swig_obj[1] ;
15635
15636 if (!args) SWIG_fail;
15637 swig_obj[0] = args;
15638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15639 if (!SWIG_IsOK(res1)) {
15640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15641 }
15642 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15643 {
15644 PyThreadState* __tstate = wxPyBeginAllowThreads();
15645 result = (int)(arg1)->GetManufacturerId();
15646 wxPyEndAllowThreads(__tstate);
15647 if (PyErr_Occurred()) SWIG_fail;
15648 }
15649 resultobj = SWIG_From_int(static_cast< int >(result));
15650 return resultobj;
15651 fail:
15652 return NULL;
15653 }
15654
15655
15656 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15657 PyObject *resultobj = 0;
15658 wxJoystick *arg1 = (wxJoystick *) 0 ;
15659 int result;
15660 void *argp1 = 0 ;
15661 int res1 = 0 ;
15662 PyObject *swig_obj[1] ;
15663
15664 if (!args) SWIG_fail;
15665 swig_obj[0] = args;
15666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15667 if (!SWIG_IsOK(res1)) {
15668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15669 }
15670 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15671 {
15672 PyThreadState* __tstate = wxPyBeginAllowThreads();
15673 result = (int)(arg1)->GetProductId();
15674 wxPyEndAllowThreads(__tstate);
15675 if (PyErr_Occurred()) SWIG_fail;
15676 }
15677 resultobj = SWIG_From_int(static_cast< int >(result));
15678 return resultobj;
15679 fail:
15680 return NULL;
15681 }
15682
15683
15684 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15685 PyObject *resultobj = 0;
15686 wxJoystick *arg1 = (wxJoystick *) 0 ;
15687 wxString result;
15688 void *argp1 = 0 ;
15689 int res1 = 0 ;
15690 PyObject *swig_obj[1] ;
15691
15692 if (!args) SWIG_fail;
15693 swig_obj[0] = args;
15694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15695 if (!SWIG_IsOK(res1)) {
15696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15697 }
15698 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15699 {
15700 PyThreadState* __tstate = wxPyBeginAllowThreads();
15701 result = (arg1)->GetProductName();
15702 wxPyEndAllowThreads(__tstate);
15703 if (PyErr_Occurred()) SWIG_fail;
15704 }
15705 {
15706 #if wxUSE_UNICODE
15707 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15708 #else
15709 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15710 #endif
15711 }
15712 return resultobj;
15713 fail:
15714 return NULL;
15715 }
15716
15717
15718 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15719 PyObject *resultobj = 0;
15720 wxJoystick *arg1 = (wxJoystick *) 0 ;
15721 int result;
15722 void *argp1 = 0 ;
15723 int res1 = 0 ;
15724 PyObject *swig_obj[1] ;
15725
15726 if (!args) SWIG_fail;
15727 swig_obj[0] = args;
15728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15729 if (!SWIG_IsOK(res1)) {
15730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15731 }
15732 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15733 {
15734 PyThreadState* __tstate = wxPyBeginAllowThreads();
15735 result = (int)(arg1)->GetXMin();
15736 wxPyEndAllowThreads(__tstate);
15737 if (PyErr_Occurred()) SWIG_fail;
15738 }
15739 resultobj = SWIG_From_int(static_cast< int >(result));
15740 return resultobj;
15741 fail:
15742 return NULL;
15743 }
15744
15745
15746 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15747 PyObject *resultobj = 0;
15748 wxJoystick *arg1 = (wxJoystick *) 0 ;
15749 int result;
15750 void *argp1 = 0 ;
15751 int res1 = 0 ;
15752 PyObject *swig_obj[1] ;
15753
15754 if (!args) SWIG_fail;
15755 swig_obj[0] = args;
15756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15757 if (!SWIG_IsOK(res1)) {
15758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15759 }
15760 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15761 {
15762 PyThreadState* __tstate = wxPyBeginAllowThreads();
15763 result = (int)(arg1)->GetYMin();
15764 wxPyEndAllowThreads(__tstate);
15765 if (PyErr_Occurred()) SWIG_fail;
15766 }
15767 resultobj = SWIG_From_int(static_cast< int >(result));
15768 return resultobj;
15769 fail:
15770 return NULL;
15771 }
15772
15773
15774 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15775 PyObject *resultobj = 0;
15776 wxJoystick *arg1 = (wxJoystick *) 0 ;
15777 int result;
15778 void *argp1 = 0 ;
15779 int res1 = 0 ;
15780 PyObject *swig_obj[1] ;
15781
15782 if (!args) SWIG_fail;
15783 swig_obj[0] = args;
15784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15785 if (!SWIG_IsOK(res1)) {
15786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15787 }
15788 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15789 {
15790 PyThreadState* __tstate = wxPyBeginAllowThreads();
15791 result = (int)(arg1)->GetZMin();
15792 wxPyEndAllowThreads(__tstate);
15793 if (PyErr_Occurred()) SWIG_fail;
15794 }
15795 resultobj = SWIG_From_int(static_cast< int >(result));
15796 return resultobj;
15797 fail:
15798 return NULL;
15799 }
15800
15801
15802 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15803 PyObject *resultobj = 0;
15804 wxJoystick *arg1 = (wxJoystick *) 0 ;
15805 int result;
15806 void *argp1 = 0 ;
15807 int res1 = 0 ;
15808 PyObject *swig_obj[1] ;
15809
15810 if (!args) SWIG_fail;
15811 swig_obj[0] = args;
15812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15813 if (!SWIG_IsOK(res1)) {
15814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15815 }
15816 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15817 {
15818 PyThreadState* __tstate = wxPyBeginAllowThreads();
15819 result = (int)(arg1)->GetXMax();
15820 wxPyEndAllowThreads(__tstate);
15821 if (PyErr_Occurred()) SWIG_fail;
15822 }
15823 resultobj = SWIG_From_int(static_cast< int >(result));
15824 return resultobj;
15825 fail:
15826 return NULL;
15827 }
15828
15829
15830 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15831 PyObject *resultobj = 0;
15832 wxJoystick *arg1 = (wxJoystick *) 0 ;
15833 int result;
15834 void *argp1 = 0 ;
15835 int res1 = 0 ;
15836 PyObject *swig_obj[1] ;
15837
15838 if (!args) SWIG_fail;
15839 swig_obj[0] = args;
15840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15841 if (!SWIG_IsOK(res1)) {
15842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15843 }
15844 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15845 {
15846 PyThreadState* __tstate = wxPyBeginAllowThreads();
15847 result = (int)(arg1)->GetYMax();
15848 wxPyEndAllowThreads(__tstate);
15849 if (PyErr_Occurred()) SWIG_fail;
15850 }
15851 resultobj = SWIG_From_int(static_cast< int >(result));
15852 return resultobj;
15853 fail:
15854 return NULL;
15855 }
15856
15857
15858 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15859 PyObject *resultobj = 0;
15860 wxJoystick *arg1 = (wxJoystick *) 0 ;
15861 int result;
15862 void *argp1 = 0 ;
15863 int res1 = 0 ;
15864 PyObject *swig_obj[1] ;
15865
15866 if (!args) SWIG_fail;
15867 swig_obj[0] = args;
15868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15869 if (!SWIG_IsOK(res1)) {
15870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15871 }
15872 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15873 {
15874 PyThreadState* __tstate = wxPyBeginAllowThreads();
15875 result = (int)(arg1)->GetZMax();
15876 wxPyEndAllowThreads(__tstate);
15877 if (PyErr_Occurred()) SWIG_fail;
15878 }
15879 resultobj = SWIG_From_int(static_cast< int >(result));
15880 return resultobj;
15881 fail:
15882 return NULL;
15883 }
15884
15885
15886 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15887 PyObject *resultobj = 0;
15888 wxJoystick *arg1 = (wxJoystick *) 0 ;
15889 int result;
15890 void *argp1 = 0 ;
15891 int res1 = 0 ;
15892 PyObject *swig_obj[1] ;
15893
15894 if (!args) SWIG_fail;
15895 swig_obj[0] = args;
15896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15897 if (!SWIG_IsOK(res1)) {
15898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15899 }
15900 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15901 {
15902 PyThreadState* __tstate = wxPyBeginAllowThreads();
15903 result = (int)(arg1)->GetNumberButtons();
15904 wxPyEndAllowThreads(__tstate);
15905 if (PyErr_Occurred()) SWIG_fail;
15906 }
15907 resultobj = SWIG_From_int(static_cast< int >(result));
15908 return resultobj;
15909 fail:
15910 return NULL;
15911 }
15912
15913
15914 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15915 PyObject *resultobj = 0;
15916 wxJoystick *arg1 = (wxJoystick *) 0 ;
15917 int result;
15918 void *argp1 = 0 ;
15919 int res1 = 0 ;
15920 PyObject *swig_obj[1] ;
15921
15922 if (!args) SWIG_fail;
15923 swig_obj[0] = args;
15924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15925 if (!SWIG_IsOK(res1)) {
15926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15927 }
15928 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15929 {
15930 PyThreadState* __tstate = wxPyBeginAllowThreads();
15931 result = (int)(arg1)->GetNumberAxes();
15932 wxPyEndAllowThreads(__tstate);
15933 if (PyErr_Occurred()) SWIG_fail;
15934 }
15935 resultobj = SWIG_From_int(static_cast< int >(result));
15936 return resultobj;
15937 fail:
15938 return NULL;
15939 }
15940
15941
15942 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15943 PyObject *resultobj = 0;
15944 wxJoystick *arg1 = (wxJoystick *) 0 ;
15945 int result;
15946 void *argp1 = 0 ;
15947 int res1 = 0 ;
15948 PyObject *swig_obj[1] ;
15949
15950 if (!args) SWIG_fail;
15951 swig_obj[0] = args;
15952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15953 if (!SWIG_IsOK(res1)) {
15954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15955 }
15956 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15957 {
15958 PyThreadState* __tstate = wxPyBeginAllowThreads();
15959 result = (int)(arg1)->GetMaxButtons();
15960 wxPyEndAllowThreads(__tstate);
15961 if (PyErr_Occurred()) SWIG_fail;
15962 }
15963 resultobj = SWIG_From_int(static_cast< int >(result));
15964 return resultobj;
15965 fail:
15966 return NULL;
15967 }
15968
15969
15970 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15971 PyObject *resultobj = 0;
15972 wxJoystick *arg1 = (wxJoystick *) 0 ;
15973 int result;
15974 void *argp1 = 0 ;
15975 int res1 = 0 ;
15976 PyObject *swig_obj[1] ;
15977
15978 if (!args) SWIG_fail;
15979 swig_obj[0] = args;
15980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15981 if (!SWIG_IsOK(res1)) {
15982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15983 }
15984 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15985 {
15986 PyThreadState* __tstate = wxPyBeginAllowThreads();
15987 result = (int)(arg1)->GetMaxAxes();
15988 wxPyEndAllowThreads(__tstate);
15989 if (PyErr_Occurred()) SWIG_fail;
15990 }
15991 resultobj = SWIG_From_int(static_cast< int >(result));
15992 return resultobj;
15993 fail:
15994 return NULL;
15995 }
15996
15997
15998 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15999 PyObject *resultobj = 0;
16000 wxJoystick *arg1 = (wxJoystick *) 0 ;
16001 int result;
16002 void *argp1 = 0 ;
16003 int res1 = 0 ;
16004 PyObject *swig_obj[1] ;
16005
16006 if (!args) SWIG_fail;
16007 swig_obj[0] = args;
16008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16009 if (!SWIG_IsOK(res1)) {
16010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16011 }
16012 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16013 {
16014 PyThreadState* __tstate = wxPyBeginAllowThreads();
16015 result = (int)(arg1)->GetPollingMin();
16016 wxPyEndAllowThreads(__tstate);
16017 if (PyErr_Occurred()) SWIG_fail;
16018 }
16019 resultobj = SWIG_From_int(static_cast< int >(result));
16020 return resultobj;
16021 fail:
16022 return NULL;
16023 }
16024
16025
16026 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16027 PyObject *resultobj = 0;
16028 wxJoystick *arg1 = (wxJoystick *) 0 ;
16029 int result;
16030 void *argp1 = 0 ;
16031 int res1 = 0 ;
16032 PyObject *swig_obj[1] ;
16033
16034 if (!args) SWIG_fail;
16035 swig_obj[0] = args;
16036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16037 if (!SWIG_IsOK(res1)) {
16038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16039 }
16040 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16041 {
16042 PyThreadState* __tstate = wxPyBeginAllowThreads();
16043 result = (int)(arg1)->GetPollingMax();
16044 wxPyEndAllowThreads(__tstate);
16045 if (PyErr_Occurred()) SWIG_fail;
16046 }
16047 resultobj = SWIG_From_int(static_cast< int >(result));
16048 return resultobj;
16049 fail:
16050 return NULL;
16051 }
16052
16053
16054 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16055 PyObject *resultobj = 0;
16056 wxJoystick *arg1 = (wxJoystick *) 0 ;
16057 int result;
16058 void *argp1 = 0 ;
16059 int res1 = 0 ;
16060 PyObject *swig_obj[1] ;
16061
16062 if (!args) SWIG_fail;
16063 swig_obj[0] = args;
16064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16065 if (!SWIG_IsOK(res1)) {
16066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16067 }
16068 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16069 {
16070 PyThreadState* __tstate = wxPyBeginAllowThreads();
16071 result = (int)(arg1)->GetRudderMin();
16072 wxPyEndAllowThreads(__tstate);
16073 if (PyErr_Occurred()) SWIG_fail;
16074 }
16075 resultobj = SWIG_From_int(static_cast< int >(result));
16076 return resultobj;
16077 fail:
16078 return NULL;
16079 }
16080
16081
16082 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16083 PyObject *resultobj = 0;
16084 wxJoystick *arg1 = (wxJoystick *) 0 ;
16085 int result;
16086 void *argp1 = 0 ;
16087 int res1 = 0 ;
16088 PyObject *swig_obj[1] ;
16089
16090 if (!args) SWIG_fail;
16091 swig_obj[0] = args;
16092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16093 if (!SWIG_IsOK(res1)) {
16094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16095 }
16096 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16097 {
16098 PyThreadState* __tstate = wxPyBeginAllowThreads();
16099 result = (int)(arg1)->GetRudderMax();
16100 wxPyEndAllowThreads(__tstate);
16101 if (PyErr_Occurred()) SWIG_fail;
16102 }
16103 resultobj = SWIG_From_int(static_cast< int >(result));
16104 return resultobj;
16105 fail:
16106 return NULL;
16107 }
16108
16109
16110 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16111 PyObject *resultobj = 0;
16112 wxJoystick *arg1 = (wxJoystick *) 0 ;
16113 int result;
16114 void *argp1 = 0 ;
16115 int res1 = 0 ;
16116 PyObject *swig_obj[1] ;
16117
16118 if (!args) SWIG_fail;
16119 swig_obj[0] = args;
16120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16121 if (!SWIG_IsOK(res1)) {
16122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16123 }
16124 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16125 {
16126 PyThreadState* __tstate = wxPyBeginAllowThreads();
16127 result = (int)(arg1)->GetUMin();
16128 wxPyEndAllowThreads(__tstate);
16129 if (PyErr_Occurred()) SWIG_fail;
16130 }
16131 resultobj = SWIG_From_int(static_cast< int >(result));
16132 return resultobj;
16133 fail:
16134 return NULL;
16135 }
16136
16137
16138 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16139 PyObject *resultobj = 0;
16140 wxJoystick *arg1 = (wxJoystick *) 0 ;
16141 int result;
16142 void *argp1 = 0 ;
16143 int res1 = 0 ;
16144 PyObject *swig_obj[1] ;
16145
16146 if (!args) SWIG_fail;
16147 swig_obj[0] = args;
16148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16149 if (!SWIG_IsOK(res1)) {
16150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16151 }
16152 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16153 {
16154 PyThreadState* __tstate = wxPyBeginAllowThreads();
16155 result = (int)(arg1)->GetUMax();
16156 wxPyEndAllowThreads(__tstate);
16157 if (PyErr_Occurred()) SWIG_fail;
16158 }
16159 resultobj = SWIG_From_int(static_cast< int >(result));
16160 return resultobj;
16161 fail:
16162 return NULL;
16163 }
16164
16165
16166 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16167 PyObject *resultobj = 0;
16168 wxJoystick *arg1 = (wxJoystick *) 0 ;
16169 int result;
16170 void *argp1 = 0 ;
16171 int res1 = 0 ;
16172 PyObject *swig_obj[1] ;
16173
16174 if (!args) SWIG_fail;
16175 swig_obj[0] = args;
16176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16177 if (!SWIG_IsOK(res1)) {
16178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16179 }
16180 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16181 {
16182 PyThreadState* __tstate = wxPyBeginAllowThreads();
16183 result = (int)(arg1)->GetVMin();
16184 wxPyEndAllowThreads(__tstate);
16185 if (PyErr_Occurred()) SWIG_fail;
16186 }
16187 resultobj = SWIG_From_int(static_cast< int >(result));
16188 return resultobj;
16189 fail:
16190 return NULL;
16191 }
16192
16193
16194 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16195 PyObject *resultobj = 0;
16196 wxJoystick *arg1 = (wxJoystick *) 0 ;
16197 int result;
16198 void *argp1 = 0 ;
16199 int res1 = 0 ;
16200 PyObject *swig_obj[1] ;
16201
16202 if (!args) SWIG_fail;
16203 swig_obj[0] = args;
16204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16205 if (!SWIG_IsOK(res1)) {
16206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16207 }
16208 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16209 {
16210 PyThreadState* __tstate = wxPyBeginAllowThreads();
16211 result = (int)(arg1)->GetVMax();
16212 wxPyEndAllowThreads(__tstate);
16213 if (PyErr_Occurred()) SWIG_fail;
16214 }
16215 resultobj = SWIG_From_int(static_cast< int >(result));
16216 return resultobj;
16217 fail:
16218 return NULL;
16219 }
16220
16221
16222 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16223 PyObject *resultobj = 0;
16224 wxJoystick *arg1 = (wxJoystick *) 0 ;
16225 bool result;
16226 void *argp1 = 0 ;
16227 int res1 = 0 ;
16228 PyObject *swig_obj[1] ;
16229
16230 if (!args) SWIG_fail;
16231 swig_obj[0] = args;
16232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16233 if (!SWIG_IsOK(res1)) {
16234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16235 }
16236 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16237 {
16238 PyThreadState* __tstate = wxPyBeginAllowThreads();
16239 result = (bool)(arg1)->HasRudder();
16240 wxPyEndAllowThreads(__tstate);
16241 if (PyErr_Occurred()) SWIG_fail;
16242 }
16243 {
16244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16245 }
16246 return resultobj;
16247 fail:
16248 return NULL;
16249 }
16250
16251
16252 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16253 PyObject *resultobj = 0;
16254 wxJoystick *arg1 = (wxJoystick *) 0 ;
16255 bool result;
16256 void *argp1 = 0 ;
16257 int res1 = 0 ;
16258 PyObject *swig_obj[1] ;
16259
16260 if (!args) SWIG_fail;
16261 swig_obj[0] = args;
16262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16263 if (!SWIG_IsOK(res1)) {
16264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16265 }
16266 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16267 {
16268 PyThreadState* __tstate = wxPyBeginAllowThreads();
16269 result = (bool)(arg1)->HasZ();
16270 wxPyEndAllowThreads(__tstate);
16271 if (PyErr_Occurred()) SWIG_fail;
16272 }
16273 {
16274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16275 }
16276 return resultobj;
16277 fail:
16278 return NULL;
16279 }
16280
16281
16282 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16283 PyObject *resultobj = 0;
16284 wxJoystick *arg1 = (wxJoystick *) 0 ;
16285 bool result;
16286 void *argp1 = 0 ;
16287 int res1 = 0 ;
16288 PyObject *swig_obj[1] ;
16289
16290 if (!args) SWIG_fail;
16291 swig_obj[0] = args;
16292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16293 if (!SWIG_IsOK(res1)) {
16294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16295 }
16296 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16297 {
16298 PyThreadState* __tstate = wxPyBeginAllowThreads();
16299 result = (bool)(arg1)->HasU();
16300 wxPyEndAllowThreads(__tstate);
16301 if (PyErr_Occurred()) SWIG_fail;
16302 }
16303 {
16304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16305 }
16306 return resultobj;
16307 fail:
16308 return NULL;
16309 }
16310
16311
16312 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16313 PyObject *resultobj = 0;
16314 wxJoystick *arg1 = (wxJoystick *) 0 ;
16315 bool result;
16316 void *argp1 = 0 ;
16317 int res1 = 0 ;
16318 PyObject *swig_obj[1] ;
16319
16320 if (!args) SWIG_fail;
16321 swig_obj[0] = args;
16322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16323 if (!SWIG_IsOK(res1)) {
16324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16325 }
16326 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16327 {
16328 PyThreadState* __tstate = wxPyBeginAllowThreads();
16329 result = (bool)(arg1)->HasV();
16330 wxPyEndAllowThreads(__tstate);
16331 if (PyErr_Occurred()) SWIG_fail;
16332 }
16333 {
16334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16335 }
16336 return resultobj;
16337 fail:
16338 return NULL;
16339 }
16340
16341
16342 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16343 PyObject *resultobj = 0;
16344 wxJoystick *arg1 = (wxJoystick *) 0 ;
16345 bool result;
16346 void *argp1 = 0 ;
16347 int res1 = 0 ;
16348 PyObject *swig_obj[1] ;
16349
16350 if (!args) SWIG_fail;
16351 swig_obj[0] = args;
16352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16353 if (!SWIG_IsOK(res1)) {
16354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16355 }
16356 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16357 {
16358 PyThreadState* __tstate = wxPyBeginAllowThreads();
16359 result = (bool)(arg1)->HasPOV();
16360 wxPyEndAllowThreads(__tstate);
16361 if (PyErr_Occurred()) SWIG_fail;
16362 }
16363 {
16364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16365 }
16366 return resultobj;
16367 fail:
16368 return NULL;
16369 }
16370
16371
16372 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16373 PyObject *resultobj = 0;
16374 wxJoystick *arg1 = (wxJoystick *) 0 ;
16375 bool result;
16376 void *argp1 = 0 ;
16377 int res1 = 0 ;
16378 PyObject *swig_obj[1] ;
16379
16380 if (!args) SWIG_fail;
16381 swig_obj[0] = args;
16382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16383 if (!SWIG_IsOK(res1)) {
16384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16385 }
16386 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16387 {
16388 PyThreadState* __tstate = wxPyBeginAllowThreads();
16389 result = (bool)(arg1)->HasPOV4Dir();
16390 wxPyEndAllowThreads(__tstate);
16391 if (PyErr_Occurred()) SWIG_fail;
16392 }
16393 {
16394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16395 }
16396 return resultobj;
16397 fail:
16398 return NULL;
16399 }
16400
16401
16402 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16403 PyObject *resultobj = 0;
16404 wxJoystick *arg1 = (wxJoystick *) 0 ;
16405 bool result;
16406 void *argp1 = 0 ;
16407 int res1 = 0 ;
16408 PyObject *swig_obj[1] ;
16409
16410 if (!args) SWIG_fail;
16411 swig_obj[0] = args;
16412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16413 if (!SWIG_IsOK(res1)) {
16414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16415 }
16416 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16417 {
16418 PyThreadState* __tstate = wxPyBeginAllowThreads();
16419 result = (bool)(arg1)->HasPOVCTS();
16420 wxPyEndAllowThreads(__tstate);
16421 if (PyErr_Occurred()) SWIG_fail;
16422 }
16423 {
16424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16425 }
16426 return resultobj;
16427 fail:
16428 return NULL;
16429 }
16430
16431
16432 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16433 PyObject *resultobj = 0;
16434 wxJoystick *arg1 = (wxJoystick *) 0 ;
16435 wxWindow *arg2 = (wxWindow *) 0 ;
16436 int arg3 = (int) 0 ;
16437 bool result;
16438 void *argp1 = 0 ;
16439 int res1 = 0 ;
16440 void *argp2 = 0 ;
16441 int res2 = 0 ;
16442 int val3 ;
16443 int ecode3 = 0 ;
16444 PyObject * obj0 = 0 ;
16445 PyObject * obj1 = 0 ;
16446 PyObject * obj2 = 0 ;
16447 char * kwnames[] = {
16448 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16449 };
16450
16451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16453 if (!SWIG_IsOK(res1)) {
16454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16455 }
16456 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16457 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16458 if (!SWIG_IsOK(res2)) {
16459 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16460 }
16461 arg2 = reinterpret_cast< wxWindow * >(argp2);
16462 if (obj2) {
16463 ecode3 = SWIG_AsVal_int(obj2, &val3);
16464 if (!SWIG_IsOK(ecode3)) {
16465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16466 }
16467 arg3 = static_cast< int >(val3);
16468 }
16469 {
16470 PyThreadState* __tstate = wxPyBeginAllowThreads();
16471 result = (bool)(arg1)->SetCapture(arg2,arg3);
16472 wxPyEndAllowThreads(__tstate);
16473 if (PyErr_Occurred()) SWIG_fail;
16474 }
16475 {
16476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16477 }
16478 return resultobj;
16479 fail:
16480 return NULL;
16481 }
16482
16483
16484 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16485 PyObject *resultobj = 0;
16486 wxJoystick *arg1 = (wxJoystick *) 0 ;
16487 bool result;
16488 void *argp1 = 0 ;
16489 int res1 = 0 ;
16490 PyObject *swig_obj[1] ;
16491
16492 if (!args) SWIG_fail;
16493 swig_obj[0] = args;
16494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16495 if (!SWIG_IsOK(res1)) {
16496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16497 }
16498 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16499 {
16500 PyThreadState* __tstate = wxPyBeginAllowThreads();
16501 result = (bool)(arg1)->ReleaseCapture();
16502 wxPyEndAllowThreads(__tstate);
16503 if (PyErr_Occurred()) SWIG_fail;
16504 }
16505 {
16506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16507 }
16508 return resultobj;
16509 fail:
16510 return NULL;
16511 }
16512
16513
16514 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16515 PyObject *obj;
16516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16517 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16518 return SWIG_Py_Void();
16519 }
16520
16521 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16522 return SWIG_Python_InitShadowInstance(args);
16523 }
16524
16525 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16526 PyObject *resultobj = 0;
16527 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16528 int arg2 = (int) 0 ;
16529 int arg3 = (int) wxJOYSTICK1 ;
16530 int arg4 = (int) 0 ;
16531 wxJoystickEvent *result = 0 ;
16532 int val1 ;
16533 int ecode1 = 0 ;
16534 int val2 ;
16535 int ecode2 = 0 ;
16536 int val3 ;
16537 int ecode3 = 0 ;
16538 int val4 ;
16539 int ecode4 = 0 ;
16540 PyObject * obj0 = 0 ;
16541 PyObject * obj1 = 0 ;
16542 PyObject * obj2 = 0 ;
16543 PyObject * obj3 = 0 ;
16544 char * kwnames[] = {
16545 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16546 };
16547
16548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16549 if (obj0) {
16550 ecode1 = SWIG_AsVal_int(obj0, &val1);
16551 if (!SWIG_IsOK(ecode1)) {
16552 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16553 }
16554 arg1 = static_cast< wxEventType >(val1);
16555 }
16556 if (obj1) {
16557 ecode2 = SWIG_AsVal_int(obj1, &val2);
16558 if (!SWIG_IsOK(ecode2)) {
16559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16560 }
16561 arg2 = static_cast< int >(val2);
16562 }
16563 if (obj2) {
16564 ecode3 = SWIG_AsVal_int(obj2, &val3);
16565 if (!SWIG_IsOK(ecode3)) {
16566 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16567 }
16568 arg3 = static_cast< int >(val3);
16569 }
16570 if (obj3) {
16571 ecode4 = SWIG_AsVal_int(obj3, &val4);
16572 if (!SWIG_IsOK(ecode4)) {
16573 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16574 }
16575 arg4 = static_cast< int >(val4);
16576 }
16577 {
16578 PyThreadState* __tstate = wxPyBeginAllowThreads();
16579 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16580 wxPyEndAllowThreads(__tstate);
16581 if (PyErr_Occurred()) SWIG_fail;
16582 }
16583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16584 return resultobj;
16585 fail:
16586 return NULL;
16587 }
16588
16589
16590 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16591 PyObject *resultobj = 0;
16592 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16593 wxPoint result;
16594 void *argp1 = 0 ;
16595 int res1 = 0 ;
16596 PyObject *swig_obj[1] ;
16597
16598 if (!args) SWIG_fail;
16599 swig_obj[0] = args;
16600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16601 if (!SWIG_IsOK(res1)) {
16602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16603 }
16604 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16605 {
16606 PyThreadState* __tstate = wxPyBeginAllowThreads();
16607 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16608 wxPyEndAllowThreads(__tstate);
16609 if (PyErr_Occurred()) SWIG_fail;
16610 }
16611 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16612 return resultobj;
16613 fail:
16614 return NULL;
16615 }
16616
16617
16618 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16619 PyObject *resultobj = 0;
16620 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16621 int result;
16622 void *argp1 = 0 ;
16623 int res1 = 0 ;
16624 PyObject *swig_obj[1] ;
16625
16626 if (!args) SWIG_fail;
16627 swig_obj[0] = args;
16628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16629 if (!SWIG_IsOK(res1)) {
16630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16631 }
16632 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16633 {
16634 PyThreadState* __tstate = wxPyBeginAllowThreads();
16635 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16636 wxPyEndAllowThreads(__tstate);
16637 if (PyErr_Occurred()) SWIG_fail;
16638 }
16639 resultobj = SWIG_From_int(static_cast< int >(result));
16640 return resultobj;
16641 fail:
16642 return NULL;
16643 }
16644
16645
16646 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16647 PyObject *resultobj = 0;
16648 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16649 int result;
16650 void *argp1 = 0 ;
16651 int res1 = 0 ;
16652 PyObject *swig_obj[1] ;
16653
16654 if (!args) SWIG_fail;
16655 swig_obj[0] = args;
16656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16657 if (!SWIG_IsOK(res1)) {
16658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16659 }
16660 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16661 {
16662 PyThreadState* __tstate = wxPyBeginAllowThreads();
16663 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16664 wxPyEndAllowThreads(__tstate);
16665 if (PyErr_Occurred()) SWIG_fail;
16666 }
16667 resultobj = SWIG_From_int(static_cast< int >(result));
16668 return resultobj;
16669 fail:
16670 return NULL;
16671 }
16672
16673
16674 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16675 PyObject *resultobj = 0;
16676 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16677 int result;
16678 void *argp1 = 0 ;
16679 int res1 = 0 ;
16680 PyObject *swig_obj[1] ;
16681
16682 if (!args) SWIG_fail;
16683 swig_obj[0] = args;
16684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16685 if (!SWIG_IsOK(res1)) {
16686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16687 }
16688 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16689 {
16690 PyThreadState* __tstate = wxPyBeginAllowThreads();
16691 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16692 wxPyEndAllowThreads(__tstate);
16693 if (PyErr_Occurred()) SWIG_fail;
16694 }
16695 resultobj = SWIG_From_int(static_cast< int >(result));
16696 return resultobj;
16697 fail:
16698 return NULL;
16699 }
16700
16701
16702 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16703 PyObject *resultobj = 0;
16704 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16705 int result;
16706 void *argp1 = 0 ;
16707 int res1 = 0 ;
16708 PyObject *swig_obj[1] ;
16709
16710 if (!args) SWIG_fail;
16711 swig_obj[0] = args;
16712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16713 if (!SWIG_IsOK(res1)) {
16714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16715 }
16716 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16717 {
16718 PyThreadState* __tstate = wxPyBeginAllowThreads();
16719 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16720 wxPyEndAllowThreads(__tstate);
16721 if (PyErr_Occurred()) SWIG_fail;
16722 }
16723 resultobj = SWIG_From_int(static_cast< int >(result));
16724 return resultobj;
16725 fail:
16726 return NULL;
16727 }
16728
16729
16730 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16731 PyObject *resultobj = 0;
16732 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16733 int arg2 ;
16734 void *argp1 = 0 ;
16735 int res1 = 0 ;
16736 int val2 ;
16737 int ecode2 = 0 ;
16738 PyObject * obj0 = 0 ;
16739 PyObject * obj1 = 0 ;
16740 char * kwnames[] = {
16741 (char *) "self",(char *) "stick", NULL
16742 };
16743
16744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16746 if (!SWIG_IsOK(res1)) {
16747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16748 }
16749 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16750 ecode2 = SWIG_AsVal_int(obj1, &val2);
16751 if (!SWIG_IsOK(ecode2)) {
16752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16753 }
16754 arg2 = static_cast< int >(val2);
16755 {
16756 PyThreadState* __tstate = wxPyBeginAllowThreads();
16757 (arg1)->SetJoystick(arg2);
16758 wxPyEndAllowThreads(__tstate);
16759 if (PyErr_Occurred()) SWIG_fail;
16760 }
16761 resultobj = SWIG_Py_Void();
16762 return resultobj;
16763 fail:
16764 return NULL;
16765 }
16766
16767
16768 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16769 PyObject *resultobj = 0;
16770 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16771 int arg2 ;
16772 void *argp1 = 0 ;
16773 int res1 = 0 ;
16774 int val2 ;
16775 int ecode2 = 0 ;
16776 PyObject * obj0 = 0 ;
16777 PyObject * obj1 = 0 ;
16778 char * kwnames[] = {
16779 (char *) "self",(char *) "state", NULL
16780 };
16781
16782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16784 if (!SWIG_IsOK(res1)) {
16785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16786 }
16787 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16788 ecode2 = SWIG_AsVal_int(obj1, &val2);
16789 if (!SWIG_IsOK(ecode2)) {
16790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16791 }
16792 arg2 = static_cast< int >(val2);
16793 {
16794 PyThreadState* __tstate = wxPyBeginAllowThreads();
16795 (arg1)->SetButtonState(arg2);
16796 wxPyEndAllowThreads(__tstate);
16797 if (PyErr_Occurred()) SWIG_fail;
16798 }
16799 resultobj = SWIG_Py_Void();
16800 return resultobj;
16801 fail:
16802 return NULL;
16803 }
16804
16805
16806 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16807 PyObject *resultobj = 0;
16808 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16809 int arg2 ;
16810 void *argp1 = 0 ;
16811 int res1 = 0 ;
16812 int val2 ;
16813 int ecode2 = 0 ;
16814 PyObject * obj0 = 0 ;
16815 PyObject * obj1 = 0 ;
16816 char * kwnames[] = {
16817 (char *) "self",(char *) "change", NULL
16818 };
16819
16820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16822 if (!SWIG_IsOK(res1)) {
16823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16824 }
16825 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16826 ecode2 = SWIG_AsVal_int(obj1, &val2);
16827 if (!SWIG_IsOK(ecode2)) {
16828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16829 }
16830 arg2 = static_cast< int >(val2);
16831 {
16832 PyThreadState* __tstate = wxPyBeginAllowThreads();
16833 (arg1)->SetButtonChange(arg2);
16834 wxPyEndAllowThreads(__tstate);
16835 if (PyErr_Occurred()) SWIG_fail;
16836 }
16837 resultobj = SWIG_Py_Void();
16838 return resultobj;
16839 fail:
16840 return NULL;
16841 }
16842
16843
16844 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16845 PyObject *resultobj = 0;
16846 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16847 wxPoint *arg2 = 0 ;
16848 void *argp1 = 0 ;
16849 int res1 = 0 ;
16850 wxPoint temp2 ;
16851 PyObject * obj0 = 0 ;
16852 PyObject * obj1 = 0 ;
16853 char * kwnames[] = {
16854 (char *) "self",(char *) "pos", NULL
16855 };
16856
16857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16859 if (!SWIG_IsOK(res1)) {
16860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16861 }
16862 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16863 {
16864 arg2 = &temp2;
16865 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16866 }
16867 {
16868 PyThreadState* __tstate = wxPyBeginAllowThreads();
16869 (arg1)->SetPosition((wxPoint const &)*arg2);
16870 wxPyEndAllowThreads(__tstate);
16871 if (PyErr_Occurred()) SWIG_fail;
16872 }
16873 resultobj = SWIG_Py_Void();
16874 return resultobj;
16875 fail:
16876 return NULL;
16877 }
16878
16879
16880 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16881 PyObject *resultobj = 0;
16882 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16883 int arg2 ;
16884 void *argp1 = 0 ;
16885 int res1 = 0 ;
16886 int val2 ;
16887 int ecode2 = 0 ;
16888 PyObject * obj0 = 0 ;
16889 PyObject * obj1 = 0 ;
16890 char * kwnames[] = {
16891 (char *) "self",(char *) "zPos", NULL
16892 };
16893
16894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16896 if (!SWIG_IsOK(res1)) {
16897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16898 }
16899 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16900 ecode2 = SWIG_AsVal_int(obj1, &val2);
16901 if (!SWIG_IsOK(ecode2)) {
16902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16903 }
16904 arg2 = static_cast< int >(val2);
16905 {
16906 PyThreadState* __tstate = wxPyBeginAllowThreads();
16907 (arg1)->SetZPosition(arg2);
16908 wxPyEndAllowThreads(__tstate);
16909 if (PyErr_Occurred()) SWIG_fail;
16910 }
16911 resultobj = SWIG_Py_Void();
16912 return resultobj;
16913 fail:
16914 return NULL;
16915 }
16916
16917
16918 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16919 PyObject *resultobj = 0;
16920 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16921 bool result;
16922 void *argp1 = 0 ;
16923 int res1 = 0 ;
16924 PyObject *swig_obj[1] ;
16925
16926 if (!args) SWIG_fail;
16927 swig_obj[0] = args;
16928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16929 if (!SWIG_IsOK(res1)) {
16930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16931 }
16932 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16933 {
16934 PyThreadState* __tstate = wxPyBeginAllowThreads();
16935 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16936 wxPyEndAllowThreads(__tstate);
16937 if (PyErr_Occurred()) SWIG_fail;
16938 }
16939 {
16940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16941 }
16942 return resultobj;
16943 fail:
16944 return NULL;
16945 }
16946
16947
16948 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16949 PyObject *resultobj = 0;
16950 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16951 bool result;
16952 void *argp1 = 0 ;
16953 int res1 = 0 ;
16954 PyObject *swig_obj[1] ;
16955
16956 if (!args) SWIG_fail;
16957 swig_obj[0] = args;
16958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16959 if (!SWIG_IsOK(res1)) {
16960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16961 }
16962 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16963 {
16964 PyThreadState* __tstate = wxPyBeginAllowThreads();
16965 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16966 wxPyEndAllowThreads(__tstate);
16967 if (PyErr_Occurred()) SWIG_fail;
16968 }
16969 {
16970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16971 }
16972 return resultobj;
16973 fail:
16974 return NULL;
16975 }
16976
16977
16978 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16979 PyObject *resultobj = 0;
16980 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16981 bool result;
16982 void *argp1 = 0 ;
16983 int res1 = 0 ;
16984 PyObject *swig_obj[1] ;
16985
16986 if (!args) SWIG_fail;
16987 swig_obj[0] = args;
16988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16989 if (!SWIG_IsOK(res1)) {
16990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16991 }
16992 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16993 {
16994 PyThreadState* __tstate = wxPyBeginAllowThreads();
16995 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16996 wxPyEndAllowThreads(__tstate);
16997 if (PyErr_Occurred()) SWIG_fail;
16998 }
16999 {
17000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17001 }
17002 return resultobj;
17003 fail:
17004 return NULL;
17005 }
17006
17007
17008 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17009 PyObject *resultobj = 0;
17010 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17011 int arg2 = (int) wxJOY_BUTTON_ANY ;
17012 bool result;
17013 void *argp1 = 0 ;
17014 int res1 = 0 ;
17015 int val2 ;
17016 int ecode2 = 0 ;
17017 PyObject * obj0 = 0 ;
17018 PyObject * obj1 = 0 ;
17019 char * kwnames[] = {
17020 (char *) "self",(char *) "but", NULL
17021 };
17022
17023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
17024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17025 if (!SWIG_IsOK(res1)) {
17026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17027 }
17028 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17029 if (obj1) {
17030 ecode2 = SWIG_AsVal_int(obj1, &val2);
17031 if (!SWIG_IsOK(ecode2)) {
17032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17033 }
17034 arg2 = static_cast< int >(val2);
17035 }
17036 {
17037 PyThreadState* __tstate = wxPyBeginAllowThreads();
17038 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17039 wxPyEndAllowThreads(__tstate);
17040 if (PyErr_Occurred()) SWIG_fail;
17041 }
17042 {
17043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17044 }
17045 return resultobj;
17046 fail:
17047 return NULL;
17048 }
17049
17050
17051 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17052 PyObject *resultobj = 0;
17053 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17054 int arg2 = (int) wxJOY_BUTTON_ANY ;
17055 bool result;
17056 void *argp1 = 0 ;
17057 int res1 = 0 ;
17058 int val2 ;
17059 int ecode2 = 0 ;
17060 PyObject * obj0 = 0 ;
17061 PyObject * obj1 = 0 ;
17062 char * kwnames[] = {
17063 (char *) "self",(char *) "but", NULL
17064 };
17065
17066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17068 if (!SWIG_IsOK(res1)) {
17069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17070 }
17071 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17072 if (obj1) {
17073 ecode2 = SWIG_AsVal_int(obj1, &val2);
17074 if (!SWIG_IsOK(ecode2)) {
17075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17076 }
17077 arg2 = static_cast< int >(val2);
17078 }
17079 {
17080 PyThreadState* __tstate = wxPyBeginAllowThreads();
17081 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17082 wxPyEndAllowThreads(__tstate);
17083 if (PyErr_Occurred()) SWIG_fail;
17084 }
17085 {
17086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17087 }
17088 return resultobj;
17089 fail:
17090 return NULL;
17091 }
17092
17093
17094 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17095 PyObject *resultobj = 0;
17096 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17097 int arg2 = (int) wxJOY_BUTTON_ANY ;
17098 bool result;
17099 void *argp1 = 0 ;
17100 int res1 = 0 ;
17101 int val2 ;
17102 int ecode2 = 0 ;
17103 PyObject * obj0 = 0 ;
17104 PyObject * obj1 = 0 ;
17105 char * kwnames[] = {
17106 (char *) "self",(char *) "but", NULL
17107 };
17108
17109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17111 if (!SWIG_IsOK(res1)) {
17112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17113 }
17114 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17115 if (obj1) {
17116 ecode2 = SWIG_AsVal_int(obj1, &val2);
17117 if (!SWIG_IsOK(ecode2)) {
17118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17119 }
17120 arg2 = static_cast< int >(val2);
17121 }
17122 {
17123 PyThreadState* __tstate = wxPyBeginAllowThreads();
17124 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17125 wxPyEndAllowThreads(__tstate);
17126 if (PyErr_Occurred()) SWIG_fail;
17127 }
17128 {
17129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17130 }
17131 return resultobj;
17132 fail:
17133 return NULL;
17134 }
17135
17136
17137 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17138 PyObject *obj;
17139 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17140 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17141 return SWIG_Py_Void();
17142 }
17143
17144 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17145 return SWIG_Python_InitShadowInstance(args);
17146 }
17147
17148 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17149 PyObject *resultobj = 0;
17150 wxString const &arg1_defvalue = wxPyEmptyString ;
17151 wxString *arg1 = (wxString *) &arg1_defvalue ;
17152 wxSound *result = 0 ;
17153 bool temp1 = false ;
17154 PyObject * obj0 = 0 ;
17155 char * kwnames[] = {
17156 (char *) "fileName", NULL
17157 };
17158
17159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17160 if (obj0) {
17161 {
17162 arg1 = wxString_in_helper(obj0);
17163 if (arg1 == NULL) SWIG_fail;
17164 temp1 = true;
17165 }
17166 }
17167 {
17168 if (!wxPyCheckForApp()) SWIG_fail;
17169 PyThreadState* __tstate = wxPyBeginAllowThreads();
17170 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17171 wxPyEndAllowThreads(__tstate);
17172 if (PyErr_Occurred()) SWIG_fail;
17173 }
17174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17175 {
17176 if (temp1)
17177 delete arg1;
17178 }
17179 return resultobj;
17180 fail:
17181 {
17182 if (temp1)
17183 delete arg1;
17184 }
17185 return NULL;
17186 }
17187
17188
17189 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17190 PyObject *resultobj = 0;
17191 PyObject *arg1 = (PyObject *) 0 ;
17192 wxSound *result = 0 ;
17193 PyObject * obj0 = 0 ;
17194 char * kwnames[] = {
17195 (char *) "data", NULL
17196 };
17197
17198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17199 arg1 = obj0;
17200 {
17201 if (!wxPyCheckForApp()) SWIG_fail;
17202 PyThreadState* __tstate = wxPyBeginAllowThreads();
17203 result = (wxSound *)new_wxSound(arg1);
17204 wxPyEndAllowThreads(__tstate);
17205 if (PyErr_Occurred()) SWIG_fail;
17206 }
17207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17208 return resultobj;
17209 fail:
17210 return NULL;
17211 }
17212
17213
17214 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17215 PyObject *resultobj = 0;
17216 wxSound *arg1 = (wxSound *) 0 ;
17217 void *argp1 = 0 ;
17218 int res1 = 0 ;
17219 PyObject *swig_obj[1] ;
17220
17221 if (!args) SWIG_fail;
17222 swig_obj[0] = args;
17223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17224 if (!SWIG_IsOK(res1)) {
17225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17226 }
17227 arg1 = reinterpret_cast< wxSound * >(argp1);
17228 {
17229 PyThreadState* __tstate = wxPyBeginAllowThreads();
17230 delete arg1;
17231
17232 wxPyEndAllowThreads(__tstate);
17233 if (PyErr_Occurred()) SWIG_fail;
17234 }
17235 resultobj = SWIG_Py_Void();
17236 return resultobj;
17237 fail:
17238 return NULL;
17239 }
17240
17241
17242 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17243 PyObject *resultobj = 0;
17244 wxSound *arg1 = (wxSound *) 0 ;
17245 wxString *arg2 = 0 ;
17246 bool result;
17247 void *argp1 = 0 ;
17248 int res1 = 0 ;
17249 bool temp2 = false ;
17250 PyObject * obj0 = 0 ;
17251 PyObject * obj1 = 0 ;
17252 char * kwnames[] = {
17253 (char *) "self",(char *) "fileName", NULL
17254 };
17255
17256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17258 if (!SWIG_IsOK(res1)) {
17259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17260 }
17261 arg1 = reinterpret_cast< wxSound * >(argp1);
17262 {
17263 arg2 = wxString_in_helper(obj1);
17264 if (arg2 == NULL) SWIG_fail;
17265 temp2 = true;
17266 }
17267 {
17268 PyThreadState* __tstate = wxPyBeginAllowThreads();
17269 result = (bool)(arg1)->Create((wxString const &)*arg2);
17270 wxPyEndAllowThreads(__tstate);
17271 if (PyErr_Occurred()) SWIG_fail;
17272 }
17273 {
17274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17275 }
17276 {
17277 if (temp2)
17278 delete arg2;
17279 }
17280 return resultobj;
17281 fail:
17282 {
17283 if (temp2)
17284 delete arg2;
17285 }
17286 return NULL;
17287 }
17288
17289
17290 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17291 PyObject *resultobj = 0;
17292 wxSound *arg1 = (wxSound *) 0 ;
17293 PyObject *arg2 = (PyObject *) 0 ;
17294 bool result;
17295 void *argp1 = 0 ;
17296 int res1 = 0 ;
17297 PyObject * obj0 = 0 ;
17298 PyObject * obj1 = 0 ;
17299 char * kwnames[] = {
17300 (char *) "self",(char *) "data", NULL
17301 };
17302
17303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17305 if (!SWIG_IsOK(res1)) {
17306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17307 }
17308 arg1 = reinterpret_cast< wxSound * >(argp1);
17309 arg2 = obj1;
17310 {
17311 PyThreadState* __tstate = wxPyBeginAllowThreads();
17312 result = (bool)wxSound_CreateFromData(arg1,arg2);
17313 wxPyEndAllowThreads(__tstate);
17314 if (PyErr_Occurred()) SWIG_fail;
17315 }
17316 {
17317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17318 }
17319 return resultobj;
17320 fail:
17321 return NULL;
17322 }
17323
17324
17325 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17326 PyObject *resultobj = 0;
17327 wxSound *arg1 = (wxSound *) 0 ;
17328 bool result;
17329 void *argp1 = 0 ;
17330 int res1 = 0 ;
17331 PyObject *swig_obj[1] ;
17332
17333 if (!args) SWIG_fail;
17334 swig_obj[0] = args;
17335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17336 if (!SWIG_IsOK(res1)) {
17337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17338 }
17339 arg1 = reinterpret_cast< wxSound * >(argp1);
17340 {
17341 PyThreadState* __tstate = wxPyBeginAllowThreads();
17342 result = (bool)(arg1)->IsOk();
17343 wxPyEndAllowThreads(__tstate);
17344 if (PyErr_Occurred()) SWIG_fail;
17345 }
17346 {
17347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17348 }
17349 return resultobj;
17350 fail:
17351 return NULL;
17352 }
17353
17354
17355 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17356 PyObject *resultobj = 0;
17357 wxSound *arg1 = (wxSound *) 0 ;
17358 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17359 bool result;
17360 void *argp1 = 0 ;
17361 int res1 = 0 ;
17362 unsigned int val2 ;
17363 int ecode2 = 0 ;
17364 PyObject * obj0 = 0 ;
17365 PyObject * obj1 = 0 ;
17366 char * kwnames[] = {
17367 (char *) "self",(char *) "flags", NULL
17368 };
17369
17370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17372 if (!SWIG_IsOK(res1)) {
17373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17374 }
17375 arg1 = reinterpret_cast< wxSound * >(argp1);
17376 if (obj1) {
17377 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17378 if (!SWIG_IsOK(ecode2)) {
17379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17380 }
17381 arg2 = static_cast< unsigned int >(val2);
17382 }
17383 {
17384 if (!wxPyCheckForApp()) SWIG_fail;
17385 PyThreadState* __tstate = wxPyBeginAllowThreads();
17386 result = (bool)((wxSound const *)arg1)->Play(arg2);
17387 wxPyEndAllowThreads(__tstate);
17388 if (PyErr_Occurred()) SWIG_fail;
17389 }
17390 {
17391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17392 }
17393 return resultobj;
17394 fail:
17395 return NULL;
17396 }
17397
17398
17399 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17400 PyObject *resultobj = 0;
17401 wxString *arg1 = 0 ;
17402 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17403 bool result;
17404 bool temp1 = false ;
17405 unsigned int val2 ;
17406 int ecode2 = 0 ;
17407 PyObject * obj0 = 0 ;
17408 PyObject * obj1 = 0 ;
17409 char * kwnames[] = {
17410 (char *) "filename",(char *) "flags", NULL
17411 };
17412
17413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17414 {
17415 arg1 = wxString_in_helper(obj0);
17416 if (arg1 == NULL) SWIG_fail;
17417 temp1 = true;
17418 }
17419 if (obj1) {
17420 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17421 if (!SWIG_IsOK(ecode2)) {
17422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17423 }
17424 arg2 = static_cast< unsigned int >(val2);
17425 }
17426 {
17427 if (!wxPyCheckForApp()) SWIG_fail;
17428 PyThreadState* __tstate = wxPyBeginAllowThreads();
17429 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17430 wxPyEndAllowThreads(__tstate);
17431 if (PyErr_Occurred()) SWIG_fail;
17432 }
17433 {
17434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17435 }
17436 {
17437 if (temp1)
17438 delete arg1;
17439 }
17440 return resultobj;
17441 fail:
17442 {
17443 if (temp1)
17444 delete arg1;
17445 }
17446 return NULL;
17447 }
17448
17449
17450 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17451 PyObject *resultobj = 0;
17452
17453 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17454 {
17455 if (!wxPyCheckForApp()) SWIG_fail;
17456 PyThreadState* __tstate = wxPyBeginAllowThreads();
17457 wxSound::Stop();
17458 wxPyEndAllowThreads(__tstate);
17459 if (PyErr_Occurred()) SWIG_fail;
17460 }
17461 resultobj = SWIG_Py_Void();
17462 return resultobj;
17463 fail:
17464 return NULL;
17465 }
17466
17467
17468 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17469 PyObject *obj;
17470 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17471 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17472 return SWIG_Py_Void();
17473 }
17474
17475 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17476 return SWIG_Python_InitShadowInstance(args);
17477 }
17478
17479 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17480 PyObject *resultobj = 0;
17481 wxString *arg1 = 0 ;
17482 wxString *arg2 = 0 ;
17483 wxString *arg3 = 0 ;
17484 wxString *arg4 = 0 ;
17485 wxFileTypeInfo *result = 0 ;
17486 bool temp1 = false ;
17487 bool temp2 = false ;
17488 bool temp3 = false ;
17489 bool temp4 = false ;
17490 PyObject * obj0 = 0 ;
17491 PyObject * obj1 = 0 ;
17492 PyObject * obj2 = 0 ;
17493 PyObject * obj3 = 0 ;
17494 char * kwnames[] = {
17495 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17496 };
17497
17498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17499 {
17500 arg1 = wxString_in_helper(obj0);
17501 if (arg1 == NULL) SWIG_fail;
17502 temp1 = true;
17503 }
17504 {
17505 arg2 = wxString_in_helper(obj1);
17506 if (arg2 == NULL) SWIG_fail;
17507 temp2 = true;
17508 }
17509 {
17510 arg3 = wxString_in_helper(obj2);
17511 if (arg3 == NULL) SWIG_fail;
17512 temp3 = true;
17513 }
17514 {
17515 arg4 = wxString_in_helper(obj3);
17516 if (arg4 == NULL) SWIG_fail;
17517 temp4 = true;
17518 }
17519 {
17520 PyThreadState* __tstate = wxPyBeginAllowThreads();
17521 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17522 wxPyEndAllowThreads(__tstate);
17523 if (PyErr_Occurred()) SWIG_fail;
17524 }
17525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17526 {
17527 if (temp1)
17528 delete arg1;
17529 }
17530 {
17531 if (temp2)
17532 delete arg2;
17533 }
17534 {
17535 if (temp3)
17536 delete arg3;
17537 }
17538 {
17539 if (temp4)
17540 delete arg4;
17541 }
17542 return resultobj;
17543 fail:
17544 {
17545 if (temp1)
17546 delete arg1;
17547 }
17548 {
17549 if (temp2)
17550 delete arg2;
17551 }
17552 {
17553 if (temp3)
17554 delete arg3;
17555 }
17556 {
17557 if (temp4)
17558 delete arg4;
17559 }
17560 return NULL;
17561 }
17562
17563
17564 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17565 PyObject *resultobj = 0;
17566 wxArrayString *arg1 = 0 ;
17567 wxFileTypeInfo *result = 0 ;
17568 bool temp1 = false ;
17569 PyObject * obj0 = 0 ;
17570 char * kwnames[] = {
17571 (char *) "sArray", NULL
17572 };
17573
17574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17575 {
17576 if (! PySequence_Check(obj0)) {
17577 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17578 SWIG_fail;
17579 }
17580 arg1 = new wxArrayString;
17581 temp1 = true;
17582 int i, len=PySequence_Length(obj0);
17583 for (i=0; i<len; i++) {
17584 PyObject* item = PySequence_GetItem(obj0, i);
17585 wxString* s = wxString_in_helper(item);
17586 if (PyErr_Occurred()) SWIG_fail;
17587 arg1->Add(*s);
17588 delete s;
17589 Py_DECREF(item);
17590 }
17591 }
17592 {
17593 PyThreadState* __tstate = wxPyBeginAllowThreads();
17594 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17595 wxPyEndAllowThreads(__tstate);
17596 if (PyErr_Occurred()) SWIG_fail;
17597 }
17598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17599 {
17600 if (temp1) delete arg1;
17601 }
17602 return resultobj;
17603 fail:
17604 {
17605 if (temp1) delete arg1;
17606 }
17607 return NULL;
17608 }
17609
17610
17611 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17612 PyObject *resultobj = 0;
17613 wxFileTypeInfo *result = 0 ;
17614
17615 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17616 {
17617 PyThreadState* __tstate = wxPyBeginAllowThreads();
17618 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17619 wxPyEndAllowThreads(__tstate);
17620 if (PyErr_Occurred()) SWIG_fail;
17621 }
17622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17623 return resultobj;
17624 fail:
17625 return NULL;
17626 }
17627
17628
17629 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17630 PyObject *resultobj = 0;
17631 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17632 bool result;
17633 void *argp1 = 0 ;
17634 int res1 = 0 ;
17635 PyObject *swig_obj[1] ;
17636
17637 if (!args) SWIG_fail;
17638 swig_obj[0] = args;
17639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17640 if (!SWIG_IsOK(res1)) {
17641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17642 }
17643 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17644 {
17645 PyThreadState* __tstate = wxPyBeginAllowThreads();
17646 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17647 wxPyEndAllowThreads(__tstate);
17648 if (PyErr_Occurred()) SWIG_fail;
17649 }
17650 {
17651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17652 }
17653 return resultobj;
17654 fail:
17655 return NULL;
17656 }
17657
17658
17659 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17660 PyObject *resultobj = 0;
17661 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17662 wxString *arg2 = 0 ;
17663 int arg3 = (int) 0 ;
17664 void *argp1 = 0 ;
17665 int res1 = 0 ;
17666 bool temp2 = false ;
17667 int val3 ;
17668 int ecode3 = 0 ;
17669 PyObject * obj0 = 0 ;
17670 PyObject * obj1 = 0 ;
17671 PyObject * obj2 = 0 ;
17672 char * kwnames[] = {
17673 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17674 };
17675
17676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17678 if (!SWIG_IsOK(res1)) {
17679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17680 }
17681 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17682 {
17683 arg2 = wxString_in_helper(obj1);
17684 if (arg2 == NULL) SWIG_fail;
17685 temp2 = true;
17686 }
17687 if (obj2) {
17688 ecode3 = SWIG_AsVal_int(obj2, &val3);
17689 if (!SWIG_IsOK(ecode3)) {
17690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17691 }
17692 arg3 = static_cast< int >(val3);
17693 }
17694 {
17695 PyThreadState* __tstate = wxPyBeginAllowThreads();
17696 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17697 wxPyEndAllowThreads(__tstate);
17698 if (PyErr_Occurred()) SWIG_fail;
17699 }
17700 resultobj = SWIG_Py_Void();
17701 {
17702 if (temp2)
17703 delete arg2;
17704 }
17705 return resultobj;
17706 fail:
17707 {
17708 if (temp2)
17709 delete arg2;
17710 }
17711 return NULL;
17712 }
17713
17714
17715 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17716 PyObject *resultobj = 0;
17717 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17718 wxString *arg2 = 0 ;
17719 void *argp1 = 0 ;
17720 int res1 = 0 ;
17721 bool temp2 = false ;
17722 PyObject * obj0 = 0 ;
17723 PyObject * obj1 = 0 ;
17724 char * kwnames[] = {
17725 (char *) "self",(char *) "shortDesc", NULL
17726 };
17727
17728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17730 if (!SWIG_IsOK(res1)) {
17731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17732 }
17733 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17734 {
17735 arg2 = wxString_in_helper(obj1);
17736 if (arg2 == NULL) SWIG_fail;
17737 temp2 = true;
17738 }
17739 {
17740 PyThreadState* __tstate = wxPyBeginAllowThreads();
17741 (arg1)->SetShortDesc((wxString const &)*arg2);
17742 wxPyEndAllowThreads(__tstate);
17743 if (PyErr_Occurred()) SWIG_fail;
17744 }
17745 resultobj = SWIG_Py_Void();
17746 {
17747 if (temp2)
17748 delete arg2;
17749 }
17750 return resultobj;
17751 fail:
17752 {
17753 if (temp2)
17754 delete arg2;
17755 }
17756 return NULL;
17757 }
17758
17759
17760 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17761 PyObject *resultobj = 0;
17762 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17763 wxString *result = 0 ;
17764 void *argp1 = 0 ;
17765 int res1 = 0 ;
17766 PyObject *swig_obj[1] ;
17767
17768 if (!args) SWIG_fail;
17769 swig_obj[0] = args;
17770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17771 if (!SWIG_IsOK(res1)) {
17772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17773 }
17774 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17775 {
17776 PyThreadState* __tstate = wxPyBeginAllowThreads();
17777 {
17778 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17779 result = (wxString *) &_result_ref;
17780 }
17781 wxPyEndAllowThreads(__tstate);
17782 if (PyErr_Occurred()) SWIG_fail;
17783 }
17784 {
17785 #if wxUSE_UNICODE
17786 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17787 #else
17788 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17789 #endif
17790 }
17791 return resultobj;
17792 fail:
17793 return NULL;
17794 }
17795
17796
17797 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17798 PyObject *resultobj = 0;
17799 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17800 wxString *result = 0 ;
17801 void *argp1 = 0 ;
17802 int res1 = 0 ;
17803 PyObject *swig_obj[1] ;
17804
17805 if (!args) SWIG_fail;
17806 swig_obj[0] = args;
17807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17808 if (!SWIG_IsOK(res1)) {
17809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17810 }
17811 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17812 {
17813 PyThreadState* __tstate = wxPyBeginAllowThreads();
17814 {
17815 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17816 result = (wxString *) &_result_ref;
17817 }
17818 wxPyEndAllowThreads(__tstate);
17819 if (PyErr_Occurred()) SWIG_fail;
17820 }
17821 {
17822 #if wxUSE_UNICODE
17823 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17824 #else
17825 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17826 #endif
17827 }
17828 return resultobj;
17829 fail:
17830 return NULL;
17831 }
17832
17833
17834 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17835 PyObject *resultobj = 0;
17836 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17837 wxString *result = 0 ;
17838 void *argp1 = 0 ;
17839 int res1 = 0 ;
17840 PyObject *swig_obj[1] ;
17841
17842 if (!args) SWIG_fail;
17843 swig_obj[0] = args;
17844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17845 if (!SWIG_IsOK(res1)) {
17846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17847 }
17848 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17849 {
17850 PyThreadState* __tstate = wxPyBeginAllowThreads();
17851 {
17852 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17853 result = (wxString *) &_result_ref;
17854 }
17855 wxPyEndAllowThreads(__tstate);
17856 if (PyErr_Occurred()) SWIG_fail;
17857 }
17858 {
17859 #if wxUSE_UNICODE
17860 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17861 #else
17862 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17863 #endif
17864 }
17865 return resultobj;
17866 fail:
17867 return NULL;
17868 }
17869
17870
17871 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17872 PyObject *resultobj = 0;
17873 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17874 wxString *result = 0 ;
17875 void *argp1 = 0 ;
17876 int res1 = 0 ;
17877 PyObject *swig_obj[1] ;
17878
17879 if (!args) SWIG_fail;
17880 swig_obj[0] = args;
17881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17882 if (!SWIG_IsOK(res1)) {
17883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17884 }
17885 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17886 {
17887 PyThreadState* __tstate = wxPyBeginAllowThreads();
17888 {
17889 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17890 result = (wxString *) &_result_ref;
17891 }
17892 wxPyEndAllowThreads(__tstate);
17893 if (PyErr_Occurred()) SWIG_fail;
17894 }
17895 {
17896 #if wxUSE_UNICODE
17897 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17898 #else
17899 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17900 #endif
17901 }
17902 return resultobj;
17903 fail:
17904 return NULL;
17905 }
17906
17907
17908 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17909 PyObject *resultobj = 0;
17910 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17911 wxString *result = 0 ;
17912 void *argp1 = 0 ;
17913 int res1 = 0 ;
17914 PyObject *swig_obj[1] ;
17915
17916 if (!args) SWIG_fail;
17917 swig_obj[0] = args;
17918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17919 if (!SWIG_IsOK(res1)) {
17920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17921 }
17922 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17923 {
17924 PyThreadState* __tstate = wxPyBeginAllowThreads();
17925 {
17926 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17927 result = (wxString *) &_result_ref;
17928 }
17929 wxPyEndAllowThreads(__tstate);
17930 if (PyErr_Occurred()) SWIG_fail;
17931 }
17932 {
17933 #if wxUSE_UNICODE
17934 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17935 #else
17936 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17937 #endif
17938 }
17939 return resultobj;
17940 fail:
17941 return NULL;
17942 }
17943
17944
17945 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17946 PyObject *resultobj = 0;
17947 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17948 wxArrayString *result = 0 ;
17949 void *argp1 = 0 ;
17950 int res1 = 0 ;
17951 PyObject *swig_obj[1] ;
17952
17953 if (!args) SWIG_fail;
17954 swig_obj[0] = args;
17955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17956 if (!SWIG_IsOK(res1)) {
17957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17958 }
17959 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17960 {
17961 PyThreadState* __tstate = wxPyBeginAllowThreads();
17962 {
17963 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17964 result = (wxArrayString *) &_result_ref;
17965 }
17966 wxPyEndAllowThreads(__tstate);
17967 if (PyErr_Occurred()) SWIG_fail;
17968 }
17969 {
17970 resultobj = wxArrayString2PyList_helper(*result);
17971 }
17972 return resultobj;
17973 fail:
17974 return NULL;
17975 }
17976
17977
17978 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17979 PyObject *resultobj = 0;
17980 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17981 size_t result;
17982 void *argp1 = 0 ;
17983 int res1 = 0 ;
17984 PyObject *swig_obj[1] ;
17985
17986 if (!args) SWIG_fail;
17987 swig_obj[0] = args;
17988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17989 if (!SWIG_IsOK(res1)) {
17990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17991 }
17992 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17993 {
17994 PyThreadState* __tstate = wxPyBeginAllowThreads();
17995 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17996 wxPyEndAllowThreads(__tstate);
17997 if (PyErr_Occurred()) SWIG_fail;
17998 }
17999 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
18000 return resultobj;
18001 fail:
18002 return NULL;
18003 }
18004
18005
18006 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18007 PyObject *resultobj = 0;
18008 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18009 wxString *result = 0 ;
18010 void *argp1 = 0 ;
18011 int res1 = 0 ;
18012 PyObject *swig_obj[1] ;
18013
18014 if (!args) SWIG_fail;
18015 swig_obj[0] = args;
18016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18017 if (!SWIG_IsOK(res1)) {
18018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18019 }
18020 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18021 {
18022 PyThreadState* __tstate = wxPyBeginAllowThreads();
18023 {
18024 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
18025 result = (wxString *) &_result_ref;
18026 }
18027 wxPyEndAllowThreads(__tstate);
18028 if (PyErr_Occurred()) SWIG_fail;
18029 }
18030 {
18031 #if wxUSE_UNICODE
18032 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18033 #else
18034 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18035 #endif
18036 }
18037 return resultobj;
18038 fail:
18039 return NULL;
18040 }
18041
18042
18043 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18044 PyObject *resultobj = 0;
18045 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18046 int result;
18047 void *argp1 = 0 ;
18048 int res1 = 0 ;
18049 PyObject *swig_obj[1] ;
18050
18051 if (!args) SWIG_fail;
18052 swig_obj[0] = args;
18053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18054 if (!SWIG_IsOK(res1)) {
18055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18056 }
18057 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18058 {
18059 PyThreadState* __tstate = wxPyBeginAllowThreads();
18060 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18061 wxPyEndAllowThreads(__tstate);
18062 if (PyErr_Occurred()) SWIG_fail;
18063 }
18064 resultobj = SWIG_From_int(static_cast< int >(result));
18065 return resultobj;
18066 fail:
18067 return NULL;
18068 }
18069
18070
18071 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18072 PyObject *obj;
18073 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18074 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18075 return SWIG_Py_Void();
18076 }
18077
18078 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18079 return SWIG_Python_InitShadowInstance(args);
18080 }
18081
18082 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18083 PyObject *resultobj = 0;
18084 wxFileTypeInfo *arg1 = 0 ;
18085 wxFileType *result = 0 ;
18086 void *argp1 = 0 ;
18087 int res1 = 0 ;
18088 PyObject * obj0 = 0 ;
18089 char * kwnames[] = {
18090 (char *) "ftInfo", NULL
18091 };
18092
18093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18094 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18095 if (!SWIG_IsOK(res1)) {
18096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18097 }
18098 if (!argp1) {
18099 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18100 }
18101 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18102 {
18103 PyThreadState* __tstate = wxPyBeginAllowThreads();
18104 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18105 wxPyEndAllowThreads(__tstate);
18106 if (PyErr_Occurred()) SWIG_fail;
18107 }
18108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18109 return resultobj;
18110 fail:
18111 return NULL;
18112 }
18113
18114
18115 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18116 PyObject *resultobj = 0;
18117 wxFileType *arg1 = (wxFileType *) 0 ;
18118 void *argp1 = 0 ;
18119 int res1 = 0 ;
18120 PyObject *swig_obj[1] ;
18121
18122 if (!args) SWIG_fail;
18123 swig_obj[0] = args;
18124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18125 if (!SWIG_IsOK(res1)) {
18126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18127 }
18128 arg1 = reinterpret_cast< wxFileType * >(argp1);
18129 {
18130 PyThreadState* __tstate = wxPyBeginAllowThreads();
18131 delete arg1;
18132
18133 wxPyEndAllowThreads(__tstate);
18134 if (PyErr_Occurred()) SWIG_fail;
18135 }
18136 resultobj = SWIG_Py_Void();
18137 return resultobj;
18138 fail:
18139 return NULL;
18140 }
18141
18142
18143 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18144 PyObject *resultobj = 0;
18145 wxFileType *arg1 = (wxFileType *) 0 ;
18146 PyObject *result = 0 ;
18147 void *argp1 = 0 ;
18148 int res1 = 0 ;
18149 PyObject *swig_obj[1] ;
18150
18151 if (!args) SWIG_fail;
18152 swig_obj[0] = args;
18153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18154 if (!SWIG_IsOK(res1)) {
18155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18156 }
18157 arg1 = reinterpret_cast< wxFileType * >(argp1);
18158 {
18159 PyThreadState* __tstate = wxPyBeginAllowThreads();
18160 result = (PyObject *)wxFileType_GetMimeType(arg1);
18161 wxPyEndAllowThreads(__tstate);
18162 if (PyErr_Occurred()) SWIG_fail;
18163 }
18164 resultobj = result;
18165 return resultobj;
18166 fail:
18167 return NULL;
18168 }
18169
18170
18171 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18172 PyObject *resultobj = 0;
18173 wxFileType *arg1 = (wxFileType *) 0 ;
18174 PyObject *result = 0 ;
18175 void *argp1 = 0 ;
18176 int res1 = 0 ;
18177 PyObject *swig_obj[1] ;
18178
18179 if (!args) SWIG_fail;
18180 swig_obj[0] = args;
18181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18182 if (!SWIG_IsOK(res1)) {
18183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18184 }
18185 arg1 = reinterpret_cast< wxFileType * >(argp1);
18186 {
18187 PyThreadState* __tstate = wxPyBeginAllowThreads();
18188 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18189 wxPyEndAllowThreads(__tstate);
18190 if (PyErr_Occurred()) SWIG_fail;
18191 }
18192 resultobj = result;
18193 return resultobj;
18194 fail:
18195 return NULL;
18196 }
18197
18198
18199 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18200 PyObject *resultobj = 0;
18201 wxFileType *arg1 = (wxFileType *) 0 ;
18202 PyObject *result = 0 ;
18203 void *argp1 = 0 ;
18204 int res1 = 0 ;
18205 PyObject *swig_obj[1] ;
18206
18207 if (!args) SWIG_fail;
18208 swig_obj[0] = args;
18209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18210 if (!SWIG_IsOK(res1)) {
18211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18212 }
18213 arg1 = reinterpret_cast< wxFileType * >(argp1);
18214 {
18215 PyThreadState* __tstate = wxPyBeginAllowThreads();
18216 result = (PyObject *)wxFileType_GetExtensions(arg1);
18217 wxPyEndAllowThreads(__tstate);
18218 if (PyErr_Occurred()) SWIG_fail;
18219 }
18220 resultobj = result;
18221 return resultobj;
18222 fail:
18223 return NULL;
18224 }
18225
18226
18227 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18228 PyObject *resultobj = 0;
18229 wxFileType *arg1 = (wxFileType *) 0 ;
18230 wxIcon *result = 0 ;
18231 void *argp1 = 0 ;
18232 int res1 = 0 ;
18233 PyObject *swig_obj[1] ;
18234
18235 if (!args) SWIG_fail;
18236 swig_obj[0] = args;
18237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18238 if (!SWIG_IsOK(res1)) {
18239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18240 }
18241 arg1 = reinterpret_cast< wxFileType * >(argp1);
18242 {
18243 PyThreadState* __tstate = wxPyBeginAllowThreads();
18244 result = (wxIcon *)wxFileType_GetIcon(arg1);
18245 wxPyEndAllowThreads(__tstate);
18246 if (PyErr_Occurred()) SWIG_fail;
18247 }
18248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18249 return resultobj;
18250 fail:
18251 return NULL;
18252 }
18253
18254
18255 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18256 PyObject *resultobj = 0;
18257 wxFileType *arg1 = (wxFileType *) 0 ;
18258 PyObject *result = 0 ;
18259 void *argp1 = 0 ;
18260 int res1 = 0 ;
18261 PyObject *swig_obj[1] ;
18262
18263 if (!args) SWIG_fail;
18264 swig_obj[0] = args;
18265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18266 if (!SWIG_IsOK(res1)) {
18267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18268 }
18269 arg1 = reinterpret_cast< wxFileType * >(argp1);
18270 {
18271 PyThreadState* __tstate = wxPyBeginAllowThreads();
18272 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18273 wxPyEndAllowThreads(__tstate);
18274 if (PyErr_Occurred()) SWIG_fail;
18275 }
18276 resultobj = result;
18277 return resultobj;
18278 fail:
18279 return NULL;
18280 }
18281
18282
18283 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18284 PyObject *resultobj = 0;
18285 wxFileType *arg1 = (wxFileType *) 0 ;
18286 PyObject *result = 0 ;
18287 void *argp1 = 0 ;
18288 int res1 = 0 ;
18289 PyObject *swig_obj[1] ;
18290
18291 if (!args) SWIG_fail;
18292 swig_obj[0] = args;
18293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18294 if (!SWIG_IsOK(res1)) {
18295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18296 }
18297 arg1 = reinterpret_cast< wxFileType * >(argp1);
18298 {
18299 PyThreadState* __tstate = wxPyBeginAllowThreads();
18300 result = (PyObject *)wxFileType_GetDescription(arg1);
18301 wxPyEndAllowThreads(__tstate);
18302 if (PyErr_Occurred()) SWIG_fail;
18303 }
18304 resultobj = result;
18305 return resultobj;
18306 fail:
18307 return NULL;
18308 }
18309
18310
18311 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18312 PyObject *resultobj = 0;
18313 wxFileType *arg1 = (wxFileType *) 0 ;
18314 wxString *arg2 = 0 ;
18315 wxString const &arg3_defvalue = wxPyEmptyString ;
18316 wxString *arg3 = (wxString *) &arg3_defvalue ;
18317 PyObject *result = 0 ;
18318 void *argp1 = 0 ;
18319 int res1 = 0 ;
18320 bool temp2 = false ;
18321 bool temp3 = false ;
18322 PyObject * obj0 = 0 ;
18323 PyObject * obj1 = 0 ;
18324 PyObject * obj2 = 0 ;
18325 char * kwnames[] = {
18326 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18327 };
18328
18329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18331 if (!SWIG_IsOK(res1)) {
18332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18333 }
18334 arg1 = reinterpret_cast< wxFileType * >(argp1);
18335 {
18336 arg2 = wxString_in_helper(obj1);
18337 if (arg2 == NULL) SWIG_fail;
18338 temp2 = true;
18339 }
18340 if (obj2) {
18341 {
18342 arg3 = wxString_in_helper(obj2);
18343 if (arg3 == NULL) SWIG_fail;
18344 temp3 = true;
18345 }
18346 }
18347 {
18348 PyThreadState* __tstate = wxPyBeginAllowThreads();
18349 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18350 wxPyEndAllowThreads(__tstate);
18351 if (PyErr_Occurred()) SWIG_fail;
18352 }
18353 resultobj = result;
18354 {
18355 if (temp2)
18356 delete arg2;
18357 }
18358 {
18359 if (temp3)
18360 delete arg3;
18361 }
18362 return resultobj;
18363 fail:
18364 {
18365 if (temp2)
18366 delete arg2;
18367 }
18368 {
18369 if (temp3)
18370 delete arg3;
18371 }
18372 return NULL;
18373 }
18374
18375
18376 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18377 PyObject *resultobj = 0;
18378 wxFileType *arg1 = (wxFileType *) 0 ;
18379 wxString *arg2 = 0 ;
18380 wxString const &arg3_defvalue = wxPyEmptyString ;
18381 wxString *arg3 = (wxString *) &arg3_defvalue ;
18382 PyObject *result = 0 ;
18383 void *argp1 = 0 ;
18384 int res1 = 0 ;
18385 bool temp2 = false ;
18386 bool temp3 = false ;
18387 PyObject * obj0 = 0 ;
18388 PyObject * obj1 = 0 ;
18389 PyObject * obj2 = 0 ;
18390 char * kwnames[] = {
18391 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18392 };
18393
18394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18396 if (!SWIG_IsOK(res1)) {
18397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18398 }
18399 arg1 = reinterpret_cast< wxFileType * >(argp1);
18400 {
18401 arg2 = wxString_in_helper(obj1);
18402 if (arg2 == NULL) SWIG_fail;
18403 temp2 = true;
18404 }
18405 if (obj2) {
18406 {
18407 arg3 = wxString_in_helper(obj2);
18408 if (arg3 == NULL) SWIG_fail;
18409 temp3 = true;
18410 }
18411 }
18412 {
18413 PyThreadState* __tstate = wxPyBeginAllowThreads();
18414 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18415 wxPyEndAllowThreads(__tstate);
18416 if (PyErr_Occurred()) SWIG_fail;
18417 }
18418 resultobj = result;
18419 {
18420 if (temp2)
18421 delete arg2;
18422 }
18423 {
18424 if (temp3)
18425 delete arg3;
18426 }
18427 return resultobj;
18428 fail:
18429 {
18430 if (temp2)
18431 delete arg2;
18432 }
18433 {
18434 if (temp3)
18435 delete arg3;
18436 }
18437 return NULL;
18438 }
18439
18440
18441 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18442 PyObject *resultobj = 0;
18443 wxFileType *arg1 = (wxFileType *) 0 ;
18444 wxString *arg2 = 0 ;
18445 wxString const &arg3_defvalue = wxPyEmptyString ;
18446 wxString *arg3 = (wxString *) &arg3_defvalue ;
18447 PyObject *result = 0 ;
18448 void *argp1 = 0 ;
18449 int res1 = 0 ;
18450 bool temp2 = false ;
18451 bool temp3 = false ;
18452 PyObject * obj0 = 0 ;
18453 PyObject * obj1 = 0 ;
18454 PyObject * obj2 = 0 ;
18455 char * kwnames[] = {
18456 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18457 };
18458
18459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18461 if (!SWIG_IsOK(res1)) {
18462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18463 }
18464 arg1 = reinterpret_cast< wxFileType * >(argp1);
18465 {
18466 arg2 = wxString_in_helper(obj1);
18467 if (arg2 == NULL) SWIG_fail;
18468 temp2 = true;
18469 }
18470 if (obj2) {
18471 {
18472 arg3 = wxString_in_helper(obj2);
18473 if (arg3 == NULL) SWIG_fail;
18474 temp3 = true;
18475 }
18476 }
18477 {
18478 PyThreadState* __tstate = wxPyBeginAllowThreads();
18479 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18480 wxPyEndAllowThreads(__tstate);
18481 if (PyErr_Occurred()) SWIG_fail;
18482 }
18483 resultobj = result;
18484 {
18485 if (temp2)
18486 delete arg2;
18487 }
18488 {
18489 if (temp3)
18490 delete arg3;
18491 }
18492 return resultobj;
18493 fail:
18494 {
18495 if (temp2)
18496 delete arg2;
18497 }
18498 {
18499 if (temp3)
18500 delete arg3;
18501 }
18502 return NULL;
18503 }
18504
18505
18506 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18507 PyObject *resultobj = 0;
18508 wxFileType *arg1 = (wxFileType *) 0 ;
18509 wxString *arg2 = 0 ;
18510 wxString *arg3 = 0 ;
18511 bool arg4 = (bool) true ;
18512 bool result;
18513 void *argp1 = 0 ;
18514 int res1 = 0 ;
18515 bool temp2 = false ;
18516 bool temp3 = false ;
18517 bool val4 ;
18518 int ecode4 = 0 ;
18519 PyObject * obj0 = 0 ;
18520 PyObject * obj1 = 0 ;
18521 PyObject * obj2 = 0 ;
18522 PyObject * obj3 = 0 ;
18523 char * kwnames[] = {
18524 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18525 };
18526
18527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18529 if (!SWIG_IsOK(res1)) {
18530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18531 }
18532 arg1 = reinterpret_cast< wxFileType * >(argp1);
18533 {
18534 arg2 = wxString_in_helper(obj1);
18535 if (arg2 == NULL) SWIG_fail;
18536 temp2 = true;
18537 }
18538 {
18539 arg3 = wxString_in_helper(obj2);
18540 if (arg3 == NULL) SWIG_fail;
18541 temp3 = true;
18542 }
18543 if (obj3) {
18544 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18545 if (!SWIG_IsOK(ecode4)) {
18546 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18547 }
18548 arg4 = static_cast< bool >(val4);
18549 }
18550 {
18551 PyThreadState* __tstate = wxPyBeginAllowThreads();
18552 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18553 wxPyEndAllowThreads(__tstate);
18554 if (PyErr_Occurred()) SWIG_fail;
18555 }
18556 {
18557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18558 }
18559 {
18560 if (temp2)
18561 delete arg2;
18562 }
18563 {
18564 if (temp3)
18565 delete arg3;
18566 }
18567 return resultobj;
18568 fail:
18569 {
18570 if (temp2)
18571 delete arg2;
18572 }
18573 {
18574 if (temp3)
18575 delete arg3;
18576 }
18577 return NULL;
18578 }
18579
18580
18581 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18582 PyObject *resultobj = 0;
18583 wxFileType *arg1 = (wxFileType *) 0 ;
18584 wxString const &arg2_defvalue = wxPyEmptyString ;
18585 wxString *arg2 = (wxString *) &arg2_defvalue ;
18586 int arg3 = (int) 0 ;
18587 bool result;
18588 void *argp1 = 0 ;
18589 int res1 = 0 ;
18590 bool temp2 = false ;
18591 int val3 ;
18592 int ecode3 = 0 ;
18593 PyObject * obj0 = 0 ;
18594 PyObject * obj1 = 0 ;
18595 PyObject * obj2 = 0 ;
18596 char * kwnames[] = {
18597 (char *) "self",(char *) "cmd",(char *) "index", NULL
18598 };
18599
18600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18602 if (!SWIG_IsOK(res1)) {
18603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18604 }
18605 arg1 = reinterpret_cast< wxFileType * >(argp1);
18606 if (obj1) {
18607 {
18608 arg2 = wxString_in_helper(obj1);
18609 if (arg2 == NULL) SWIG_fail;
18610 temp2 = true;
18611 }
18612 }
18613 if (obj2) {
18614 ecode3 = SWIG_AsVal_int(obj2, &val3);
18615 if (!SWIG_IsOK(ecode3)) {
18616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18617 }
18618 arg3 = static_cast< int >(val3);
18619 }
18620 {
18621 PyThreadState* __tstate = wxPyBeginAllowThreads();
18622 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18623 wxPyEndAllowThreads(__tstate);
18624 if (PyErr_Occurred()) SWIG_fail;
18625 }
18626 {
18627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18628 }
18629 {
18630 if (temp2)
18631 delete arg2;
18632 }
18633 return resultobj;
18634 fail:
18635 {
18636 if (temp2)
18637 delete arg2;
18638 }
18639 return NULL;
18640 }
18641
18642
18643 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18644 PyObject *resultobj = 0;
18645 wxFileType *arg1 = (wxFileType *) 0 ;
18646 bool result;
18647 void *argp1 = 0 ;
18648 int res1 = 0 ;
18649 PyObject *swig_obj[1] ;
18650
18651 if (!args) SWIG_fail;
18652 swig_obj[0] = args;
18653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18654 if (!SWIG_IsOK(res1)) {
18655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18656 }
18657 arg1 = reinterpret_cast< wxFileType * >(argp1);
18658 {
18659 PyThreadState* __tstate = wxPyBeginAllowThreads();
18660 result = (bool)(arg1)->Unassociate();
18661 wxPyEndAllowThreads(__tstate);
18662 if (PyErr_Occurred()) SWIG_fail;
18663 }
18664 {
18665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18666 }
18667 return resultobj;
18668 fail:
18669 return NULL;
18670 }
18671
18672
18673 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18674 PyObject *resultobj = 0;
18675 wxString *arg1 = 0 ;
18676 wxString *arg2 = 0 ;
18677 wxString const &arg3_defvalue = wxPyEmptyString ;
18678 wxString *arg3 = (wxString *) &arg3_defvalue ;
18679 wxString result;
18680 bool temp1 = false ;
18681 bool temp2 = false ;
18682 bool temp3 = false ;
18683 PyObject * obj0 = 0 ;
18684 PyObject * obj1 = 0 ;
18685 PyObject * obj2 = 0 ;
18686 char * kwnames[] = {
18687 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18688 };
18689
18690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18691 {
18692 arg1 = wxString_in_helper(obj0);
18693 if (arg1 == NULL) SWIG_fail;
18694 temp1 = true;
18695 }
18696 {
18697 arg2 = wxString_in_helper(obj1);
18698 if (arg2 == NULL) SWIG_fail;
18699 temp2 = true;
18700 }
18701 if (obj2) {
18702 {
18703 arg3 = wxString_in_helper(obj2);
18704 if (arg3 == NULL) SWIG_fail;
18705 temp3 = true;
18706 }
18707 }
18708 {
18709 PyThreadState* __tstate = wxPyBeginAllowThreads();
18710 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18711 wxPyEndAllowThreads(__tstate);
18712 if (PyErr_Occurred()) SWIG_fail;
18713 }
18714 {
18715 #if wxUSE_UNICODE
18716 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18717 #else
18718 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18719 #endif
18720 }
18721 {
18722 if (temp1)
18723 delete arg1;
18724 }
18725 {
18726 if (temp2)
18727 delete arg2;
18728 }
18729 {
18730 if (temp3)
18731 delete arg3;
18732 }
18733 return resultobj;
18734 fail:
18735 {
18736 if (temp1)
18737 delete arg1;
18738 }
18739 {
18740 if (temp2)
18741 delete arg2;
18742 }
18743 {
18744 if (temp3)
18745 delete arg3;
18746 }
18747 return NULL;
18748 }
18749
18750
18751 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18752 PyObject *obj;
18753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18754 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18755 return SWIG_Py_Void();
18756 }
18757
18758 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18759 return SWIG_Python_InitShadowInstance(args);
18760 }
18761
18762 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18763 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18764 return 1;
18765 }
18766
18767
18768 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18769 PyObject *pyobj = 0;
18770
18771 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18772 return pyobj;
18773 }
18774
18775
18776 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18777 PyObject *resultobj = 0;
18778 wxString *arg1 = 0 ;
18779 wxString *arg2 = 0 ;
18780 bool result;
18781 bool temp1 = false ;
18782 bool temp2 = false ;
18783 PyObject * obj0 = 0 ;
18784 PyObject * obj1 = 0 ;
18785 char * kwnames[] = {
18786 (char *) "mimeType",(char *) "wildcard", NULL
18787 };
18788
18789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18790 {
18791 arg1 = wxString_in_helper(obj0);
18792 if (arg1 == NULL) SWIG_fail;
18793 temp1 = true;
18794 }
18795 {
18796 arg2 = wxString_in_helper(obj1);
18797 if (arg2 == NULL) SWIG_fail;
18798 temp2 = true;
18799 }
18800 {
18801 PyThreadState* __tstate = wxPyBeginAllowThreads();
18802 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18803 wxPyEndAllowThreads(__tstate);
18804 if (PyErr_Occurred()) SWIG_fail;
18805 }
18806 {
18807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18808 }
18809 {
18810 if (temp1)
18811 delete arg1;
18812 }
18813 {
18814 if (temp2)
18815 delete arg2;
18816 }
18817 return resultobj;
18818 fail:
18819 {
18820 if (temp1)
18821 delete arg1;
18822 }
18823 {
18824 if (temp2)
18825 delete arg2;
18826 }
18827 return NULL;
18828 }
18829
18830
18831 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18832 PyObject *resultobj = 0;
18833 wxMimeTypesManager *result = 0 ;
18834
18835 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18836 {
18837 PyThreadState* __tstate = wxPyBeginAllowThreads();
18838 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18839 wxPyEndAllowThreads(__tstate);
18840 if (PyErr_Occurred()) SWIG_fail;
18841 }
18842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18843 return resultobj;
18844 fail:
18845 return NULL;
18846 }
18847
18848
18849 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18850 PyObject *resultobj = 0;
18851 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18852 int arg2 = (int) wxMAILCAP_ALL ;
18853 wxString const &arg3_defvalue = wxPyEmptyString ;
18854 wxString *arg3 = (wxString *) &arg3_defvalue ;
18855 void *argp1 = 0 ;
18856 int res1 = 0 ;
18857 int val2 ;
18858 int ecode2 = 0 ;
18859 bool temp3 = false ;
18860 PyObject * obj0 = 0 ;
18861 PyObject * obj1 = 0 ;
18862 PyObject * obj2 = 0 ;
18863 char * kwnames[] = {
18864 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18865 };
18866
18867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18869 if (!SWIG_IsOK(res1)) {
18870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18871 }
18872 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18873 if (obj1) {
18874 ecode2 = SWIG_AsVal_int(obj1, &val2);
18875 if (!SWIG_IsOK(ecode2)) {
18876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18877 }
18878 arg2 = static_cast< int >(val2);
18879 }
18880 if (obj2) {
18881 {
18882 arg3 = wxString_in_helper(obj2);
18883 if (arg3 == NULL) SWIG_fail;
18884 temp3 = true;
18885 }
18886 }
18887 {
18888 PyThreadState* __tstate = wxPyBeginAllowThreads();
18889 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18890 wxPyEndAllowThreads(__tstate);
18891 if (PyErr_Occurred()) SWIG_fail;
18892 }
18893 resultobj = SWIG_Py_Void();
18894 {
18895 if (temp3)
18896 delete arg3;
18897 }
18898 return resultobj;
18899 fail:
18900 {
18901 if (temp3)
18902 delete arg3;
18903 }
18904 return NULL;
18905 }
18906
18907
18908 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18909 PyObject *resultobj = 0;
18910 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18911 void *argp1 = 0 ;
18912 int res1 = 0 ;
18913 PyObject *swig_obj[1] ;
18914
18915 if (!args) SWIG_fail;
18916 swig_obj[0] = args;
18917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18918 if (!SWIG_IsOK(res1)) {
18919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18920 }
18921 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18922 {
18923 PyThreadState* __tstate = wxPyBeginAllowThreads();
18924 (arg1)->ClearData();
18925 wxPyEndAllowThreads(__tstate);
18926 if (PyErr_Occurred()) SWIG_fail;
18927 }
18928 resultobj = SWIG_Py_Void();
18929 return resultobj;
18930 fail:
18931 return NULL;
18932 }
18933
18934
18935 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18936 PyObject *resultobj = 0;
18937 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18938 wxString *arg2 = 0 ;
18939 wxFileType *result = 0 ;
18940 void *argp1 = 0 ;
18941 int res1 = 0 ;
18942 bool temp2 = false ;
18943 PyObject * obj0 = 0 ;
18944 PyObject * obj1 = 0 ;
18945 char * kwnames[] = {
18946 (char *) "self",(char *) "ext", NULL
18947 };
18948
18949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) 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_GetFileTypeFromExtension" "', 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 {
18961 PyThreadState* __tstate = wxPyBeginAllowThreads();
18962 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18963 wxPyEndAllowThreads(__tstate);
18964 if (PyErr_Occurred()) SWIG_fail;
18965 }
18966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18967 {
18968 if (temp2)
18969 delete arg2;
18970 }
18971 return resultobj;
18972 fail:
18973 {
18974 if (temp2)
18975 delete arg2;
18976 }
18977 return NULL;
18978 }
18979
18980
18981 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18982 PyObject *resultobj = 0;
18983 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18984 wxString *arg2 = 0 ;
18985 wxFileType *result = 0 ;
18986 void *argp1 = 0 ;
18987 int res1 = 0 ;
18988 bool temp2 = false ;
18989 PyObject * obj0 = 0 ;
18990 PyObject * obj1 = 0 ;
18991 char * kwnames[] = {
18992 (char *) "self",(char *) "mimeType", NULL
18993 };
18994
18995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18997 if (!SWIG_IsOK(res1)) {
18998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18999 }
19000 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19001 {
19002 arg2 = wxString_in_helper(obj1);
19003 if (arg2 == NULL) SWIG_fail;
19004 temp2 = true;
19005 }
19006 {
19007 PyThreadState* __tstate = wxPyBeginAllowThreads();
19008 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
19009 wxPyEndAllowThreads(__tstate);
19010 if (PyErr_Occurred()) SWIG_fail;
19011 }
19012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19013 {
19014 if (temp2)
19015 delete arg2;
19016 }
19017 return resultobj;
19018 fail:
19019 {
19020 if (temp2)
19021 delete arg2;
19022 }
19023 return NULL;
19024 }
19025
19026
19027 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19028 PyObject *resultobj = 0;
19029 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19030 wxString *arg2 = 0 ;
19031 bool arg3 = (bool) false ;
19032 bool result;
19033 void *argp1 = 0 ;
19034 int res1 = 0 ;
19035 bool temp2 = false ;
19036 bool val3 ;
19037 int ecode3 = 0 ;
19038 PyObject * obj0 = 0 ;
19039 PyObject * obj1 = 0 ;
19040 PyObject * obj2 = 0 ;
19041 char * kwnames[] = {
19042 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19043 };
19044
19045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19047 if (!SWIG_IsOK(res1)) {
19048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19049 }
19050 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19051 {
19052 arg2 = wxString_in_helper(obj1);
19053 if (arg2 == NULL) SWIG_fail;
19054 temp2 = true;
19055 }
19056 if (obj2) {
19057 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19058 if (!SWIG_IsOK(ecode3)) {
19059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19060 }
19061 arg3 = static_cast< bool >(val3);
19062 }
19063 {
19064 PyThreadState* __tstate = wxPyBeginAllowThreads();
19065 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19066 wxPyEndAllowThreads(__tstate);
19067 if (PyErr_Occurred()) SWIG_fail;
19068 }
19069 {
19070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19071 }
19072 {
19073 if (temp2)
19074 delete arg2;
19075 }
19076 return resultobj;
19077 fail:
19078 {
19079 if (temp2)
19080 delete arg2;
19081 }
19082 return NULL;
19083 }
19084
19085
19086 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19087 PyObject *resultobj = 0;
19088 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19089 wxString *arg2 = 0 ;
19090 bool result;
19091 void *argp1 = 0 ;
19092 int res1 = 0 ;
19093 bool temp2 = false ;
19094 PyObject * obj0 = 0 ;
19095 PyObject * obj1 = 0 ;
19096 char * kwnames[] = {
19097 (char *) "self",(char *) "filename", NULL
19098 };
19099
19100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19102 if (!SWIG_IsOK(res1)) {
19103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19104 }
19105 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19106 {
19107 arg2 = wxString_in_helper(obj1);
19108 if (arg2 == NULL) SWIG_fail;
19109 temp2 = true;
19110 }
19111 {
19112 PyThreadState* __tstate = wxPyBeginAllowThreads();
19113 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19114 wxPyEndAllowThreads(__tstate);
19115 if (PyErr_Occurred()) SWIG_fail;
19116 }
19117 {
19118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19119 }
19120 {
19121 if (temp2)
19122 delete arg2;
19123 }
19124 return resultobj;
19125 fail:
19126 {
19127 if (temp2)
19128 delete arg2;
19129 }
19130 return NULL;
19131 }
19132
19133
19134 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19135 PyObject *resultobj = 0;
19136 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19137 PyObject *result = 0 ;
19138 void *argp1 = 0 ;
19139 int res1 = 0 ;
19140 PyObject *swig_obj[1] ;
19141
19142 if (!args) SWIG_fail;
19143 swig_obj[0] = args;
19144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19145 if (!SWIG_IsOK(res1)) {
19146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19147 }
19148 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19149 {
19150 PyThreadState* __tstate = wxPyBeginAllowThreads();
19151 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19152 wxPyEndAllowThreads(__tstate);
19153 if (PyErr_Occurred()) SWIG_fail;
19154 }
19155 resultobj = result;
19156 return resultobj;
19157 fail:
19158 return NULL;
19159 }
19160
19161
19162 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19163 PyObject *resultobj = 0;
19164 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19165 wxFileTypeInfo *arg2 = 0 ;
19166 void *argp1 = 0 ;
19167 int res1 = 0 ;
19168 void *argp2 = 0 ;
19169 int res2 = 0 ;
19170 PyObject * obj0 = 0 ;
19171 PyObject * obj1 = 0 ;
19172 char * kwnames[] = {
19173 (char *) "self",(char *) "ft", NULL
19174 };
19175
19176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19178 if (!SWIG_IsOK(res1)) {
19179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19180 }
19181 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19182 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19183 if (!SWIG_IsOK(res2)) {
19184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19185 }
19186 if (!argp2) {
19187 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19188 }
19189 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19190 {
19191 PyThreadState* __tstate = wxPyBeginAllowThreads();
19192 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19193 wxPyEndAllowThreads(__tstate);
19194 if (PyErr_Occurred()) SWIG_fail;
19195 }
19196 resultobj = SWIG_Py_Void();
19197 return resultobj;
19198 fail:
19199 return NULL;
19200 }
19201
19202
19203 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19204 PyObject *resultobj = 0;
19205 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19206 wxFileTypeInfo *arg2 = 0 ;
19207 wxFileType *result = 0 ;
19208 void *argp1 = 0 ;
19209 int res1 = 0 ;
19210 void *argp2 = 0 ;
19211 int res2 = 0 ;
19212 PyObject * obj0 = 0 ;
19213 PyObject * obj1 = 0 ;
19214 char * kwnames[] = {
19215 (char *) "self",(char *) "ftInfo", NULL
19216 };
19217
19218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19220 if (!SWIG_IsOK(res1)) {
19221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19222 }
19223 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19224 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19225 if (!SWIG_IsOK(res2)) {
19226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19227 }
19228 if (!argp2) {
19229 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19230 }
19231 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19232 {
19233 PyThreadState* __tstate = wxPyBeginAllowThreads();
19234 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19235 wxPyEndAllowThreads(__tstate);
19236 if (PyErr_Occurred()) SWIG_fail;
19237 }
19238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19239 return resultobj;
19240 fail:
19241 return NULL;
19242 }
19243
19244
19245 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19246 PyObject *resultobj = 0;
19247 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19248 wxFileType *arg2 = (wxFileType *) 0 ;
19249 bool result;
19250 void *argp1 = 0 ;
19251 int res1 = 0 ;
19252 void *argp2 = 0 ;
19253 int res2 = 0 ;
19254 PyObject * obj0 = 0 ;
19255 PyObject * obj1 = 0 ;
19256 char * kwnames[] = {
19257 (char *) "self",(char *) "ft", NULL
19258 };
19259
19260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19262 if (!SWIG_IsOK(res1)) {
19263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19264 }
19265 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19266 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19267 if (!SWIG_IsOK(res2)) {
19268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19269 }
19270 arg2 = reinterpret_cast< wxFileType * >(argp2);
19271 {
19272 PyThreadState* __tstate = wxPyBeginAllowThreads();
19273 result = (bool)(arg1)->Unassociate(arg2);
19274 wxPyEndAllowThreads(__tstate);
19275 if (PyErr_Occurred()) SWIG_fail;
19276 }
19277 {
19278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19279 }
19280 return resultobj;
19281 fail:
19282 return NULL;
19283 }
19284
19285
19286 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19287 PyObject *resultobj = 0;
19288 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19289 void *argp1 = 0 ;
19290 int res1 = 0 ;
19291 PyObject *swig_obj[1] ;
19292
19293 if (!args) SWIG_fail;
19294 swig_obj[0] = args;
19295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19296 if (!SWIG_IsOK(res1)) {
19297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19298 }
19299 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19300 {
19301 PyThreadState* __tstate = wxPyBeginAllowThreads();
19302 delete arg1;
19303
19304 wxPyEndAllowThreads(__tstate);
19305 if (PyErr_Occurred()) SWIG_fail;
19306 }
19307 resultobj = SWIG_Py_Void();
19308 return resultobj;
19309 fail:
19310 return NULL;
19311 }
19312
19313
19314 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19315 PyObject *obj;
19316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19317 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19318 return SWIG_Py_Void();
19319 }
19320
19321 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19322 return SWIG_Python_InitShadowInstance(args);
19323 }
19324
19325 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19326 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19327 return 1;
19328 }
19329
19330
19331 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19332 PyObject *pyobj = 0;
19333
19334 {
19335 #if wxUSE_UNICODE
19336 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19337 #else
19338 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19339 #endif
19340 }
19341 return pyobj;
19342 }
19343
19344
19345 SWIGINTERN int ART_MENU_set(PyObject *) {
19346 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19347 return 1;
19348 }
19349
19350
19351 SWIGINTERN PyObject *ART_MENU_get(void) {
19352 PyObject *pyobj = 0;
19353
19354 {
19355 #if wxUSE_UNICODE
19356 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19357 #else
19358 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19359 #endif
19360 }
19361 return pyobj;
19362 }
19363
19364
19365 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19366 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19367 return 1;
19368 }
19369
19370
19371 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19372 PyObject *pyobj = 0;
19373
19374 {
19375 #if wxUSE_UNICODE
19376 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19377 #else
19378 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19379 #endif
19380 }
19381 return pyobj;
19382 }
19383
19384
19385 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19386 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19387 return 1;
19388 }
19389
19390
19391 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19392 PyObject *pyobj = 0;
19393
19394 {
19395 #if wxUSE_UNICODE
19396 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19397 #else
19398 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19399 #endif
19400 }
19401 return pyobj;
19402 }
19403
19404
19405 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19406 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19407 return 1;
19408 }
19409
19410
19411 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19412 PyObject *pyobj = 0;
19413
19414 {
19415 #if wxUSE_UNICODE
19416 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19417 #else
19418 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19419 #endif
19420 }
19421 return pyobj;
19422 }
19423
19424
19425 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19426 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19427 return 1;
19428 }
19429
19430
19431 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19432 PyObject *pyobj = 0;
19433
19434 {
19435 #if wxUSE_UNICODE
19436 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19437 #else
19438 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19439 #endif
19440 }
19441 return pyobj;
19442 }
19443
19444
19445 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19446 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19447 return 1;
19448 }
19449
19450
19451 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19452 PyObject *pyobj = 0;
19453
19454 {
19455 #if wxUSE_UNICODE
19456 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19457 #else
19458 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19459 #endif
19460 }
19461 return pyobj;
19462 }
19463
19464
19465 SWIGINTERN int ART_OTHER_set(PyObject *) {
19466 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19467 return 1;
19468 }
19469
19470
19471 SWIGINTERN PyObject *ART_OTHER_get(void) {
19472 PyObject *pyobj = 0;
19473
19474 {
19475 #if wxUSE_UNICODE
19476 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19477 #else
19478 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19479 #endif
19480 }
19481 return pyobj;
19482 }
19483
19484
19485 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19486 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19487 return 1;
19488 }
19489
19490
19491 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19492 PyObject *pyobj = 0;
19493
19494 {
19495 #if wxUSE_UNICODE
19496 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19497 #else
19498 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19499 #endif
19500 }
19501 return pyobj;
19502 }
19503
19504
19505 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19506 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19507 return 1;
19508 }
19509
19510
19511 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19512 PyObject *pyobj = 0;
19513
19514 {
19515 #if wxUSE_UNICODE
19516 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19517 #else
19518 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19519 #endif
19520 }
19521 return pyobj;
19522 }
19523
19524
19525 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19526 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19527 return 1;
19528 }
19529
19530
19531 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19532 PyObject *pyobj = 0;
19533
19534 {
19535 #if wxUSE_UNICODE
19536 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19537 #else
19538 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19539 #endif
19540 }
19541 return pyobj;
19542 }
19543
19544
19545 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19546 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19547 return 1;
19548 }
19549
19550
19551 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19552 PyObject *pyobj = 0;
19553
19554 {
19555 #if wxUSE_UNICODE
19556 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19557 #else
19558 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19559 #endif
19560 }
19561 return pyobj;
19562 }
19563
19564
19565 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19566 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19567 return 1;
19568 }
19569
19570
19571 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19572 PyObject *pyobj = 0;
19573
19574 {
19575 #if wxUSE_UNICODE
19576 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19577 #else
19578 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19579 #endif
19580 }
19581 return pyobj;
19582 }
19583
19584
19585 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19586 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19587 return 1;
19588 }
19589
19590
19591 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19592 PyObject *pyobj = 0;
19593
19594 {
19595 #if wxUSE_UNICODE
19596 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19597 #else
19598 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19599 #endif
19600 }
19601 return pyobj;
19602 }
19603
19604
19605 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19606 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19607 return 1;
19608 }
19609
19610
19611 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19612 PyObject *pyobj = 0;
19613
19614 {
19615 #if wxUSE_UNICODE
19616 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19617 #else
19618 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19619 #endif
19620 }
19621 return pyobj;
19622 }
19623
19624
19625 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19626 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19627 return 1;
19628 }
19629
19630
19631 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19632 PyObject *pyobj = 0;
19633
19634 {
19635 #if wxUSE_UNICODE
19636 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19637 #else
19638 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19639 #endif
19640 }
19641 return pyobj;
19642 }
19643
19644
19645 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19646 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19647 return 1;
19648 }
19649
19650
19651 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19652 PyObject *pyobj = 0;
19653
19654 {
19655 #if wxUSE_UNICODE
19656 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19657 #else
19658 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19659 #endif
19660 }
19661 return pyobj;
19662 }
19663
19664
19665 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19666 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19667 return 1;
19668 }
19669
19670
19671 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19672 PyObject *pyobj = 0;
19673
19674 {
19675 #if wxUSE_UNICODE
19676 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19677 #else
19678 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19679 #endif
19680 }
19681 return pyobj;
19682 }
19683
19684
19685 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19686 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19687 return 1;
19688 }
19689
19690
19691 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19692 PyObject *pyobj = 0;
19693
19694 {
19695 #if wxUSE_UNICODE
19696 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19697 #else
19698 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19699 #endif
19700 }
19701 return pyobj;
19702 }
19703
19704
19705 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19706 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19707 return 1;
19708 }
19709
19710
19711 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19712 PyObject *pyobj = 0;
19713
19714 {
19715 #if wxUSE_UNICODE
19716 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19717 #else
19718 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19719 #endif
19720 }
19721 return pyobj;
19722 }
19723
19724
19725 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19726 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19727 return 1;
19728 }
19729
19730
19731 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19732 PyObject *pyobj = 0;
19733
19734 {
19735 #if wxUSE_UNICODE
19736 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19737 #else
19738 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19739 #endif
19740 }
19741 return pyobj;
19742 }
19743
19744
19745 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19746 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19747 return 1;
19748 }
19749
19750
19751 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19752 PyObject *pyobj = 0;
19753
19754 {
19755 #if wxUSE_UNICODE
19756 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19757 #else
19758 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19759 #endif
19760 }
19761 return pyobj;
19762 }
19763
19764
19765 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19766 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19767 return 1;
19768 }
19769
19770
19771 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19772 PyObject *pyobj = 0;
19773
19774 {
19775 #if wxUSE_UNICODE
19776 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19777 #else
19778 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19779 #endif
19780 }
19781 return pyobj;
19782 }
19783
19784
19785 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19786 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19787 return 1;
19788 }
19789
19790
19791 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19792 PyObject *pyobj = 0;
19793
19794 {
19795 #if wxUSE_UNICODE
19796 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19797 #else
19798 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19799 #endif
19800 }
19801 return pyobj;
19802 }
19803
19804
19805 SWIGINTERN int ART_PRINT_set(PyObject *) {
19806 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19807 return 1;
19808 }
19809
19810
19811 SWIGINTERN PyObject *ART_PRINT_get(void) {
19812 PyObject *pyobj = 0;
19813
19814 {
19815 #if wxUSE_UNICODE
19816 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19817 #else
19818 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19819 #endif
19820 }
19821 return pyobj;
19822 }
19823
19824
19825 SWIGINTERN int ART_HELP_set(PyObject *) {
19826 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19827 return 1;
19828 }
19829
19830
19831 SWIGINTERN PyObject *ART_HELP_get(void) {
19832 PyObject *pyobj = 0;
19833
19834 {
19835 #if wxUSE_UNICODE
19836 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19837 #else
19838 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19839 #endif
19840 }
19841 return pyobj;
19842 }
19843
19844
19845 SWIGINTERN int ART_TIP_set(PyObject *) {
19846 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19847 return 1;
19848 }
19849
19850
19851 SWIGINTERN PyObject *ART_TIP_get(void) {
19852 PyObject *pyobj = 0;
19853
19854 {
19855 #if wxUSE_UNICODE
19856 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19857 #else
19858 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19859 #endif
19860 }
19861 return pyobj;
19862 }
19863
19864
19865 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19866 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19867 return 1;
19868 }
19869
19870
19871 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19872 PyObject *pyobj = 0;
19873
19874 {
19875 #if wxUSE_UNICODE
19876 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19877 #else
19878 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19879 #endif
19880 }
19881 return pyobj;
19882 }
19883
19884
19885 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19886 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19887 return 1;
19888 }
19889
19890
19891 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19892 PyObject *pyobj = 0;
19893
19894 {
19895 #if wxUSE_UNICODE
19896 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19897 #else
19898 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19899 #endif
19900 }
19901 return pyobj;
19902 }
19903
19904
19905 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19906 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19907 return 1;
19908 }
19909
19910
19911 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19912 PyObject *pyobj = 0;
19913
19914 {
19915 #if wxUSE_UNICODE
19916 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19917 #else
19918 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19919 #endif
19920 }
19921 return pyobj;
19922 }
19923
19924
19925 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19926 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19927 return 1;
19928 }
19929
19930
19931 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19932 PyObject *pyobj = 0;
19933
19934 {
19935 #if wxUSE_UNICODE
19936 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19937 #else
19938 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19939 #endif
19940 }
19941 return pyobj;
19942 }
19943
19944
19945 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19946 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19947 return 1;
19948 }
19949
19950
19951 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19952 PyObject *pyobj = 0;
19953
19954 {
19955 #if wxUSE_UNICODE
19956 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19957 #else
19958 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19959 #endif
19960 }
19961 return pyobj;
19962 }
19963
19964
19965 SWIGINTERN int ART_CDROM_set(PyObject *) {
19966 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19967 return 1;
19968 }
19969
19970
19971 SWIGINTERN PyObject *ART_CDROM_get(void) {
19972 PyObject *pyobj = 0;
19973
19974 {
19975 #if wxUSE_UNICODE
19976 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19977 #else
19978 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19979 #endif
19980 }
19981 return pyobj;
19982 }
19983
19984
19985 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19986 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19987 return 1;
19988 }
19989
19990
19991 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19992 PyObject *pyobj = 0;
19993
19994 {
19995 #if wxUSE_UNICODE
19996 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19997 #else
19998 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19999 #endif
20000 }
20001 return pyobj;
20002 }
20003
20004
20005 SWIGINTERN int ART_FOLDER_set(PyObject *) {
20006 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
20007 return 1;
20008 }
20009
20010
20011 SWIGINTERN PyObject *ART_FOLDER_get(void) {
20012 PyObject *pyobj = 0;
20013
20014 {
20015 #if wxUSE_UNICODE
20016 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20017 #else
20018 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20019 #endif
20020 }
20021 return pyobj;
20022 }
20023
20024
20025 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
20026 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
20027 return 1;
20028 }
20029
20030
20031 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
20032 PyObject *pyobj = 0;
20033
20034 {
20035 #if wxUSE_UNICODE
20036 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20037 #else
20038 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20039 #endif
20040 }
20041 return pyobj;
20042 }
20043
20044
20045 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20046 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20047 return 1;
20048 }
20049
20050
20051 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20052 PyObject *pyobj = 0;
20053
20054 {
20055 #if wxUSE_UNICODE
20056 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20057 #else
20058 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20059 #endif
20060 }
20061 return pyobj;
20062 }
20063
20064
20065 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20066 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20067 return 1;
20068 }
20069
20070
20071 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20072 PyObject *pyobj = 0;
20073
20074 {
20075 #if wxUSE_UNICODE
20076 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20077 #else
20078 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20079 #endif
20080 }
20081 return pyobj;
20082 }
20083
20084
20085 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20086 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20087 return 1;
20088 }
20089
20090
20091 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20092 PyObject *pyobj = 0;
20093
20094 {
20095 #if wxUSE_UNICODE
20096 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20097 #else
20098 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20099 #endif
20100 }
20101 return pyobj;
20102 }
20103
20104
20105 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20106 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20107 return 1;
20108 }
20109
20110
20111 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20112 PyObject *pyobj = 0;
20113
20114 {
20115 #if wxUSE_UNICODE
20116 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20117 #else
20118 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20119 #endif
20120 }
20121 return pyobj;
20122 }
20123
20124
20125 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20126 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20127 return 1;
20128 }
20129
20130
20131 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20132 PyObject *pyobj = 0;
20133
20134 {
20135 #if wxUSE_UNICODE
20136 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20137 #else
20138 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20139 #endif
20140 }
20141 return pyobj;
20142 }
20143
20144
20145 SWIGINTERN int ART_ERROR_set(PyObject *) {
20146 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20147 return 1;
20148 }
20149
20150
20151 SWIGINTERN PyObject *ART_ERROR_get(void) {
20152 PyObject *pyobj = 0;
20153
20154 {
20155 #if wxUSE_UNICODE
20156 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20157 #else
20158 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20159 #endif
20160 }
20161 return pyobj;
20162 }
20163
20164
20165 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20166 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20167 return 1;
20168 }
20169
20170
20171 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20172 PyObject *pyobj = 0;
20173
20174 {
20175 #if wxUSE_UNICODE
20176 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20177 #else
20178 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20179 #endif
20180 }
20181 return pyobj;
20182 }
20183
20184
20185 SWIGINTERN int ART_WARNING_set(PyObject *) {
20186 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20187 return 1;
20188 }
20189
20190
20191 SWIGINTERN PyObject *ART_WARNING_get(void) {
20192 PyObject *pyobj = 0;
20193
20194 {
20195 #if wxUSE_UNICODE
20196 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20197 #else
20198 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20199 #endif
20200 }
20201 return pyobj;
20202 }
20203
20204
20205 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20206 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20207 return 1;
20208 }
20209
20210
20211 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20212 PyObject *pyobj = 0;
20213
20214 {
20215 #if wxUSE_UNICODE
20216 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20217 #else
20218 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20219 #endif
20220 }
20221 return pyobj;
20222 }
20223
20224
20225 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20226 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20227 return 1;
20228 }
20229
20230
20231 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20232 PyObject *pyobj = 0;
20233
20234 {
20235 #if wxUSE_UNICODE
20236 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20237 #else
20238 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20239 #endif
20240 }
20241 return pyobj;
20242 }
20243
20244
20245 SWIGINTERN int ART_COPY_set(PyObject *) {
20246 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20247 return 1;
20248 }
20249
20250
20251 SWIGINTERN PyObject *ART_COPY_get(void) {
20252 PyObject *pyobj = 0;
20253
20254 {
20255 #if wxUSE_UNICODE
20256 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20257 #else
20258 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20259 #endif
20260 }
20261 return pyobj;
20262 }
20263
20264
20265 SWIGINTERN int ART_CUT_set(PyObject *) {
20266 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20267 return 1;
20268 }
20269
20270
20271 SWIGINTERN PyObject *ART_CUT_get(void) {
20272 PyObject *pyobj = 0;
20273
20274 {
20275 #if wxUSE_UNICODE
20276 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20277 #else
20278 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20279 #endif
20280 }
20281 return pyobj;
20282 }
20283
20284
20285 SWIGINTERN int ART_PASTE_set(PyObject *) {
20286 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20287 return 1;
20288 }
20289
20290
20291 SWIGINTERN PyObject *ART_PASTE_get(void) {
20292 PyObject *pyobj = 0;
20293
20294 {
20295 #if wxUSE_UNICODE
20296 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20297 #else
20298 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20299 #endif
20300 }
20301 return pyobj;
20302 }
20303
20304
20305 SWIGINTERN int ART_DELETE_set(PyObject *) {
20306 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20307 return 1;
20308 }
20309
20310
20311 SWIGINTERN PyObject *ART_DELETE_get(void) {
20312 PyObject *pyobj = 0;
20313
20314 {
20315 #if wxUSE_UNICODE
20316 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20317 #else
20318 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20319 #endif
20320 }
20321 return pyobj;
20322 }
20323
20324
20325 SWIGINTERN int ART_NEW_set(PyObject *) {
20326 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20327 return 1;
20328 }
20329
20330
20331 SWIGINTERN PyObject *ART_NEW_get(void) {
20332 PyObject *pyobj = 0;
20333
20334 {
20335 #if wxUSE_UNICODE
20336 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20337 #else
20338 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20339 #endif
20340 }
20341 return pyobj;
20342 }
20343
20344
20345 SWIGINTERN int ART_UNDO_set(PyObject *) {
20346 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20347 return 1;
20348 }
20349
20350
20351 SWIGINTERN PyObject *ART_UNDO_get(void) {
20352 PyObject *pyobj = 0;
20353
20354 {
20355 #if wxUSE_UNICODE
20356 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20357 #else
20358 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20359 #endif
20360 }
20361 return pyobj;
20362 }
20363
20364
20365 SWIGINTERN int ART_REDO_set(PyObject *) {
20366 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20367 return 1;
20368 }
20369
20370
20371 SWIGINTERN PyObject *ART_REDO_get(void) {
20372 PyObject *pyobj = 0;
20373
20374 {
20375 #if wxUSE_UNICODE
20376 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20377 #else
20378 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20379 #endif
20380 }
20381 return pyobj;
20382 }
20383
20384
20385 SWIGINTERN int ART_QUIT_set(PyObject *) {
20386 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20387 return 1;
20388 }
20389
20390
20391 SWIGINTERN PyObject *ART_QUIT_get(void) {
20392 PyObject *pyobj = 0;
20393
20394 {
20395 #if wxUSE_UNICODE
20396 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20397 #else
20398 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20399 #endif
20400 }
20401 return pyobj;
20402 }
20403
20404
20405 SWIGINTERN int ART_FIND_set(PyObject *) {
20406 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20407 return 1;
20408 }
20409
20410
20411 SWIGINTERN PyObject *ART_FIND_get(void) {
20412 PyObject *pyobj = 0;
20413
20414 {
20415 #if wxUSE_UNICODE
20416 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20417 #else
20418 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20419 #endif
20420 }
20421 return pyobj;
20422 }
20423
20424
20425 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20426 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20427 return 1;
20428 }
20429
20430
20431 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20432 PyObject *pyobj = 0;
20433
20434 {
20435 #if wxUSE_UNICODE
20436 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20437 #else
20438 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20439 #endif
20440 }
20441 return pyobj;
20442 }
20443
20444
20445 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20446 PyObject *resultobj = 0;
20447 wxPyArtProvider *result = 0 ;
20448
20449 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20450 {
20451 if (!wxPyCheckForApp()) SWIG_fail;
20452 PyThreadState* __tstate = wxPyBeginAllowThreads();
20453 result = (wxPyArtProvider *)new wxPyArtProvider();
20454 wxPyEndAllowThreads(__tstate);
20455 if (PyErr_Occurred()) SWIG_fail;
20456 }
20457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20458 return resultobj;
20459 fail:
20460 return NULL;
20461 }
20462
20463
20464 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20465 PyObject *resultobj = 0;
20466 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20467 void *argp1 = 0 ;
20468 int res1 = 0 ;
20469 PyObject *swig_obj[1] ;
20470
20471 if (!args) SWIG_fail;
20472 swig_obj[0] = args;
20473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20474 if (!SWIG_IsOK(res1)) {
20475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20476 }
20477 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20478 {
20479 PyThreadState* __tstate = wxPyBeginAllowThreads();
20480 delete arg1;
20481
20482 wxPyEndAllowThreads(__tstate);
20483 if (PyErr_Occurred()) SWIG_fail;
20484 }
20485 resultobj = SWIG_Py_Void();
20486 return resultobj;
20487 fail:
20488 return NULL;
20489 }
20490
20491
20492 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20493 PyObject *resultobj = 0;
20494 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20495 PyObject *arg2 = (PyObject *) 0 ;
20496 PyObject *arg3 = (PyObject *) 0 ;
20497 void *argp1 = 0 ;
20498 int res1 = 0 ;
20499 PyObject * obj0 = 0 ;
20500 PyObject * obj1 = 0 ;
20501 PyObject * obj2 = 0 ;
20502 char * kwnames[] = {
20503 (char *) "self",(char *) "self",(char *) "_class", NULL
20504 };
20505
20506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20508 if (!SWIG_IsOK(res1)) {
20509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20510 }
20511 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20512 arg2 = obj1;
20513 arg3 = obj2;
20514 {
20515 PyThreadState* __tstate = wxPyBeginAllowThreads();
20516 (arg1)->_setCallbackInfo(arg2,arg3);
20517 wxPyEndAllowThreads(__tstate);
20518 if (PyErr_Occurred()) SWIG_fail;
20519 }
20520 resultobj = SWIG_Py_Void();
20521 return resultobj;
20522 fail:
20523 return NULL;
20524 }
20525
20526
20527 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20528 PyObject *resultobj = 0;
20529 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20530 int res1 = 0 ;
20531 PyObject * obj0 = 0 ;
20532 char * kwnames[] = {
20533 (char *) "provider", NULL
20534 };
20535
20536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20537 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20538 if (!SWIG_IsOK(res1)) {
20539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20540 }
20541 {
20542 PyThreadState* __tstate = wxPyBeginAllowThreads();
20543 wxPyArtProvider::Push(arg1);
20544 wxPyEndAllowThreads(__tstate);
20545 if (PyErr_Occurred()) SWIG_fail;
20546 }
20547 resultobj = SWIG_Py_Void();
20548 return resultobj;
20549 fail:
20550 return NULL;
20551 }
20552
20553
20554 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20555 PyObject *resultobj = 0;
20556 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20557 int res1 = 0 ;
20558 PyObject * obj0 = 0 ;
20559 char * kwnames[] = {
20560 (char *) "provider", NULL
20561 };
20562
20563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20564 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20565 if (!SWIG_IsOK(res1)) {
20566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20567 }
20568 {
20569 PyThreadState* __tstate = wxPyBeginAllowThreads();
20570 wxPyArtProvider::Insert(arg1);
20571 wxPyEndAllowThreads(__tstate);
20572 if (PyErr_Occurred()) SWIG_fail;
20573 }
20574 resultobj = SWIG_Py_Void();
20575 return resultobj;
20576 fail:
20577 return NULL;
20578 }
20579
20580
20581 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20582 PyObject *resultobj = 0;
20583 bool result;
20584
20585 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20586 {
20587 PyThreadState* __tstate = wxPyBeginAllowThreads();
20588 result = (bool)wxPyArtProvider::Pop();
20589 wxPyEndAllowThreads(__tstate);
20590 if (PyErr_Occurred()) SWIG_fail;
20591 }
20592 {
20593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20594 }
20595 return resultobj;
20596 fail:
20597 return NULL;
20598 }
20599
20600
20601 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20602 PyObject *resultobj = 0;
20603 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20604 bool result;
20605 void *argp1 = 0 ;
20606 int res1 = 0 ;
20607 PyObject * obj0 = 0 ;
20608 char * kwnames[] = {
20609 (char *) "provider", NULL
20610 };
20611
20612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20614 if (!SWIG_IsOK(res1)) {
20615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20616 }
20617 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20618 {
20619 PyThreadState* __tstate = wxPyBeginAllowThreads();
20620 result = (bool)wxPyArtProvider::Delete(arg1);
20621 wxPyEndAllowThreads(__tstate);
20622 if (PyErr_Occurred()) SWIG_fail;
20623 }
20624 {
20625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20626 }
20627 return resultobj;
20628 fail:
20629 return NULL;
20630 }
20631
20632
20633 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20634 PyObject *resultobj = 0;
20635 wxString *arg1 = 0 ;
20636 wxString const &arg2_defvalue = wxPyART_OTHER ;
20637 wxString *arg2 = (wxString *) &arg2_defvalue ;
20638 wxSize const &arg3_defvalue = wxDefaultSize ;
20639 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20640 wxBitmap result;
20641 bool temp1 = false ;
20642 bool temp2 = false ;
20643 wxSize temp3 ;
20644 PyObject * obj0 = 0 ;
20645 PyObject * obj1 = 0 ;
20646 PyObject * obj2 = 0 ;
20647 char * kwnames[] = {
20648 (char *) "id",(char *) "client",(char *) "size", NULL
20649 };
20650
20651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20652 {
20653 arg1 = wxString_in_helper(obj0);
20654 if (arg1 == NULL) SWIG_fail;
20655 temp1 = true;
20656 }
20657 if (obj1) {
20658 {
20659 arg2 = wxString_in_helper(obj1);
20660 if (arg2 == NULL) SWIG_fail;
20661 temp2 = true;
20662 }
20663 }
20664 if (obj2) {
20665 {
20666 arg3 = &temp3;
20667 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20668 }
20669 }
20670 {
20671 if (!wxPyCheckForApp()) SWIG_fail;
20672 PyThreadState* __tstate = wxPyBeginAllowThreads();
20673 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20674 wxPyEndAllowThreads(__tstate);
20675 if (PyErr_Occurred()) SWIG_fail;
20676 }
20677 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20678 {
20679 if (temp1)
20680 delete arg1;
20681 }
20682 {
20683 if (temp2)
20684 delete arg2;
20685 }
20686 return resultobj;
20687 fail:
20688 {
20689 if (temp1)
20690 delete arg1;
20691 }
20692 {
20693 if (temp2)
20694 delete arg2;
20695 }
20696 return NULL;
20697 }
20698
20699
20700 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20701 PyObject *resultobj = 0;
20702 wxString *arg1 = 0 ;
20703 wxString const &arg2_defvalue = wxPyART_OTHER ;
20704 wxString *arg2 = (wxString *) &arg2_defvalue ;
20705 wxSize const &arg3_defvalue = wxDefaultSize ;
20706 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20707 wxIcon result;
20708 bool temp1 = false ;
20709 bool temp2 = false ;
20710 wxSize temp3 ;
20711 PyObject * obj0 = 0 ;
20712 PyObject * obj1 = 0 ;
20713 PyObject * obj2 = 0 ;
20714 char * kwnames[] = {
20715 (char *) "id",(char *) "client",(char *) "size", NULL
20716 };
20717
20718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20719 {
20720 arg1 = wxString_in_helper(obj0);
20721 if (arg1 == NULL) SWIG_fail;
20722 temp1 = true;
20723 }
20724 if (obj1) {
20725 {
20726 arg2 = wxString_in_helper(obj1);
20727 if (arg2 == NULL) SWIG_fail;
20728 temp2 = true;
20729 }
20730 }
20731 if (obj2) {
20732 {
20733 arg3 = &temp3;
20734 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20735 }
20736 }
20737 {
20738 if (!wxPyCheckForApp()) SWIG_fail;
20739 PyThreadState* __tstate = wxPyBeginAllowThreads();
20740 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20741 wxPyEndAllowThreads(__tstate);
20742 if (PyErr_Occurred()) SWIG_fail;
20743 }
20744 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20745 {
20746 if (temp1)
20747 delete arg1;
20748 }
20749 {
20750 if (temp2)
20751 delete arg2;
20752 }
20753 return resultobj;
20754 fail:
20755 {
20756 if (temp1)
20757 delete arg1;
20758 }
20759 {
20760 if (temp2)
20761 delete arg2;
20762 }
20763 return NULL;
20764 }
20765
20766
20767 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20768 PyObject *resultobj = 0;
20769 wxString *arg1 = 0 ;
20770 bool arg2 = (bool) false ;
20771 wxSize result;
20772 bool temp1 = false ;
20773 bool val2 ;
20774 int ecode2 = 0 ;
20775 PyObject * obj0 = 0 ;
20776 PyObject * obj1 = 0 ;
20777 char * kwnames[] = {
20778 (char *) "client",(char *) "platform_dependent", NULL
20779 };
20780
20781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20782 {
20783 arg1 = wxString_in_helper(obj0);
20784 if (arg1 == NULL) SWIG_fail;
20785 temp1 = true;
20786 }
20787 if (obj1) {
20788 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20789 if (!SWIG_IsOK(ecode2)) {
20790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20791 }
20792 arg2 = static_cast< bool >(val2);
20793 }
20794 {
20795 PyThreadState* __tstate = wxPyBeginAllowThreads();
20796 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20797 wxPyEndAllowThreads(__tstate);
20798 if (PyErr_Occurred()) SWIG_fail;
20799 }
20800 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20801 {
20802 if (temp1)
20803 delete arg1;
20804 }
20805 return resultobj;
20806 fail:
20807 {
20808 if (temp1)
20809 delete arg1;
20810 }
20811 return NULL;
20812 }
20813
20814
20815 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20816 PyObject *resultobj = 0;
20817 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20818 void *argp1 = 0 ;
20819 int res1 = 0 ;
20820 PyObject *swig_obj[1] ;
20821
20822 if (!args) SWIG_fail;
20823 swig_obj[0] = args;
20824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20825 if (!SWIG_IsOK(res1)) {
20826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20827 }
20828 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20829 {
20830 PyThreadState* __tstate = wxPyBeginAllowThreads();
20831 wxPyArtProvider_Destroy(arg1);
20832 wxPyEndAllowThreads(__tstate);
20833 if (PyErr_Occurred()) SWIG_fail;
20834 }
20835 resultobj = SWIG_Py_Void();
20836 return resultobj;
20837 fail:
20838 return NULL;
20839 }
20840
20841
20842 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20843 PyObject *obj;
20844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20845 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20846 return SWIG_Py_Void();
20847 }
20848
20849 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20850 return SWIG_Python_InitShadowInstance(args);
20851 }
20852
20853 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20854 PyObject *resultobj = 0;
20855 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20856 void *argp1 = 0 ;
20857 int res1 = 0 ;
20858 PyObject *swig_obj[1] ;
20859
20860 if (!args) SWIG_fail;
20861 swig_obj[0] = args;
20862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20863 if (!SWIG_IsOK(res1)) {
20864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20865 }
20866 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20867 {
20868 PyThreadState* __tstate = wxPyBeginAllowThreads();
20869 delete arg1;
20870
20871 wxPyEndAllowThreads(__tstate);
20872 if (PyErr_Occurred()) SWIG_fail;
20873 }
20874 resultobj = SWIG_Py_Void();
20875 return resultobj;
20876 fail:
20877 return NULL;
20878 }
20879
20880
20881 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20882 PyObject *resultobj = 0;
20883 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20884 wxConfigBase *result = 0 ;
20885 int res1 = 0 ;
20886 PyObject * obj0 = 0 ;
20887 char * kwnames[] = {
20888 (char *) "config", NULL
20889 };
20890
20891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20892 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20893 if (!SWIG_IsOK(res1)) {
20894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20895 }
20896 {
20897 PyThreadState* __tstate = wxPyBeginAllowThreads();
20898 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20899 wxPyEndAllowThreads(__tstate);
20900 if (PyErr_Occurred()) SWIG_fail;
20901 }
20902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20903 return resultobj;
20904 fail:
20905 return NULL;
20906 }
20907
20908
20909 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20910 PyObject *resultobj = 0;
20911 bool arg1 = (bool) true ;
20912 wxConfigBase *result = 0 ;
20913 bool val1 ;
20914 int ecode1 = 0 ;
20915 PyObject * obj0 = 0 ;
20916 char * kwnames[] = {
20917 (char *) "createOnDemand", NULL
20918 };
20919
20920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20921 if (obj0) {
20922 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20923 if (!SWIG_IsOK(ecode1)) {
20924 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20925 }
20926 arg1 = static_cast< bool >(val1);
20927 }
20928 {
20929 PyThreadState* __tstate = wxPyBeginAllowThreads();
20930 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20931 wxPyEndAllowThreads(__tstate);
20932 if (PyErr_Occurred()) SWIG_fail;
20933 }
20934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20935 return resultobj;
20936 fail:
20937 return NULL;
20938 }
20939
20940
20941 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20942 PyObject *resultobj = 0;
20943 wxConfigBase *result = 0 ;
20944
20945 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20946 {
20947 PyThreadState* __tstate = wxPyBeginAllowThreads();
20948 result = (wxConfigBase *)wxConfigBase::Create();
20949 wxPyEndAllowThreads(__tstate);
20950 if (PyErr_Occurred()) SWIG_fail;
20951 }
20952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20953 return resultobj;
20954 fail:
20955 return NULL;
20956 }
20957
20958
20959 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20960 PyObject *resultobj = 0;
20961
20962 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20963 {
20964 PyThreadState* __tstate = wxPyBeginAllowThreads();
20965 wxConfigBase::DontCreateOnDemand();
20966 wxPyEndAllowThreads(__tstate);
20967 if (PyErr_Occurred()) SWIG_fail;
20968 }
20969 resultobj = SWIG_Py_Void();
20970 return resultobj;
20971 fail:
20972 return NULL;
20973 }
20974
20975
20976 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20977 PyObject *resultobj = 0;
20978 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20979 wxString *arg2 = 0 ;
20980 void *argp1 = 0 ;
20981 int res1 = 0 ;
20982 bool temp2 = false ;
20983 PyObject * obj0 = 0 ;
20984 PyObject * obj1 = 0 ;
20985 char * kwnames[] = {
20986 (char *) "self",(char *) "path", NULL
20987 };
20988
20989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20991 if (!SWIG_IsOK(res1)) {
20992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20993 }
20994 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20995 {
20996 arg2 = wxString_in_helper(obj1);
20997 if (arg2 == NULL) SWIG_fail;
20998 temp2 = true;
20999 }
21000 {
21001 PyThreadState* __tstate = wxPyBeginAllowThreads();
21002 (arg1)->SetPath((wxString const &)*arg2);
21003 wxPyEndAllowThreads(__tstate);
21004 if (PyErr_Occurred()) SWIG_fail;
21005 }
21006 resultobj = SWIG_Py_Void();
21007 {
21008 if (temp2)
21009 delete arg2;
21010 }
21011 return resultobj;
21012 fail:
21013 {
21014 if (temp2)
21015 delete arg2;
21016 }
21017 return NULL;
21018 }
21019
21020
21021 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21022 PyObject *resultobj = 0;
21023 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21024 wxString *result = 0 ;
21025 void *argp1 = 0 ;
21026 int res1 = 0 ;
21027 PyObject *swig_obj[1] ;
21028
21029 if (!args) SWIG_fail;
21030 swig_obj[0] = args;
21031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21032 if (!SWIG_IsOK(res1)) {
21033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21034 }
21035 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21036 {
21037 PyThreadState* __tstate = wxPyBeginAllowThreads();
21038 {
21039 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21040 result = (wxString *) &_result_ref;
21041 }
21042 wxPyEndAllowThreads(__tstate);
21043 if (PyErr_Occurred()) SWIG_fail;
21044 }
21045 {
21046 #if wxUSE_UNICODE
21047 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21048 #else
21049 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21050 #endif
21051 }
21052 return resultobj;
21053 fail:
21054 return NULL;
21055 }
21056
21057
21058 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21059 PyObject *resultobj = 0;
21060 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21061 PyObject *result = 0 ;
21062 void *argp1 = 0 ;
21063 int res1 = 0 ;
21064 PyObject *swig_obj[1] ;
21065
21066 if (!args) SWIG_fail;
21067 swig_obj[0] = args;
21068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21069 if (!SWIG_IsOK(res1)) {
21070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21071 }
21072 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21073 {
21074 PyThreadState* __tstate = wxPyBeginAllowThreads();
21075 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21076 wxPyEndAllowThreads(__tstate);
21077 if (PyErr_Occurred()) SWIG_fail;
21078 }
21079 resultobj = result;
21080 return resultobj;
21081 fail:
21082 return NULL;
21083 }
21084
21085
21086 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21087 PyObject *resultobj = 0;
21088 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21089 long arg2 ;
21090 PyObject *result = 0 ;
21091 void *argp1 = 0 ;
21092 int res1 = 0 ;
21093 long val2 ;
21094 int ecode2 = 0 ;
21095 PyObject * obj0 = 0 ;
21096 PyObject * obj1 = 0 ;
21097 char * kwnames[] = {
21098 (char *) "self",(char *) "index", NULL
21099 };
21100
21101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21103 if (!SWIG_IsOK(res1)) {
21104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21105 }
21106 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21107 ecode2 = SWIG_AsVal_long(obj1, &val2);
21108 if (!SWIG_IsOK(ecode2)) {
21109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21110 }
21111 arg2 = static_cast< long >(val2);
21112 {
21113 PyThreadState* __tstate = wxPyBeginAllowThreads();
21114 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21115 wxPyEndAllowThreads(__tstate);
21116 if (PyErr_Occurred()) SWIG_fail;
21117 }
21118 resultobj = result;
21119 return resultobj;
21120 fail:
21121 return NULL;
21122 }
21123
21124
21125 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21126 PyObject *resultobj = 0;
21127 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21128 PyObject *result = 0 ;
21129 void *argp1 = 0 ;
21130 int res1 = 0 ;
21131 PyObject *swig_obj[1] ;
21132
21133 if (!args) SWIG_fail;
21134 swig_obj[0] = args;
21135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21136 if (!SWIG_IsOK(res1)) {
21137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21138 }
21139 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21140 {
21141 PyThreadState* __tstate = wxPyBeginAllowThreads();
21142 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21143 wxPyEndAllowThreads(__tstate);
21144 if (PyErr_Occurred()) SWIG_fail;
21145 }
21146 resultobj = result;
21147 return resultobj;
21148 fail:
21149 return NULL;
21150 }
21151
21152
21153 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21154 PyObject *resultobj = 0;
21155 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21156 long arg2 ;
21157 PyObject *result = 0 ;
21158 void *argp1 = 0 ;
21159 int res1 = 0 ;
21160 long val2 ;
21161 int ecode2 = 0 ;
21162 PyObject * obj0 = 0 ;
21163 PyObject * obj1 = 0 ;
21164 char * kwnames[] = {
21165 (char *) "self",(char *) "index", NULL
21166 };
21167
21168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21170 if (!SWIG_IsOK(res1)) {
21171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21172 }
21173 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21174 ecode2 = SWIG_AsVal_long(obj1, &val2);
21175 if (!SWIG_IsOK(ecode2)) {
21176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21177 }
21178 arg2 = static_cast< long >(val2);
21179 {
21180 PyThreadState* __tstate = wxPyBeginAllowThreads();
21181 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21182 wxPyEndAllowThreads(__tstate);
21183 if (PyErr_Occurred()) SWIG_fail;
21184 }
21185 resultobj = result;
21186 return resultobj;
21187 fail:
21188 return NULL;
21189 }
21190
21191
21192 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21193 PyObject *resultobj = 0;
21194 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21195 bool arg2 = (bool) false ;
21196 size_t result;
21197 void *argp1 = 0 ;
21198 int res1 = 0 ;
21199 bool val2 ;
21200 int ecode2 = 0 ;
21201 PyObject * obj0 = 0 ;
21202 PyObject * obj1 = 0 ;
21203 char * kwnames[] = {
21204 (char *) "self",(char *) "recursive", NULL
21205 };
21206
21207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21209 if (!SWIG_IsOK(res1)) {
21210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21211 }
21212 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21213 if (obj1) {
21214 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21215 if (!SWIG_IsOK(ecode2)) {
21216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21217 }
21218 arg2 = static_cast< bool >(val2);
21219 }
21220 {
21221 PyThreadState* __tstate = wxPyBeginAllowThreads();
21222 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21223 wxPyEndAllowThreads(__tstate);
21224 if (PyErr_Occurred()) SWIG_fail;
21225 }
21226 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21227 return resultobj;
21228 fail:
21229 return NULL;
21230 }
21231
21232
21233 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21234 PyObject *resultobj = 0;
21235 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21236 bool arg2 = (bool) false ;
21237 size_t result;
21238 void *argp1 = 0 ;
21239 int res1 = 0 ;
21240 bool val2 ;
21241 int ecode2 = 0 ;
21242 PyObject * obj0 = 0 ;
21243 PyObject * obj1 = 0 ;
21244 char * kwnames[] = {
21245 (char *) "self",(char *) "recursive", NULL
21246 };
21247
21248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21250 if (!SWIG_IsOK(res1)) {
21251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21252 }
21253 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21254 if (obj1) {
21255 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21256 if (!SWIG_IsOK(ecode2)) {
21257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21258 }
21259 arg2 = static_cast< bool >(val2);
21260 }
21261 {
21262 PyThreadState* __tstate = wxPyBeginAllowThreads();
21263 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21264 wxPyEndAllowThreads(__tstate);
21265 if (PyErr_Occurred()) SWIG_fail;
21266 }
21267 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21268 return resultobj;
21269 fail:
21270 return NULL;
21271 }
21272
21273
21274 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(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_HasGroup",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_HasGroup" "', 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)->HasGroup((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_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21323 PyObject *resultobj = 0;
21324 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21325 wxString *arg2 = 0 ;
21326 bool 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_HasEntry",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_HasEntry" "', 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 = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21350 wxPyEndAllowThreads(__tstate);
21351 if (PyErr_Occurred()) SWIG_fail;
21352 }
21353 {
21354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21355 }
21356 {
21357 if (temp2)
21358 delete arg2;
21359 }
21360 return resultobj;
21361 fail:
21362 {
21363 if (temp2)
21364 delete arg2;
21365 }
21366 return NULL;
21367 }
21368
21369
21370 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21371 PyObject *resultobj = 0;
21372 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21373 wxString *arg2 = 0 ;
21374 bool result;
21375 void *argp1 = 0 ;
21376 int res1 = 0 ;
21377 bool temp2 = false ;
21378 PyObject * obj0 = 0 ;
21379 PyObject * obj1 = 0 ;
21380 char * kwnames[] = {
21381 (char *) "self",(char *) "name", NULL
21382 };
21383
21384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21386 if (!SWIG_IsOK(res1)) {
21387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21388 }
21389 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21390 {
21391 arg2 = wxString_in_helper(obj1);
21392 if (arg2 == NULL) SWIG_fail;
21393 temp2 = true;
21394 }
21395 {
21396 PyThreadState* __tstate = wxPyBeginAllowThreads();
21397 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21398 wxPyEndAllowThreads(__tstate);
21399 if (PyErr_Occurred()) SWIG_fail;
21400 }
21401 {
21402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21403 }
21404 {
21405 if (temp2)
21406 delete arg2;
21407 }
21408 return resultobj;
21409 fail:
21410 {
21411 if (temp2)
21412 delete arg2;
21413 }
21414 return NULL;
21415 }
21416
21417
21418 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21419 PyObject *resultobj = 0;
21420 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21421 wxString *arg2 = 0 ;
21422 wxConfigBase::EntryType result;
21423 void *argp1 = 0 ;
21424 int res1 = 0 ;
21425 bool temp2 = false ;
21426 PyObject * obj0 = 0 ;
21427 PyObject * obj1 = 0 ;
21428 char * kwnames[] = {
21429 (char *) "self",(char *) "name", NULL
21430 };
21431
21432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21434 if (!SWIG_IsOK(res1)) {
21435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21436 }
21437 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21438 {
21439 arg2 = wxString_in_helper(obj1);
21440 if (arg2 == NULL) SWIG_fail;
21441 temp2 = true;
21442 }
21443 {
21444 PyThreadState* __tstate = wxPyBeginAllowThreads();
21445 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21446 wxPyEndAllowThreads(__tstate);
21447 if (PyErr_Occurred()) SWIG_fail;
21448 }
21449 resultobj = SWIG_From_int(static_cast< int >(result));
21450 {
21451 if (temp2)
21452 delete arg2;
21453 }
21454 return resultobj;
21455 fail:
21456 {
21457 if (temp2)
21458 delete arg2;
21459 }
21460 return NULL;
21461 }
21462
21463
21464 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21465 PyObject *resultobj = 0;
21466 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21467 wxString *arg2 = 0 ;
21468 wxString const &arg3_defvalue = wxPyEmptyString ;
21469 wxString *arg3 = (wxString *) &arg3_defvalue ;
21470 wxString result;
21471 void *argp1 = 0 ;
21472 int res1 = 0 ;
21473 bool temp2 = false ;
21474 bool temp3 = false ;
21475 PyObject * obj0 = 0 ;
21476 PyObject * obj1 = 0 ;
21477 PyObject * obj2 = 0 ;
21478 char * kwnames[] = {
21479 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21480 };
21481
21482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21484 if (!SWIG_IsOK(res1)) {
21485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21486 }
21487 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21488 {
21489 arg2 = wxString_in_helper(obj1);
21490 if (arg2 == NULL) SWIG_fail;
21491 temp2 = true;
21492 }
21493 if (obj2) {
21494 {
21495 arg3 = wxString_in_helper(obj2);
21496 if (arg3 == NULL) SWIG_fail;
21497 temp3 = true;
21498 }
21499 }
21500 {
21501 PyThreadState* __tstate = wxPyBeginAllowThreads();
21502 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21503 wxPyEndAllowThreads(__tstate);
21504 if (PyErr_Occurred()) SWIG_fail;
21505 }
21506 {
21507 #if wxUSE_UNICODE
21508 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21509 #else
21510 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21511 #endif
21512 }
21513 {
21514 if (temp2)
21515 delete arg2;
21516 }
21517 {
21518 if (temp3)
21519 delete arg3;
21520 }
21521 return resultobj;
21522 fail:
21523 {
21524 if (temp2)
21525 delete arg2;
21526 }
21527 {
21528 if (temp3)
21529 delete arg3;
21530 }
21531 return NULL;
21532 }
21533
21534
21535 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21536 PyObject *resultobj = 0;
21537 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21538 wxString *arg2 = 0 ;
21539 long arg3 = (long) 0 ;
21540 long result;
21541 void *argp1 = 0 ;
21542 int res1 = 0 ;
21543 bool temp2 = false ;
21544 long val3 ;
21545 int ecode3 = 0 ;
21546 PyObject * obj0 = 0 ;
21547 PyObject * obj1 = 0 ;
21548 PyObject * obj2 = 0 ;
21549 char * kwnames[] = {
21550 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21551 };
21552
21553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21555 if (!SWIG_IsOK(res1)) {
21556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21557 }
21558 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21559 {
21560 arg2 = wxString_in_helper(obj1);
21561 if (arg2 == NULL) SWIG_fail;
21562 temp2 = true;
21563 }
21564 if (obj2) {
21565 ecode3 = SWIG_AsVal_long(obj2, &val3);
21566 if (!SWIG_IsOK(ecode3)) {
21567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21568 }
21569 arg3 = static_cast< long >(val3);
21570 }
21571 {
21572 PyThreadState* __tstate = wxPyBeginAllowThreads();
21573 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21574 wxPyEndAllowThreads(__tstate);
21575 if (PyErr_Occurred()) SWIG_fail;
21576 }
21577 resultobj = SWIG_From_long(static_cast< long >(result));
21578 {
21579 if (temp2)
21580 delete arg2;
21581 }
21582 return resultobj;
21583 fail:
21584 {
21585 if (temp2)
21586 delete arg2;
21587 }
21588 return NULL;
21589 }
21590
21591
21592 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21593 PyObject *resultobj = 0;
21594 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21595 wxString *arg2 = 0 ;
21596 double arg3 = (double) 0.0 ;
21597 double result;
21598 void *argp1 = 0 ;
21599 int res1 = 0 ;
21600 bool temp2 = false ;
21601 double val3 ;
21602 int ecode3 = 0 ;
21603 PyObject * obj0 = 0 ;
21604 PyObject * obj1 = 0 ;
21605 PyObject * obj2 = 0 ;
21606 char * kwnames[] = {
21607 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21608 };
21609
21610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21612 if (!SWIG_IsOK(res1)) {
21613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21614 }
21615 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21616 {
21617 arg2 = wxString_in_helper(obj1);
21618 if (arg2 == NULL) SWIG_fail;
21619 temp2 = true;
21620 }
21621 if (obj2) {
21622 ecode3 = SWIG_AsVal_double(obj2, &val3);
21623 if (!SWIG_IsOK(ecode3)) {
21624 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21625 }
21626 arg3 = static_cast< double >(val3);
21627 }
21628 {
21629 PyThreadState* __tstate = wxPyBeginAllowThreads();
21630 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21631 wxPyEndAllowThreads(__tstate);
21632 if (PyErr_Occurred()) SWIG_fail;
21633 }
21634 resultobj = SWIG_From_double(static_cast< double >(result));
21635 {
21636 if (temp2)
21637 delete arg2;
21638 }
21639 return resultobj;
21640 fail:
21641 {
21642 if (temp2)
21643 delete arg2;
21644 }
21645 return NULL;
21646 }
21647
21648
21649 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21650 PyObject *resultobj = 0;
21651 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21652 wxString *arg2 = 0 ;
21653 bool arg3 = (bool) false ;
21654 bool result;
21655 void *argp1 = 0 ;
21656 int res1 = 0 ;
21657 bool temp2 = false ;
21658 bool val3 ;
21659 int ecode3 = 0 ;
21660 PyObject * obj0 = 0 ;
21661 PyObject * obj1 = 0 ;
21662 PyObject * obj2 = 0 ;
21663 char * kwnames[] = {
21664 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21665 };
21666
21667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21669 if (!SWIG_IsOK(res1)) {
21670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21671 }
21672 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21673 {
21674 arg2 = wxString_in_helper(obj1);
21675 if (arg2 == NULL) SWIG_fail;
21676 temp2 = true;
21677 }
21678 if (obj2) {
21679 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21680 if (!SWIG_IsOK(ecode3)) {
21681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21682 }
21683 arg3 = static_cast< bool >(val3);
21684 }
21685 {
21686 PyThreadState* __tstate = wxPyBeginAllowThreads();
21687 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21688 wxPyEndAllowThreads(__tstate);
21689 if (PyErr_Occurred()) SWIG_fail;
21690 }
21691 {
21692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21693 }
21694 {
21695 if (temp2)
21696 delete arg2;
21697 }
21698 return resultobj;
21699 fail:
21700 {
21701 if (temp2)
21702 delete arg2;
21703 }
21704 return NULL;
21705 }
21706
21707
21708 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21709 PyObject *resultobj = 0;
21710 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21711 wxString *arg2 = 0 ;
21712 wxString *arg3 = 0 ;
21713 bool result;
21714 void *argp1 = 0 ;
21715 int res1 = 0 ;
21716 bool temp2 = false ;
21717 bool temp3 = false ;
21718 PyObject * obj0 = 0 ;
21719 PyObject * obj1 = 0 ;
21720 PyObject * obj2 = 0 ;
21721 char * kwnames[] = {
21722 (char *) "self",(char *) "key",(char *) "value", NULL
21723 };
21724
21725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21727 if (!SWIG_IsOK(res1)) {
21728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21729 }
21730 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21731 {
21732 arg2 = wxString_in_helper(obj1);
21733 if (arg2 == NULL) SWIG_fail;
21734 temp2 = true;
21735 }
21736 {
21737 arg3 = wxString_in_helper(obj2);
21738 if (arg3 == NULL) SWIG_fail;
21739 temp3 = true;
21740 }
21741 {
21742 PyThreadState* __tstate = wxPyBeginAllowThreads();
21743 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21744 wxPyEndAllowThreads(__tstate);
21745 if (PyErr_Occurred()) SWIG_fail;
21746 }
21747 {
21748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21749 }
21750 {
21751 if (temp2)
21752 delete arg2;
21753 }
21754 {
21755 if (temp3)
21756 delete arg3;
21757 }
21758 return resultobj;
21759 fail:
21760 {
21761 if (temp2)
21762 delete arg2;
21763 }
21764 {
21765 if (temp3)
21766 delete arg3;
21767 }
21768 return NULL;
21769 }
21770
21771
21772 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21773 PyObject *resultobj = 0;
21774 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21775 wxString *arg2 = 0 ;
21776 long arg3 ;
21777 bool result;
21778 void *argp1 = 0 ;
21779 int res1 = 0 ;
21780 bool temp2 = false ;
21781 long val3 ;
21782 int ecode3 = 0 ;
21783 PyObject * obj0 = 0 ;
21784 PyObject * obj1 = 0 ;
21785 PyObject * obj2 = 0 ;
21786 char * kwnames[] = {
21787 (char *) "self",(char *) "key",(char *) "value", NULL
21788 };
21789
21790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21792 if (!SWIG_IsOK(res1)) {
21793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21794 }
21795 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21796 {
21797 arg2 = wxString_in_helper(obj1);
21798 if (arg2 == NULL) SWIG_fail;
21799 temp2 = true;
21800 }
21801 ecode3 = SWIG_AsVal_long(obj2, &val3);
21802 if (!SWIG_IsOK(ecode3)) {
21803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21804 }
21805 arg3 = static_cast< long >(val3);
21806 {
21807 PyThreadState* __tstate = wxPyBeginAllowThreads();
21808 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21809 wxPyEndAllowThreads(__tstate);
21810 if (PyErr_Occurred()) SWIG_fail;
21811 }
21812 {
21813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21814 }
21815 {
21816 if (temp2)
21817 delete arg2;
21818 }
21819 return resultobj;
21820 fail:
21821 {
21822 if (temp2)
21823 delete arg2;
21824 }
21825 return NULL;
21826 }
21827
21828
21829 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21830 PyObject *resultobj = 0;
21831 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21832 wxString *arg2 = 0 ;
21833 double arg3 ;
21834 bool result;
21835 void *argp1 = 0 ;
21836 int res1 = 0 ;
21837 bool temp2 = false ;
21838 double val3 ;
21839 int ecode3 = 0 ;
21840 PyObject * obj0 = 0 ;
21841 PyObject * obj1 = 0 ;
21842 PyObject * obj2 = 0 ;
21843 char * kwnames[] = {
21844 (char *) "self",(char *) "key",(char *) "value", NULL
21845 };
21846
21847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21849 if (!SWIG_IsOK(res1)) {
21850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21851 }
21852 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21853 {
21854 arg2 = wxString_in_helper(obj1);
21855 if (arg2 == NULL) SWIG_fail;
21856 temp2 = true;
21857 }
21858 ecode3 = SWIG_AsVal_double(obj2, &val3);
21859 if (!SWIG_IsOK(ecode3)) {
21860 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21861 }
21862 arg3 = static_cast< double >(val3);
21863 {
21864 PyThreadState* __tstate = wxPyBeginAllowThreads();
21865 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21866 wxPyEndAllowThreads(__tstate);
21867 if (PyErr_Occurred()) SWIG_fail;
21868 }
21869 {
21870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21871 }
21872 {
21873 if (temp2)
21874 delete arg2;
21875 }
21876 return resultobj;
21877 fail:
21878 {
21879 if (temp2)
21880 delete arg2;
21881 }
21882 return NULL;
21883 }
21884
21885
21886 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21887 PyObject *resultobj = 0;
21888 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21889 wxString *arg2 = 0 ;
21890 bool arg3 ;
21891 bool result;
21892 void *argp1 = 0 ;
21893 int res1 = 0 ;
21894 bool temp2 = false ;
21895 bool val3 ;
21896 int ecode3 = 0 ;
21897 PyObject * obj0 = 0 ;
21898 PyObject * obj1 = 0 ;
21899 PyObject * obj2 = 0 ;
21900 char * kwnames[] = {
21901 (char *) "self",(char *) "key",(char *) "value", NULL
21902 };
21903
21904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21906 if (!SWIG_IsOK(res1)) {
21907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21908 }
21909 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21910 {
21911 arg2 = wxString_in_helper(obj1);
21912 if (arg2 == NULL) SWIG_fail;
21913 temp2 = true;
21914 }
21915 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21916 if (!SWIG_IsOK(ecode3)) {
21917 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21918 }
21919 arg3 = static_cast< bool >(val3);
21920 {
21921 PyThreadState* __tstate = wxPyBeginAllowThreads();
21922 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21923 wxPyEndAllowThreads(__tstate);
21924 if (PyErr_Occurred()) SWIG_fail;
21925 }
21926 {
21927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21928 }
21929 {
21930 if (temp2)
21931 delete arg2;
21932 }
21933 return resultobj;
21934 fail:
21935 {
21936 if (temp2)
21937 delete arg2;
21938 }
21939 return NULL;
21940 }
21941
21942
21943 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21944 PyObject *resultobj = 0;
21945 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21946 bool arg2 = (bool) false ;
21947 bool result;
21948 void *argp1 = 0 ;
21949 int res1 = 0 ;
21950 bool val2 ;
21951 int ecode2 = 0 ;
21952 PyObject * obj0 = 0 ;
21953 PyObject * obj1 = 0 ;
21954 char * kwnames[] = {
21955 (char *) "self",(char *) "currentOnly", NULL
21956 };
21957
21958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21960 if (!SWIG_IsOK(res1)) {
21961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21962 }
21963 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21964 if (obj1) {
21965 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21966 if (!SWIG_IsOK(ecode2)) {
21967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21968 }
21969 arg2 = static_cast< bool >(val2);
21970 }
21971 {
21972 PyThreadState* __tstate = wxPyBeginAllowThreads();
21973 result = (bool)(arg1)->Flush(arg2);
21974 wxPyEndAllowThreads(__tstate);
21975 if (PyErr_Occurred()) SWIG_fail;
21976 }
21977 {
21978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21979 }
21980 return resultobj;
21981 fail:
21982 return NULL;
21983 }
21984
21985
21986 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21987 PyObject *resultobj = 0;
21988 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21989 wxString *arg2 = 0 ;
21990 wxString *arg3 = 0 ;
21991 bool result;
21992 void *argp1 = 0 ;
21993 int res1 = 0 ;
21994 bool temp2 = false ;
21995 bool temp3 = false ;
21996 PyObject * obj0 = 0 ;
21997 PyObject * obj1 = 0 ;
21998 PyObject * obj2 = 0 ;
21999 char * kwnames[] = {
22000 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22001 };
22002
22003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22005 if (!SWIG_IsOK(res1)) {
22006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22007 }
22008 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22009 {
22010 arg2 = wxString_in_helper(obj1);
22011 if (arg2 == NULL) SWIG_fail;
22012 temp2 = true;
22013 }
22014 {
22015 arg3 = wxString_in_helper(obj2);
22016 if (arg3 == NULL) SWIG_fail;
22017 temp3 = true;
22018 }
22019 {
22020 PyThreadState* __tstate = wxPyBeginAllowThreads();
22021 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
22022 wxPyEndAllowThreads(__tstate);
22023 if (PyErr_Occurred()) SWIG_fail;
22024 }
22025 {
22026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22027 }
22028 {
22029 if (temp2)
22030 delete arg2;
22031 }
22032 {
22033 if (temp3)
22034 delete arg3;
22035 }
22036 return resultobj;
22037 fail:
22038 {
22039 if (temp2)
22040 delete arg2;
22041 }
22042 {
22043 if (temp3)
22044 delete arg3;
22045 }
22046 return NULL;
22047 }
22048
22049
22050 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22051 PyObject *resultobj = 0;
22052 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22053 wxString *arg2 = 0 ;
22054 wxString *arg3 = 0 ;
22055 bool result;
22056 void *argp1 = 0 ;
22057 int res1 = 0 ;
22058 bool temp2 = false ;
22059 bool temp3 = false ;
22060 PyObject * obj0 = 0 ;
22061 PyObject * obj1 = 0 ;
22062 PyObject * obj2 = 0 ;
22063 char * kwnames[] = {
22064 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22065 };
22066
22067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22069 if (!SWIG_IsOK(res1)) {
22070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22071 }
22072 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22073 {
22074 arg2 = wxString_in_helper(obj1);
22075 if (arg2 == NULL) SWIG_fail;
22076 temp2 = true;
22077 }
22078 {
22079 arg3 = wxString_in_helper(obj2);
22080 if (arg3 == NULL) SWIG_fail;
22081 temp3 = true;
22082 }
22083 {
22084 PyThreadState* __tstate = wxPyBeginAllowThreads();
22085 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22086 wxPyEndAllowThreads(__tstate);
22087 if (PyErr_Occurred()) SWIG_fail;
22088 }
22089 {
22090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22091 }
22092 {
22093 if (temp2)
22094 delete arg2;
22095 }
22096 {
22097 if (temp3)
22098 delete arg3;
22099 }
22100 return resultobj;
22101 fail:
22102 {
22103 if (temp2)
22104 delete arg2;
22105 }
22106 {
22107 if (temp3)
22108 delete arg3;
22109 }
22110 return NULL;
22111 }
22112
22113
22114 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22115 PyObject *resultobj = 0;
22116 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22117 wxString *arg2 = 0 ;
22118 bool arg3 = (bool) true ;
22119 bool result;
22120 void *argp1 = 0 ;
22121 int res1 = 0 ;
22122 bool temp2 = false ;
22123 bool val3 ;
22124 int ecode3 = 0 ;
22125 PyObject * obj0 = 0 ;
22126 PyObject * obj1 = 0 ;
22127 PyObject * obj2 = 0 ;
22128 char * kwnames[] = {
22129 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22130 };
22131
22132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22134 if (!SWIG_IsOK(res1)) {
22135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22136 }
22137 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22138 {
22139 arg2 = wxString_in_helper(obj1);
22140 if (arg2 == NULL) SWIG_fail;
22141 temp2 = true;
22142 }
22143 if (obj2) {
22144 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22145 if (!SWIG_IsOK(ecode3)) {
22146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22147 }
22148 arg3 = static_cast< bool >(val3);
22149 }
22150 {
22151 PyThreadState* __tstate = wxPyBeginAllowThreads();
22152 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22153 wxPyEndAllowThreads(__tstate);
22154 if (PyErr_Occurred()) SWIG_fail;
22155 }
22156 {
22157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22158 }
22159 {
22160 if (temp2)
22161 delete arg2;
22162 }
22163 return resultobj;
22164 fail:
22165 {
22166 if (temp2)
22167 delete arg2;
22168 }
22169 return NULL;
22170 }
22171
22172
22173 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22174 PyObject *resultobj = 0;
22175 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22176 wxString *arg2 = 0 ;
22177 bool result;
22178 void *argp1 = 0 ;
22179 int res1 = 0 ;
22180 bool temp2 = false ;
22181 PyObject * obj0 = 0 ;
22182 PyObject * obj1 = 0 ;
22183 char * kwnames[] = {
22184 (char *) "self",(char *) "key", NULL
22185 };
22186
22187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22189 if (!SWIG_IsOK(res1)) {
22190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22191 }
22192 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22193 {
22194 arg2 = wxString_in_helper(obj1);
22195 if (arg2 == NULL) SWIG_fail;
22196 temp2 = true;
22197 }
22198 {
22199 PyThreadState* __tstate = wxPyBeginAllowThreads();
22200 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22201 wxPyEndAllowThreads(__tstate);
22202 if (PyErr_Occurred()) SWIG_fail;
22203 }
22204 {
22205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22206 }
22207 {
22208 if (temp2)
22209 delete arg2;
22210 }
22211 return resultobj;
22212 fail:
22213 {
22214 if (temp2)
22215 delete arg2;
22216 }
22217 return NULL;
22218 }
22219
22220
22221 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22222 PyObject *resultobj = 0;
22223 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22224 bool result;
22225 void *argp1 = 0 ;
22226 int res1 = 0 ;
22227 PyObject *swig_obj[1] ;
22228
22229 if (!args) SWIG_fail;
22230 swig_obj[0] = args;
22231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22232 if (!SWIG_IsOK(res1)) {
22233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22234 }
22235 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22236 {
22237 PyThreadState* __tstate = wxPyBeginAllowThreads();
22238 result = (bool)(arg1)->DeleteAll();
22239 wxPyEndAllowThreads(__tstate);
22240 if (PyErr_Occurred()) SWIG_fail;
22241 }
22242 {
22243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22244 }
22245 return resultobj;
22246 fail:
22247 return NULL;
22248 }
22249
22250
22251 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22252 PyObject *resultobj = 0;
22253 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22254 bool arg2 = (bool) true ;
22255 void *argp1 = 0 ;
22256 int res1 = 0 ;
22257 bool val2 ;
22258 int ecode2 = 0 ;
22259 PyObject * obj0 = 0 ;
22260 PyObject * obj1 = 0 ;
22261 char * kwnames[] = {
22262 (char *) "self",(char *) "doIt", NULL
22263 };
22264
22265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22267 if (!SWIG_IsOK(res1)) {
22268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22269 }
22270 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22271 if (obj1) {
22272 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22273 if (!SWIG_IsOK(ecode2)) {
22274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22275 }
22276 arg2 = static_cast< bool >(val2);
22277 }
22278 {
22279 PyThreadState* __tstate = wxPyBeginAllowThreads();
22280 (arg1)->SetExpandEnvVars(arg2);
22281 wxPyEndAllowThreads(__tstate);
22282 if (PyErr_Occurred()) SWIG_fail;
22283 }
22284 resultobj = SWIG_Py_Void();
22285 return resultobj;
22286 fail:
22287 return NULL;
22288 }
22289
22290
22291 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22292 PyObject *resultobj = 0;
22293 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22294 bool result;
22295 void *argp1 = 0 ;
22296 int res1 = 0 ;
22297 PyObject *swig_obj[1] ;
22298
22299 if (!args) SWIG_fail;
22300 swig_obj[0] = args;
22301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22302 if (!SWIG_IsOK(res1)) {
22303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22304 }
22305 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22306 {
22307 PyThreadState* __tstate = wxPyBeginAllowThreads();
22308 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22309 wxPyEndAllowThreads(__tstate);
22310 if (PyErr_Occurred()) SWIG_fail;
22311 }
22312 {
22313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22314 }
22315 return resultobj;
22316 fail:
22317 return NULL;
22318 }
22319
22320
22321 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22322 PyObject *resultobj = 0;
22323 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22324 bool arg2 = (bool) true ;
22325 void *argp1 = 0 ;
22326 int res1 = 0 ;
22327 bool val2 ;
22328 int ecode2 = 0 ;
22329 PyObject * obj0 = 0 ;
22330 PyObject * obj1 = 0 ;
22331 char * kwnames[] = {
22332 (char *) "self",(char *) "doIt", NULL
22333 };
22334
22335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22337 if (!SWIG_IsOK(res1)) {
22338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22339 }
22340 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22341 if (obj1) {
22342 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22343 if (!SWIG_IsOK(ecode2)) {
22344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22345 }
22346 arg2 = static_cast< bool >(val2);
22347 }
22348 {
22349 PyThreadState* __tstate = wxPyBeginAllowThreads();
22350 (arg1)->SetRecordDefaults(arg2);
22351 wxPyEndAllowThreads(__tstate);
22352 if (PyErr_Occurred()) SWIG_fail;
22353 }
22354 resultobj = SWIG_Py_Void();
22355 return resultobj;
22356 fail:
22357 return NULL;
22358 }
22359
22360
22361 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22362 PyObject *resultobj = 0;
22363 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22364 bool result;
22365 void *argp1 = 0 ;
22366 int res1 = 0 ;
22367 PyObject *swig_obj[1] ;
22368
22369 if (!args) SWIG_fail;
22370 swig_obj[0] = args;
22371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22372 if (!SWIG_IsOK(res1)) {
22373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22374 }
22375 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22376 {
22377 PyThreadState* __tstate = wxPyBeginAllowThreads();
22378 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22379 wxPyEndAllowThreads(__tstate);
22380 if (PyErr_Occurred()) SWIG_fail;
22381 }
22382 {
22383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22384 }
22385 return resultobj;
22386 fail:
22387 return NULL;
22388 }
22389
22390
22391 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22392 PyObject *resultobj = 0;
22393 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22394 wxString *arg2 = 0 ;
22395 wxString result;
22396 void *argp1 = 0 ;
22397 int res1 = 0 ;
22398 bool temp2 = false ;
22399 PyObject * obj0 = 0 ;
22400 PyObject * obj1 = 0 ;
22401 char * kwnames[] = {
22402 (char *) "self",(char *) "str", NULL
22403 };
22404
22405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22407 if (!SWIG_IsOK(res1)) {
22408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22409 }
22410 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22411 {
22412 arg2 = wxString_in_helper(obj1);
22413 if (arg2 == NULL) SWIG_fail;
22414 temp2 = true;
22415 }
22416 {
22417 PyThreadState* __tstate = wxPyBeginAllowThreads();
22418 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22419 wxPyEndAllowThreads(__tstate);
22420 if (PyErr_Occurred()) SWIG_fail;
22421 }
22422 {
22423 #if wxUSE_UNICODE
22424 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22425 #else
22426 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22427 #endif
22428 }
22429 {
22430 if (temp2)
22431 delete arg2;
22432 }
22433 return resultobj;
22434 fail:
22435 {
22436 if (temp2)
22437 delete arg2;
22438 }
22439 return NULL;
22440 }
22441
22442
22443 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22444 PyObject *resultobj = 0;
22445 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22446 wxString result;
22447 void *argp1 = 0 ;
22448 int res1 = 0 ;
22449 PyObject *swig_obj[1] ;
22450
22451 if (!args) SWIG_fail;
22452 swig_obj[0] = args;
22453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22454 if (!SWIG_IsOK(res1)) {
22455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22456 }
22457 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22458 {
22459 PyThreadState* __tstate = wxPyBeginAllowThreads();
22460 result = ((wxConfigBase const *)arg1)->GetAppName();
22461 wxPyEndAllowThreads(__tstate);
22462 if (PyErr_Occurred()) SWIG_fail;
22463 }
22464 {
22465 #if wxUSE_UNICODE
22466 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22467 #else
22468 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22469 #endif
22470 }
22471 return resultobj;
22472 fail:
22473 return NULL;
22474 }
22475
22476
22477 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22478 PyObject *resultobj = 0;
22479 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22480 wxString result;
22481 void *argp1 = 0 ;
22482 int res1 = 0 ;
22483 PyObject *swig_obj[1] ;
22484
22485 if (!args) SWIG_fail;
22486 swig_obj[0] = args;
22487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22488 if (!SWIG_IsOK(res1)) {
22489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22490 }
22491 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22492 {
22493 PyThreadState* __tstate = wxPyBeginAllowThreads();
22494 result = ((wxConfigBase const *)arg1)->GetVendorName();
22495 wxPyEndAllowThreads(__tstate);
22496 if (PyErr_Occurred()) SWIG_fail;
22497 }
22498 {
22499 #if wxUSE_UNICODE
22500 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22501 #else
22502 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22503 #endif
22504 }
22505 return resultobj;
22506 fail:
22507 return NULL;
22508 }
22509
22510
22511 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22512 PyObject *resultobj = 0;
22513 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22514 wxString *arg2 = 0 ;
22515 void *argp1 = 0 ;
22516 int res1 = 0 ;
22517 bool temp2 = false ;
22518 PyObject * obj0 = 0 ;
22519 PyObject * obj1 = 0 ;
22520 char * kwnames[] = {
22521 (char *) "self",(char *) "appName", NULL
22522 };
22523
22524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22526 if (!SWIG_IsOK(res1)) {
22527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22528 }
22529 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22530 {
22531 arg2 = wxString_in_helper(obj1);
22532 if (arg2 == NULL) SWIG_fail;
22533 temp2 = true;
22534 }
22535 {
22536 PyThreadState* __tstate = wxPyBeginAllowThreads();
22537 (arg1)->SetAppName((wxString const &)*arg2);
22538 wxPyEndAllowThreads(__tstate);
22539 if (PyErr_Occurred()) SWIG_fail;
22540 }
22541 resultobj = SWIG_Py_Void();
22542 {
22543 if (temp2)
22544 delete arg2;
22545 }
22546 return resultobj;
22547 fail:
22548 {
22549 if (temp2)
22550 delete arg2;
22551 }
22552 return NULL;
22553 }
22554
22555
22556 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22557 PyObject *resultobj = 0;
22558 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22559 wxString *arg2 = 0 ;
22560 void *argp1 = 0 ;
22561 int res1 = 0 ;
22562 bool temp2 = false ;
22563 PyObject * obj0 = 0 ;
22564 PyObject * obj1 = 0 ;
22565 char * kwnames[] = {
22566 (char *) "self",(char *) "vendorName", NULL
22567 };
22568
22569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22571 if (!SWIG_IsOK(res1)) {
22572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22573 }
22574 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22575 {
22576 arg2 = wxString_in_helper(obj1);
22577 if (arg2 == NULL) SWIG_fail;
22578 temp2 = true;
22579 }
22580 {
22581 PyThreadState* __tstate = wxPyBeginAllowThreads();
22582 (arg1)->SetVendorName((wxString const &)*arg2);
22583 wxPyEndAllowThreads(__tstate);
22584 if (PyErr_Occurred()) SWIG_fail;
22585 }
22586 resultobj = SWIG_Py_Void();
22587 {
22588 if (temp2)
22589 delete arg2;
22590 }
22591 return resultobj;
22592 fail:
22593 {
22594 if (temp2)
22595 delete arg2;
22596 }
22597 return NULL;
22598 }
22599
22600
22601 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22602 PyObject *resultobj = 0;
22603 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22604 long arg2 ;
22605 void *argp1 = 0 ;
22606 int res1 = 0 ;
22607 long val2 ;
22608 int ecode2 = 0 ;
22609 PyObject * obj0 = 0 ;
22610 PyObject * obj1 = 0 ;
22611 char * kwnames[] = {
22612 (char *) "self",(char *) "style", NULL
22613 };
22614
22615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22617 if (!SWIG_IsOK(res1)) {
22618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22619 }
22620 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22621 ecode2 = SWIG_AsVal_long(obj1, &val2);
22622 if (!SWIG_IsOK(ecode2)) {
22623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22624 }
22625 arg2 = static_cast< long >(val2);
22626 {
22627 PyThreadState* __tstate = wxPyBeginAllowThreads();
22628 (arg1)->SetStyle(arg2);
22629 wxPyEndAllowThreads(__tstate);
22630 if (PyErr_Occurred()) SWIG_fail;
22631 }
22632 resultobj = SWIG_Py_Void();
22633 return resultobj;
22634 fail:
22635 return NULL;
22636 }
22637
22638
22639 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22640 PyObject *resultobj = 0;
22641 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22642 long result;
22643 void *argp1 = 0 ;
22644 int res1 = 0 ;
22645 PyObject *swig_obj[1] ;
22646
22647 if (!args) SWIG_fail;
22648 swig_obj[0] = args;
22649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22650 if (!SWIG_IsOK(res1)) {
22651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22652 }
22653 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22654 {
22655 PyThreadState* __tstate = wxPyBeginAllowThreads();
22656 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22657 wxPyEndAllowThreads(__tstate);
22658 if (PyErr_Occurred()) SWIG_fail;
22659 }
22660 resultobj = SWIG_From_long(static_cast< long >(result));
22661 return resultobj;
22662 fail:
22663 return NULL;
22664 }
22665
22666
22667 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22668 PyObject *obj;
22669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22670 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22671 return SWIG_Py_Void();
22672 }
22673
22674 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22675 PyObject *resultobj = 0;
22676 wxString const &arg1_defvalue = wxPyEmptyString ;
22677 wxString *arg1 = (wxString *) &arg1_defvalue ;
22678 wxString const &arg2_defvalue = wxPyEmptyString ;
22679 wxString *arg2 = (wxString *) &arg2_defvalue ;
22680 wxString const &arg3_defvalue = wxPyEmptyString ;
22681 wxString *arg3 = (wxString *) &arg3_defvalue ;
22682 wxString const &arg4_defvalue = wxPyEmptyString ;
22683 wxString *arg4 = (wxString *) &arg4_defvalue ;
22684 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22685 wxConfig *result = 0 ;
22686 bool temp1 = false ;
22687 bool temp2 = false ;
22688 bool temp3 = false ;
22689 bool temp4 = false ;
22690 long val5 ;
22691 int ecode5 = 0 ;
22692 PyObject * obj0 = 0 ;
22693 PyObject * obj1 = 0 ;
22694 PyObject * obj2 = 0 ;
22695 PyObject * obj3 = 0 ;
22696 PyObject * obj4 = 0 ;
22697 char * kwnames[] = {
22698 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22699 };
22700
22701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22702 if (obj0) {
22703 {
22704 arg1 = wxString_in_helper(obj0);
22705 if (arg1 == NULL) SWIG_fail;
22706 temp1 = true;
22707 }
22708 }
22709 if (obj1) {
22710 {
22711 arg2 = wxString_in_helper(obj1);
22712 if (arg2 == NULL) SWIG_fail;
22713 temp2 = true;
22714 }
22715 }
22716 if (obj2) {
22717 {
22718 arg3 = wxString_in_helper(obj2);
22719 if (arg3 == NULL) SWIG_fail;
22720 temp3 = true;
22721 }
22722 }
22723 if (obj3) {
22724 {
22725 arg4 = wxString_in_helper(obj3);
22726 if (arg4 == NULL) SWIG_fail;
22727 temp4 = true;
22728 }
22729 }
22730 if (obj4) {
22731 ecode5 = SWIG_AsVal_long(obj4, &val5);
22732 if (!SWIG_IsOK(ecode5)) {
22733 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22734 }
22735 arg5 = static_cast< long >(val5);
22736 }
22737 {
22738 PyThreadState* __tstate = wxPyBeginAllowThreads();
22739 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22740 wxPyEndAllowThreads(__tstate);
22741 if (PyErr_Occurred()) SWIG_fail;
22742 }
22743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22744 {
22745 if (temp1)
22746 delete arg1;
22747 }
22748 {
22749 if (temp2)
22750 delete arg2;
22751 }
22752 {
22753 if (temp3)
22754 delete arg3;
22755 }
22756 {
22757 if (temp4)
22758 delete arg4;
22759 }
22760 return resultobj;
22761 fail:
22762 {
22763 if (temp1)
22764 delete arg1;
22765 }
22766 {
22767 if (temp2)
22768 delete arg2;
22769 }
22770 {
22771 if (temp3)
22772 delete arg3;
22773 }
22774 {
22775 if (temp4)
22776 delete arg4;
22777 }
22778 return NULL;
22779 }
22780
22781
22782 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22783 PyObject *resultobj = 0;
22784 wxConfig *arg1 = (wxConfig *) 0 ;
22785 void *argp1 = 0 ;
22786 int res1 = 0 ;
22787 PyObject *swig_obj[1] ;
22788
22789 if (!args) SWIG_fail;
22790 swig_obj[0] = args;
22791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22792 if (!SWIG_IsOK(res1)) {
22793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22794 }
22795 arg1 = reinterpret_cast< wxConfig * >(argp1);
22796 {
22797 PyThreadState* __tstate = wxPyBeginAllowThreads();
22798 delete arg1;
22799
22800 wxPyEndAllowThreads(__tstate);
22801 if (PyErr_Occurred()) SWIG_fail;
22802 }
22803 resultobj = SWIG_Py_Void();
22804 return resultobj;
22805 fail:
22806 return NULL;
22807 }
22808
22809
22810 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22811 PyObject *obj;
22812 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22813 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22814 return SWIG_Py_Void();
22815 }
22816
22817 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22818 return SWIG_Python_InitShadowInstance(args);
22819 }
22820
22821 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22822 PyObject *resultobj = 0;
22823 wxString const &arg1_defvalue = wxPyEmptyString ;
22824 wxString *arg1 = (wxString *) &arg1_defvalue ;
22825 wxString const &arg2_defvalue = wxPyEmptyString ;
22826 wxString *arg2 = (wxString *) &arg2_defvalue ;
22827 wxString const &arg3_defvalue = wxPyEmptyString ;
22828 wxString *arg3 = (wxString *) &arg3_defvalue ;
22829 wxString const &arg4_defvalue = wxPyEmptyString ;
22830 wxString *arg4 = (wxString *) &arg4_defvalue ;
22831 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22832 wxFileConfig *result = 0 ;
22833 bool temp1 = false ;
22834 bool temp2 = false ;
22835 bool temp3 = false ;
22836 bool temp4 = false ;
22837 long val5 ;
22838 int ecode5 = 0 ;
22839 PyObject * obj0 = 0 ;
22840 PyObject * obj1 = 0 ;
22841 PyObject * obj2 = 0 ;
22842 PyObject * obj3 = 0 ;
22843 PyObject * obj4 = 0 ;
22844 char * kwnames[] = {
22845 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22846 };
22847
22848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22849 if (obj0) {
22850 {
22851 arg1 = wxString_in_helper(obj0);
22852 if (arg1 == NULL) SWIG_fail;
22853 temp1 = true;
22854 }
22855 }
22856 if (obj1) {
22857 {
22858 arg2 = wxString_in_helper(obj1);
22859 if (arg2 == NULL) SWIG_fail;
22860 temp2 = true;
22861 }
22862 }
22863 if (obj2) {
22864 {
22865 arg3 = wxString_in_helper(obj2);
22866 if (arg3 == NULL) SWIG_fail;
22867 temp3 = true;
22868 }
22869 }
22870 if (obj3) {
22871 {
22872 arg4 = wxString_in_helper(obj3);
22873 if (arg4 == NULL) SWIG_fail;
22874 temp4 = true;
22875 }
22876 }
22877 if (obj4) {
22878 ecode5 = SWIG_AsVal_long(obj4, &val5);
22879 if (!SWIG_IsOK(ecode5)) {
22880 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22881 }
22882 arg5 = static_cast< long >(val5);
22883 }
22884 {
22885 PyThreadState* __tstate = wxPyBeginAllowThreads();
22886 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22887 wxPyEndAllowThreads(__tstate);
22888 if (PyErr_Occurred()) SWIG_fail;
22889 }
22890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22891 {
22892 if (temp1)
22893 delete arg1;
22894 }
22895 {
22896 if (temp2)
22897 delete arg2;
22898 }
22899 {
22900 if (temp3)
22901 delete arg3;
22902 }
22903 {
22904 if (temp4)
22905 delete arg4;
22906 }
22907 return resultobj;
22908 fail:
22909 {
22910 if (temp1)
22911 delete arg1;
22912 }
22913 {
22914 if (temp2)
22915 delete arg2;
22916 }
22917 {
22918 if (temp3)
22919 delete arg3;
22920 }
22921 {
22922 if (temp4)
22923 delete arg4;
22924 }
22925 return NULL;
22926 }
22927
22928
22929 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22930 PyObject *resultobj = 0;
22931 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22932 void *argp1 = 0 ;
22933 int res1 = 0 ;
22934 PyObject *swig_obj[1] ;
22935
22936 if (!args) SWIG_fail;
22937 swig_obj[0] = args;
22938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22939 if (!SWIG_IsOK(res1)) {
22940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22941 }
22942 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22943 {
22944 PyThreadState* __tstate = wxPyBeginAllowThreads();
22945 delete arg1;
22946
22947 wxPyEndAllowThreads(__tstate);
22948 if (PyErr_Occurred()) SWIG_fail;
22949 }
22950 resultobj = SWIG_Py_Void();
22951 return resultobj;
22952 fail:
22953 return NULL;
22954 }
22955
22956
22957 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22958 PyObject *obj;
22959 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22960 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22961 return SWIG_Py_Void();
22962 }
22963
22964 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22965 return SWIG_Python_InitShadowInstance(args);
22966 }
22967
22968 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22969 PyObject *resultobj = 0;
22970 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22971 wxString *arg2 = 0 ;
22972 wxConfigPathChanger *result = 0 ;
22973 void *argp1 = 0 ;
22974 int res1 = 0 ;
22975 bool temp2 = false ;
22976 PyObject * obj0 = 0 ;
22977 PyObject * obj1 = 0 ;
22978 char * kwnames[] = {
22979 (char *) "config",(char *) "entry", NULL
22980 };
22981
22982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22984 if (!SWIG_IsOK(res1)) {
22985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22986 }
22987 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22988 {
22989 arg2 = wxString_in_helper(obj1);
22990 if (arg2 == NULL) SWIG_fail;
22991 temp2 = true;
22992 }
22993 {
22994 PyThreadState* __tstate = wxPyBeginAllowThreads();
22995 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22996 wxPyEndAllowThreads(__tstate);
22997 if (PyErr_Occurred()) SWIG_fail;
22998 }
22999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
23000 {
23001 if (temp2)
23002 delete arg2;
23003 }
23004 return resultobj;
23005 fail:
23006 {
23007 if (temp2)
23008 delete arg2;
23009 }
23010 return NULL;
23011 }
23012
23013
23014 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23015 PyObject *resultobj = 0;
23016 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23017 void *argp1 = 0 ;
23018 int res1 = 0 ;
23019 PyObject *swig_obj[1] ;
23020
23021 if (!args) SWIG_fail;
23022 swig_obj[0] = args;
23023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23024 if (!SWIG_IsOK(res1)) {
23025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23026 }
23027 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23028 {
23029 PyThreadState* __tstate = wxPyBeginAllowThreads();
23030 delete arg1;
23031
23032 wxPyEndAllowThreads(__tstate);
23033 if (PyErr_Occurred()) SWIG_fail;
23034 }
23035 resultobj = SWIG_Py_Void();
23036 return resultobj;
23037 fail:
23038 return NULL;
23039 }
23040
23041
23042 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23043 PyObject *resultobj = 0;
23044 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23045 wxString *result = 0 ;
23046 void *argp1 = 0 ;
23047 int res1 = 0 ;
23048 PyObject *swig_obj[1] ;
23049
23050 if (!args) SWIG_fail;
23051 swig_obj[0] = args;
23052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23053 if (!SWIG_IsOK(res1)) {
23054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23055 }
23056 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23057 {
23058 PyThreadState* __tstate = wxPyBeginAllowThreads();
23059 {
23060 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23061 result = (wxString *) &_result_ref;
23062 }
23063 wxPyEndAllowThreads(__tstate);
23064 if (PyErr_Occurred()) SWIG_fail;
23065 }
23066 {
23067 #if wxUSE_UNICODE
23068 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23069 #else
23070 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23071 #endif
23072 }
23073 return resultobj;
23074 fail:
23075 return NULL;
23076 }
23077
23078
23079 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23080 PyObject *obj;
23081 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23082 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23083 return SWIG_Py_Void();
23084 }
23085
23086 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23087 return SWIG_Python_InitShadowInstance(args);
23088 }
23089
23090 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23091 PyObject *resultobj = 0;
23092 wxString *arg1 = 0 ;
23093 wxString result;
23094 bool temp1 = false ;
23095 PyObject * obj0 = 0 ;
23096 char * kwnames[] = {
23097 (char *) "sz", NULL
23098 };
23099
23100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23101 {
23102 arg1 = wxString_in_helper(obj0);
23103 if (arg1 == NULL) SWIG_fail;
23104 temp1 = true;
23105 }
23106 {
23107 PyThreadState* __tstate = wxPyBeginAllowThreads();
23108 result = wxExpandEnvVars((wxString const &)*arg1);
23109 wxPyEndAllowThreads(__tstate);
23110 if (PyErr_Occurred()) SWIG_fail;
23111 }
23112 {
23113 #if wxUSE_UNICODE
23114 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23115 #else
23116 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23117 #endif
23118 }
23119 {
23120 if (temp1)
23121 delete arg1;
23122 }
23123 return resultobj;
23124 fail:
23125 {
23126 if (temp1)
23127 delete arg1;
23128 }
23129 return NULL;
23130 }
23131
23132
23133 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23134 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23135 return 1;
23136 }
23137
23138
23139 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23140 PyObject *pyobj = 0;
23141
23142 {
23143 #if wxUSE_UNICODE
23144 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23145 #else
23146 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23147 #endif
23148 }
23149 return pyobj;
23150 }
23151
23152
23153 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23154 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23155 return 1;
23156 }
23157
23158
23159 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23160 PyObject *pyobj = 0;
23161
23162 {
23163 #if wxUSE_UNICODE
23164 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23165 #else
23166 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23167 #endif
23168 }
23169 return pyobj;
23170 }
23171
23172
23173 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23174 PyObject *resultobj = 0;
23175 wxDateTime::Country arg1 ;
23176 int val1 ;
23177 int ecode1 = 0 ;
23178 PyObject * obj0 = 0 ;
23179 char * kwnames[] = {
23180 (char *) "country", NULL
23181 };
23182
23183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23184 ecode1 = SWIG_AsVal_int(obj0, &val1);
23185 if (!SWIG_IsOK(ecode1)) {
23186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23187 }
23188 arg1 = static_cast< wxDateTime::Country >(val1);
23189 {
23190 PyThreadState* __tstate = wxPyBeginAllowThreads();
23191 wxDateTime::SetCountry(arg1);
23192 wxPyEndAllowThreads(__tstate);
23193 if (PyErr_Occurred()) SWIG_fail;
23194 }
23195 resultobj = SWIG_Py_Void();
23196 return resultobj;
23197 fail:
23198 return NULL;
23199 }
23200
23201
23202 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23203 PyObject *resultobj = 0;
23204 wxDateTime::Country result;
23205
23206 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23207 {
23208 PyThreadState* __tstate = wxPyBeginAllowThreads();
23209 result = (wxDateTime::Country)wxDateTime::GetCountry();
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_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23221 PyObject *resultobj = 0;
23222 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23223 bool result;
23224 int val1 ;
23225 int ecode1 = 0 ;
23226 PyObject * obj0 = 0 ;
23227 char * kwnames[] = {
23228 (char *) "country", NULL
23229 };
23230
23231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",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_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23236 }
23237 arg1 = static_cast< wxDateTime::Country >(val1);
23238 }
23239 {
23240 PyThreadState* __tstate = wxPyBeginAllowThreads();
23241 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23242 wxPyEndAllowThreads(__tstate);
23243 if (PyErr_Occurred()) SWIG_fail;
23244 }
23245 {
23246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23247 }
23248 return resultobj;
23249 fail:
23250 return NULL;
23251 }
23252
23253
23254 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23255 PyObject *resultobj = 0;
23256 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23257 int result;
23258 int val1 ;
23259 int ecode1 = 0 ;
23260 PyObject * obj0 = 0 ;
23261 char * kwnames[] = {
23262 (char *) "cal", NULL
23263 };
23264
23265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23266 if (obj0) {
23267 ecode1 = SWIG_AsVal_int(obj0, &val1);
23268 if (!SWIG_IsOK(ecode1)) {
23269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23270 }
23271 arg1 = static_cast< wxDateTime::Calendar >(val1);
23272 }
23273 {
23274 PyThreadState* __tstate = wxPyBeginAllowThreads();
23275 result = (int)wxDateTime::GetCurrentYear(arg1);
23276 wxPyEndAllowThreads(__tstate);
23277 if (PyErr_Occurred()) SWIG_fail;
23278 }
23279 resultobj = SWIG_From_int(static_cast< int >(result));
23280 return resultobj;
23281 fail:
23282 return NULL;
23283 }
23284
23285
23286 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23287 PyObject *resultobj = 0;
23288 int arg1 ;
23289 int result;
23290 int val1 ;
23291 int ecode1 = 0 ;
23292 PyObject * obj0 = 0 ;
23293 char * kwnames[] = {
23294 (char *) "year", NULL
23295 };
23296
23297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23298 ecode1 = SWIG_AsVal_int(obj0, &val1);
23299 if (!SWIG_IsOK(ecode1)) {
23300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23301 }
23302 arg1 = static_cast< int >(val1);
23303 {
23304 PyThreadState* __tstate = wxPyBeginAllowThreads();
23305 result = (int)wxDateTime::ConvertYearToBC(arg1);
23306 wxPyEndAllowThreads(__tstate);
23307 if (PyErr_Occurred()) SWIG_fail;
23308 }
23309 resultobj = SWIG_From_int(static_cast< int >(result));
23310 return resultobj;
23311 fail:
23312 return NULL;
23313 }
23314
23315
23316 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23317 PyObject *resultobj = 0;
23318 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23319 wxDateTime::Month result;
23320 int val1 ;
23321 int ecode1 = 0 ;
23322 PyObject * obj0 = 0 ;
23323 char * kwnames[] = {
23324 (char *) "cal", NULL
23325 };
23326
23327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23328 if (obj0) {
23329 ecode1 = SWIG_AsVal_int(obj0, &val1);
23330 if (!SWIG_IsOK(ecode1)) {
23331 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23332 }
23333 arg1 = static_cast< wxDateTime::Calendar >(val1);
23334 }
23335 {
23336 PyThreadState* __tstate = wxPyBeginAllowThreads();
23337 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23338 wxPyEndAllowThreads(__tstate);
23339 if (PyErr_Occurred()) SWIG_fail;
23340 }
23341 resultobj = SWIG_From_int(static_cast< int >(result));
23342 return resultobj;
23343 fail:
23344 return NULL;
23345 }
23346
23347
23348 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23349 PyObject *resultobj = 0;
23350 int arg1 = (int) wxDateTime::Inv_Year ;
23351 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23352 bool result;
23353 int val1 ;
23354 int ecode1 = 0 ;
23355 int val2 ;
23356 int ecode2 = 0 ;
23357 PyObject * obj0 = 0 ;
23358 PyObject * obj1 = 0 ;
23359 char * kwnames[] = {
23360 (char *) "year",(char *) "cal", NULL
23361 };
23362
23363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23364 if (obj0) {
23365 ecode1 = SWIG_AsVal_int(obj0, &val1);
23366 if (!SWIG_IsOK(ecode1)) {
23367 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23368 }
23369 arg1 = static_cast< int >(val1);
23370 }
23371 if (obj1) {
23372 ecode2 = SWIG_AsVal_int(obj1, &val2);
23373 if (!SWIG_IsOK(ecode2)) {
23374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23375 }
23376 arg2 = static_cast< wxDateTime::Calendar >(val2);
23377 }
23378 {
23379 PyThreadState* __tstate = wxPyBeginAllowThreads();
23380 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23381 wxPyEndAllowThreads(__tstate);
23382 if (PyErr_Occurred()) SWIG_fail;
23383 }
23384 {
23385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23386 }
23387 return resultobj;
23388 fail:
23389 return NULL;
23390 }
23391
23392
23393 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23394 PyObject *resultobj = 0;
23395 int arg1 = (int) wxDateTime::Inv_Year ;
23396 int result;
23397 int val1 ;
23398 int ecode1 = 0 ;
23399 PyObject * obj0 = 0 ;
23400 char * kwnames[] = {
23401 (char *) "year", NULL
23402 };
23403
23404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23405 if (obj0) {
23406 ecode1 = SWIG_AsVal_int(obj0, &val1);
23407 if (!SWIG_IsOK(ecode1)) {
23408 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23409 }
23410 arg1 = static_cast< int >(val1);
23411 }
23412 {
23413 PyThreadState* __tstate = wxPyBeginAllowThreads();
23414 result = (int)wxDateTime::GetCentury(arg1);
23415 wxPyEndAllowThreads(__tstate);
23416 if (PyErr_Occurred()) SWIG_fail;
23417 }
23418 resultobj = SWIG_From_int(static_cast< int >(result));
23419 return resultobj;
23420 fail:
23421 return NULL;
23422 }
23423
23424
23425 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23426 PyObject *resultobj = 0;
23427 int arg1 ;
23428 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23429 int result;
23430 int val1 ;
23431 int ecode1 = 0 ;
23432 int val2 ;
23433 int ecode2 = 0 ;
23434 PyObject * obj0 = 0 ;
23435 PyObject * obj1 = 0 ;
23436 char * kwnames[] = {
23437 (char *) "year",(char *) "cal", NULL
23438 };
23439
23440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23441 ecode1 = SWIG_AsVal_int(obj0, &val1);
23442 if (!SWIG_IsOK(ecode1)) {
23443 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23444 }
23445 arg1 = static_cast< int >(val1);
23446 if (obj1) {
23447 ecode2 = SWIG_AsVal_int(obj1, &val2);
23448 if (!SWIG_IsOK(ecode2)) {
23449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23450 }
23451 arg2 = static_cast< wxDateTime::Calendar >(val2);
23452 }
23453 {
23454 PyThreadState* __tstate = wxPyBeginAllowThreads();
23455 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23456 wxPyEndAllowThreads(__tstate);
23457 if (PyErr_Occurred()) SWIG_fail;
23458 }
23459 resultobj = SWIG_From_int(static_cast< int >(result));
23460 return resultobj;
23461 fail:
23462 return NULL;
23463 }
23464
23465
23466 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23467 PyObject *resultobj = 0;
23468 wxDateTime::Month arg1 ;
23469 int arg2 = (int) wxDateTime::Inv_Year ;
23470 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23471 int result;
23472 int val1 ;
23473 int ecode1 = 0 ;
23474 int val2 ;
23475 int ecode2 = 0 ;
23476 int val3 ;
23477 int ecode3 = 0 ;
23478 PyObject * obj0 = 0 ;
23479 PyObject * obj1 = 0 ;
23480 PyObject * obj2 = 0 ;
23481 char * kwnames[] = {
23482 (char *) "month",(char *) "year",(char *) "cal", NULL
23483 };
23484
23485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23486 ecode1 = SWIG_AsVal_int(obj0, &val1);
23487 if (!SWIG_IsOK(ecode1)) {
23488 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23489 }
23490 arg1 = static_cast< wxDateTime::Month >(val1);
23491 if (obj1) {
23492 ecode2 = SWIG_AsVal_int(obj1, &val2);
23493 if (!SWIG_IsOK(ecode2)) {
23494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23495 }
23496 arg2 = static_cast< int >(val2);
23497 }
23498 if (obj2) {
23499 ecode3 = SWIG_AsVal_int(obj2, &val3);
23500 if (!SWIG_IsOK(ecode3)) {
23501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23502 }
23503 arg3 = static_cast< wxDateTime::Calendar >(val3);
23504 }
23505 {
23506 PyThreadState* __tstate = wxPyBeginAllowThreads();
23507 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23508 wxPyEndAllowThreads(__tstate);
23509 if (PyErr_Occurred()) SWIG_fail;
23510 }
23511 resultobj = SWIG_From_int(static_cast< int >(result));
23512 return resultobj;
23513 fail:
23514 return NULL;
23515 }
23516
23517
23518 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23519 PyObject *resultobj = 0;
23520 wxDateTime::Month arg1 ;
23521 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23522 wxString result;
23523 int val1 ;
23524 int ecode1 = 0 ;
23525 int val2 ;
23526 int ecode2 = 0 ;
23527 PyObject * obj0 = 0 ;
23528 PyObject * obj1 = 0 ;
23529 char * kwnames[] = {
23530 (char *) "month",(char *) "flags", NULL
23531 };
23532
23533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23534 ecode1 = SWIG_AsVal_int(obj0, &val1);
23535 if (!SWIG_IsOK(ecode1)) {
23536 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23537 }
23538 arg1 = static_cast< wxDateTime::Month >(val1);
23539 if (obj1) {
23540 ecode2 = SWIG_AsVal_int(obj1, &val2);
23541 if (!SWIG_IsOK(ecode2)) {
23542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23543 }
23544 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23545 }
23546 {
23547 PyThreadState* __tstate = wxPyBeginAllowThreads();
23548 result = wxDateTime::GetMonthName(arg1,arg2);
23549 wxPyEndAllowThreads(__tstate);
23550 if (PyErr_Occurred()) SWIG_fail;
23551 }
23552 {
23553 #if wxUSE_UNICODE
23554 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23555 #else
23556 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23557 #endif
23558 }
23559 return resultobj;
23560 fail:
23561 return NULL;
23562 }
23563
23564
23565 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23566 PyObject *resultobj = 0;
23567 wxDateTime::WeekDay arg1 ;
23568 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23569 wxString result;
23570 int val1 ;
23571 int ecode1 = 0 ;
23572 int val2 ;
23573 int ecode2 = 0 ;
23574 PyObject * obj0 = 0 ;
23575 PyObject * obj1 = 0 ;
23576 char * kwnames[] = {
23577 (char *) "weekday",(char *) "flags", NULL
23578 };
23579
23580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23581 ecode1 = SWIG_AsVal_int(obj0, &val1);
23582 if (!SWIG_IsOK(ecode1)) {
23583 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23584 }
23585 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23586 if (obj1) {
23587 ecode2 = SWIG_AsVal_int(obj1, &val2);
23588 if (!SWIG_IsOK(ecode2)) {
23589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23590 }
23591 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23592 }
23593 {
23594 PyThreadState* __tstate = wxPyBeginAllowThreads();
23595 result = wxDateTime::GetWeekDayName(arg1,arg2);
23596 wxPyEndAllowThreads(__tstate);
23597 if (PyErr_Occurred()) SWIG_fail;
23598 }
23599 {
23600 #if wxUSE_UNICODE
23601 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23602 #else
23603 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23604 #endif
23605 }
23606 return resultobj;
23607 fail:
23608 return NULL;
23609 }
23610
23611
23612 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23613 PyObject *resultobj = 0;
23614 PyObject *result = 0 ;
23615
23616 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23617 {
23618 PyThreadState* __tstate = wxPyBeginAllowThreads();
23619 result = (PyObject *)wxDateTime_GetAmPmStrings();
23620 wxPyEndAllowThreads(__tstate);
23621 if (PyErr_Occurred()) SWIG_fail;
23622 }
23623 resultobj = result;
23624 return resultobj;
23625 fail:
23626 return NULL;
23627 }
23628
23629
23630 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23631 PyObject *resultobj = 0;
23632 int arg1 = (int) wxDateTime::Inv_Year ;
23633 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23634 bool result;
23635 int val1 ;
23636 int ecode1 = 0 ;
23637 int val2 ;
23638 int ecode2 = 0 ;
23639 PyObject * obj0 = 0 ;
23640 PyObject * obj1 = 0 ;
23641 char * kwnames[] = {
23642 (char *) "year",(char *) "country", NULL
23643 };
23644
23645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23646 if (obj0) {
23647 ecode1 = SWIG_AsVal_int(obj0, &val1);
23648 if (!SWIG_IsOK(ecode1)) {
23649 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23650 }
23651 arg1 = static_cast< int >(val1);
23652 }
23653 if (obj1) {
23654 ecode2 = SWIG_AsVal_int(obj1, &val2);
23655 if (!SWIG_IsOK(ecode2)) {
23656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23657 }
23658 arg2 = static_cast< wxDateTime::Country >(val2);
23659 }
23660 {
23661 PyThreadState* __tstate = wxPyBeginAllowThreads();
23662 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23663 wxPyEndAllowThreads(__tstate);
23664 if (PyErr_Occurred()) SWIG_fail;
23665 }
23666 {
23667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23668 }
23669 return resultobj;
23670 fail:
23671 return NULL;
23672 }
23673
23674
23675 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23676 PyObject *resultobj = 0;
23677 int arg1 = (int) wxDateTime::Inv_Year ;
23678 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23679 wxDateTime result;
23680 int val1 ;
23681 int ecode1 = 0 ;
23682 int val2 ;
23683 int ecode2 = 0 ;
23684 PyObject * obj0 = 0 ;
23685 PyObject * obj1 = 0 ;
23686 char * kwnames[] = {
23687 (char *) "year",(char *) "country", NULL
23688 };
23689
23690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23691 if (obj0) {
23692 ecode1 = SWIG_AsVal_int(obj0, &val1);
23693 if (!SWIG_IsOK(ecode1)) {
23694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23695 }
23696 arg1 = static_cast< int >(val1);
23697 }
23698 if (obj1) {
23699 ecode2 = SWIG_AsVal_int(obj1, &val2);
23700 if (!SWIG_IsOK(ecode2)) {
23701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23702 }
23703 arg2 = static_cast< wxDateTime::Country >(val2);
23704 }
23705 {
23706 PyThreadState* __tstate = wxPyBeginAllowThreads();
23707 result = wxDateTime::GetBeginDST(arg1,arg2);
23708 wxPyEndAllowThreads(__tstate);
23709 if (PyErr_Occurred()) SWIG_fail;
23710 }
23711 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23712 return resultobj;
23713 fail:
23714 return NULL;
23715 }
23716
23717
23718 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23719 PyObject *resultobj = 0;
23720 int arg1 = (int) wxDateTime::Inv_Year ;
23721 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23722 wxDateTime result;
23723 int val1 ;
23724 int ecode1 = 0 ;
23725 int val2 ;
23726 int ecode2 = 0 ;
23727 PyObject * obj0 = 0 ;
23728 PyObject * obj1 = 0 ;
23729 char * kwnames[] = {
23730 (char *) "year",(char *) "country", NULL
23731 };
23732
23733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23734 if (obj0) {
23735 ecode1 = SWIG_AsVal_int(obj0, &val1);
23736 if (!SWIG_IsOK(ecode1)) {
23737 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23738 }
23739 arg1 = static_cast< int >(val1);
23740 }
23741 if (obj1) {
23742 ecode2 = SWIG_AsVal_int(obj1, &val2);
23743 if (!SWIG_IsOK(ecode2)) {
23744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23745 }
23746 arg2 = static_cast< wxDateTime::Country >(val2);
23747 }
23748 {
23749 PyThreadState* __tstate = wxPyBeginAllowThreads();
23750 result = wxDateTime::GetEndDST(arg1,arg2);
23751 wxPyEndAllowThreads(__tstate);
23752 if (PyErr_Occurred()) SWIG_fail;
23753 }
23754 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23755 return resultobj;
23756 fail:
23757 return NULL;
23758 }
23759
23760
23761 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23762 PyObject *resultobj = 0;
23763 wxDateTime result;
23764
23765 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23766 {
23767 PyThreadState* __tstate = wxPyBeginAllowThreads();
23768 result = wxDateTime::Now();
23769 wxPyEndAllowThreads(__tstate);
23770 if (PyErr_Occurred()) SWIG_fail;
23771 }
23772 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23773 return resultobj;
23774 fail:
23775 return NULL;
23776 }
23777
23778
23779 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23780 PyObject *resultobj = 0;
23781 wxDateTime result;
23782
23783 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23784 {
23785 PyThreadState* __tstate = wxPyBeginAllowThreads();
23786 result = wxDateTime::UNow();
23787 wxPyEndAllowThreads(__tstate);
23788 if (PyErr_Occurred()) SWIG_fail;
23789 }
23790 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23791 return resultobj;
23792 fail:
23793 return NULL;
23794 }
23795
23796
23797 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23798 PyObject *resultobj = 0;
23799 wxDateTime result;
23800
23801 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23802 {
23803 PyThreadState* __tstate = wxPyBeginAllowThreads();
23804 result = wxDateTime::Today();
23805 wxPyEndAllowThreads(__tstate);
23806 if (PyErr_Occurred()) SWIG_fail;
23807 }
23808 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23809 return resultobj;
23810 fail:
23811 return NULL;
23812 }
23813
23814
23815 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23816 PyObject *resultobj = 0;
23817 wxDateTime *result = 0 ;
23818
23819 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23820 {
23821 PyThreadState* __tstate = wxPyBeginAllowThreads();
23822 result = (wxDateTime *)new wxDateTime();
23823 wxPyEndAllowThreads(__tstate);
23824 if (PyErr_Occurred()) SWIG_fail;
23825 }
23826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23827 return resultobj;
23828 fail:
23829 return NULL;
23830 }
23831
23832
23833 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23834 PyObject *resultobj = 0;
23835 time_t arg1 ;
23836 wxDateTime *result = 0 ;
23837 unsigned int val1 ;
23838 int ecode1 = 0 ;
23839 PyObject * obj0 = 0 ;
23840 char * kwnames[] = {
23841 (char *) "timet", NULL
23842 };
23843
23844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23845 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23846 if (!SWIG_IsOK(ecode1)) {
23847 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23848 }
23849 arg1 = static_cast< time_t >(val1);
23850 {
23851 PyThreadState* __tstate = wxPyBeginAllowThreads();
23852 result = (wxDateTime *)new wxDateTime(arg1);
23853 wxPyEndAllowThreads(__tstate);
23854 if (PyErr_Occurred()) SWIG_fail;
23855 }
23856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23857 return resultobj;
23858 fail:
23859 return NULL;
23860 }
23861
23862
23863 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23864 PyObject *resultobj = 0;
23865 double arg1 ;
23866 wxDateTime *result = 0 ;
23867 double val1 ;
23868 int ecode1 = 0 ;
23869 PyObject * obj0 = 0 ;
23870 char * kwnames[] = {
23871 (char *) "jdn", NULL
23872 };
23873
23874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23875 ecode1 = SWIG_AsVal_double(obj0, &val1);
23876 if (!SWIG_IsOK(ecode1)) {
23877 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23878 }
23879 arg1 = static_cast< double >(val1);
23880 {
23881 PyThreadState* __tstate = wxPyBeginAllowThreads();
23882 result = (wxDateTime *)new wxDateTime(arg1);
23883 wxPyEndAllowThreads(__tstate);
23884 if (PyErr_Occurred()) SWIG_fail;
23885 }
23886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23887 return resultobj;
23888 fail:
23889 return NULL;
23890 }
23891
23892
23893 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23894 PyObject *resultobj = 0;
23895 int arg1 ;
23896 int arg2 = (int) 0 ;
23897 int arg3 = (int) 0 ;
23898 int arg4 = (int) 0 ;
23899 wxDateTime *result = 0 ;
23900 int val1 ;
23901 int ecode1 = 0 ;
23902 int val2 ;
23903 int ecode2 = 0 ;
23904 int val3 ;
23905 int ecode3 = 0 ;
23906 int val4 ;
23907 int ecode4 = 0 ;
23908 PyObject * obj0 = 0 ;
23909 PyObject * obj1 = 0 ;
23910 PyObject * obj2 = 0 ;
23911 PyObject * obj3 = 0 ;
23912 char * kwnames[] = {
23913 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23914 };
23915
23916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23917 ecode1 = SWIG_AsVal_int(obj0, &val1);
23918 if (!SWIG_IsOK(ecode1)) {
23919 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23920 }
23921 arg1 = static_cast< int >(val1);
23922 if (obj1) {
23923 ecode2 = SWIG_AsVal_int(obj1, &val2);
23924 if (!SWIG_IsOK(ecode2)) {
23925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23926 }
23927 arg2 = static_cast< int >(val2);
23928 }
23929 if (obj2) {
23930 ecode3 = SWIG_AsVal_int(obj2, &val3);
23931 if (!SWIG_IsOK(ecode3)) {
23932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23933 }
23934 arg3 = static_cast< int >(val3);
23935 }
23936 if (obj3) {
23937 ecode4 = SWIG_AsVal_int(obj3, &val4);
23938 if (!SWIG_IsOK(ecode4)) {
23939 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23940 }
23941 arg4 = static_cast< int >(val4);
23942 }
23943 {
23944 PyThreadState* __tstate = wxPyBeginAllowThreads();
23945 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
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_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23957 PyObject *resultobj = 0;
23958 int arg1 ;
23959 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23960 int arg3 = (int) wxDateTime::Inv_Year ;
23961 int arg4 = (int) 0 ;
23962 int arg5 = (int) 0 ;
23963 int arg6 = (int) 0 ;
23964 int arg7 = (int) 0 ;
23965 wxDateTime *result = 0 ;
23966 int val1 ;
23967 int ecode1 = 0 ;
23968 int val2 ;
23969 int ecode2 = 0 ;
23970 int val3 ;
23971 int ecode3 = 0 ;
23972 int val4 ;
23973 int ecode4 = 0 ;
23974 int val5 ;
23975 int ecode5 = 0 ;
23976 int val6 ;
23977 int ecode6 = 0 ;
23978 int val7 ;
23979 int ecode7 = 0 ;
23980 PyObject * obj0 = 0 ;
23981 PyObject * obj1 = 0 ;
23982 PyObject * obj2 = 0 ;
23983 PyObject * obj3 = 0 ;
23984 PyObject * obj4 = 0 ;
23985 PyObject * obj5 = 0 ;
23986 PyObject * obj6 = 0 ;
23987 char * kwnames[] = {
23988 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23989 };
23990
23991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23992 ecode1 = SWIG_AsVal_int(obj0, &val1);
23993 if (!SWIG_IsOK(ecode1)) {
23994 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23995 }
23996 arg1 = static_cast< int >(val1);
23997 if (obj1) {
23998 ecode2 = SWIG_AsVal_int(obj1, &val2);
23999 if (!SWIG_IsOK(ecode2)) {
24000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24001 }
24002 arg2 = static_cast< wxDateTime::Month >(val2);
24003 }
24004 if (obj2) {
24005 ecode3 = SWIG_AsVal_int(obj2, &val3);
24006 if (!SWIG_IsOK(ecode3)) {
24007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24008 }
24009 arg3 = static_cast< int >(val3);
24010 }
24011 if (obj3) {
24012 ecode4 = SWIG_AsVal_int(obj3, &val4);
24013 if (!SWIG_IsOK(ecode4)) {
24014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24015 }
24016 arg4 = static_cast< int >(val4);
24017 }
24018 if (obj4) {
24019 ecode5 = SWIG_AsVal_int(obj4, &val5);
24020 if (!SWIG_IsOK(ecode5)) {
24021 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24022 }
24023 arg5 = static_cast< int >(val5);
24024 }
24025 if (obj5) {
24026 ecode6 = SWIG_AsVal_int(obj5, &val6);
24027 if (!SWIG_IsOK(ecode6)) {
24028 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24029 }
24030 arg6 = static_cast< int >(val6);
24031 }
24032 if (obj6) {
24033 ecode7 = SWIG_AsVal_int(obj6, &val7);
24034 if (!SWIG_IsOK(ecode7)) {
24035 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24036 }
24037 arg7 = static_cast< int >(val7);
24038 }
24039 {
24040 PyThreadState* __tstate = wxPyBeginAllowThreads();
24041 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24042 wxPyEndAllowThreads(__tstate);
24043 if (PyErr_Occurred()) SWIG_fail;
24044 }
24045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24046 return resultobj;
24047 fail:
24048 return NULL;
24049 }
24050
24051
24052 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24053 PyObject *resultobj = 0;
24054 wxDateTime *arg1 = 0 ;
24055 wxDateTime *result = 0 ;
24056 void *argp1 = 0 ;
24057 int res1 = 0 ;
24058 PyObject * obj0 = 0 ;
24059 char * kwnames[] = {
24060 (char *) "date", NULL
24061 };
24062
24063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) 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 '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24067 }
24068 if (!argp1) {
24069 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24070 }
24071 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24072 {
24073 PyThreadState* __tstate = wxPyBeginAllowThreads();
24074 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24075 wxPyEndAllowThreads(__tstate);
24076 if (PyErr_Occurred()) SWIG_fail;
24077 }
24078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24079 return resultobj;
24080 fail:
24081 return NULL;
24082 }
24083
24084
24085 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24086 PyObject *resultobj = 0;
24087 wxDateTime *arg1 = (wxDateTime *) 0 ;
24088 void *argp1 = 0 ;
24089 int res1 = 0 ;
24090 PyObject *swig_obj[1] ;
24091
24092 if (!args) SWIG_fail;
24093 swig_obj[0] = args;
24094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24095 if (!SWIG_IsOK(res1)) {
24096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24097 }
24098 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24099 {
24100 PyThreadState* __tstate = wxPyBeginAllowThreads();
24101 delete arg1;
24102
24103 wxPyEndAllowThreads(__tstate);
24104 if (PyErr_Occurred()) SWIG_fail;
24105 }
24106 resultobj = SWIG_Py_Void();
24107 return resultobj;
24108 fail:
24109 return NULL;
24110 }
24111
24112
24113 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24114 PyObject *resultobj = 0;
24115 wxDateTime *arg1 = (wxDateTime *) 0 ;
24116 wxDateTime *result = 0 ;
24117 void *argp1 = 0 ;
24118 int res1 = 0 ;
24119 PyObject *swig_obj[1] ;
24120
24121 if (!args) SWIG_fail;
24122 swig_obj[0] = args;
24123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24124 if (!SWIG_IsOK(res1)) {
24125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24126 }
24127 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24128 {
24129 PyThreadState* __tstate = wxPyBeginAllowThreads();
24130 {
24131 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24132 result = (wxDateTime *) &_result_ref;
24133 }
24134 wxPyEndAllowThreads(__tstate);
24135 if (PyErr_Occurred()) SWIG_fail;
24136 }
24137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24138 return resultobj;
24139 fail:
24140 return NULL;
24141 }
24142
24143
24144 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24145 PyObject *resultobj = 0;
24146 wxDateTime *arg1 = (wxDateTime *) 0 ;
24147 time_t arg2 ;
24148 wxDateTime *result = 0 ;
24149 void *argp1 = 0 ;
24150 int res1 = 0 ;
24151 unsigned int val2 ;
24152 int ecode2 = 0 ;
24153 PyObject * obj0 = 0 ;
24154 PyObject * obj1 = 0 ;
24155 char * kwnames[] = {
24156 (char *) "self",(char *) "timet", NULL
24157 };
24158
24159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) 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_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24163 }
24164 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24165 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24166 if (!SWIG_IsOK(ecode2)) {
24167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24168 }
24169 arg2 = static_cast< time_t >(val2);
24170 {
24171 PyThreadState* __tstate = wxPyBeginAllowThreads();
24172 {
24173 wxDateTime &_result_ref = (arg1)->Set(arg2);
24174 result = (wxDateTime *) &_result_ref;
24175 }
24176 wxPyEndAllowThreads(__tstate);
24177 if (PyErr_Occurred()) SWIG_fail;
24178 }
24179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24180 return resultobj;
24181 fail:
24182 return NULL;
24183 }
24184
24185
24186 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24187 PyObject *resultobj = 0;
24188 wxDateTime *arg1 = (wxDateTime *) 0 ;
24189 double arg2 ;
24190 wxDateTime *result = 0 ;
24191 void *argp1 = 0 ;
24192 int res1 = 0 ;
24193 double val2 ;
24194 int ecode2 = 0 ;
24195 PyObject * obj0 = 0 ;
24196 PyObject * obj1 = 0 ;
24197 char * kwnames[] = {
24198 (char *) "self",(char *) "jdn", NULL
24199 };
24200
24201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24203 if (!SWIG_IsOK(res1)) {
24204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24205 }
24206 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24207 ecode2 = SWIG_AsVal_double(obj1, &val2);
24208 if (!SWIG_IsOK(ecode2)) {
24209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24210 }
24211 arg2 = static_cast< double >(val2);
24212 {
24213 PyThreadState* __tstate = wxPyBeginAllowThreads();
24214 {
24215 wxDateTime &_result_ref = (arg1)->Set(arg2);
24216 result = (wxDateTime *) &_result_ref;
24217 }
24218 wxPyEndAllowThreads(__tstate);
24219 if (PyErr_Occurred()) SWIG_fail;
24220 }
24221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24222 return resultobj;
24223 fail:
24224 return NULL;
24225 }
24226
24227
24228 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24229 PyObject *resultobj = 0;
24230 wxDateTime *arg1 = (wxDateTime *) 0 ;
24231 int arg2 ;
24232 int arg3 = (int) 0 ;
24233 int arg4 = (int) 0 ;
24234 int arg5 = (int) 0 ;
24235 wxDateTime *result = 0 ;
24236 void *argp1 = 0 ;
24237 int res1 = 0 ;
24238 int val2 ;
24239 int ecode2 = 0 ;
24240 int val3 ;
24241 int ecode3 = 0 ;
24242 int val4 ;
24243 int ecode4 = 0 ;
24244 int val5 ;
24245 int ecode5 = 0 ;
24246 PyObject * obj0 = 0 ;
24247 PyObject * obj1 = 0 ;
24248 PyObject * obj2 = 0 ;
24249 PyObject * obj3 = 0 ;
24250 PyObject * obj4 = 0 ;
24251 char * kwnames[] = {
24252 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24253 };
24254
24255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24257 if (!SWIG_IsOK(res1)) {
24258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24259 }
24260 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24261 ecode2 = SWIG_AsVal_int(obj1, &val2);
24262 if (!SWIG_IsOK(ecode2)) {
24263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24264 }
24265 arg2 = static_cast< int >(val2);
24266 if (obj2) {
24267 ecode3 = SWIG_AsVal_int(obj2, &val3);
24268 if (!SWIG_IsOK(ecode3)) {
24269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24270 }
24271 arg3 = static_cast< int >(val3);
24272 }
24273 if (obj3) {
24274 ecode4 = SWIG_AsVal_int(obj3, &val4);
24275 if (!SWIG_IsOK(ecode4)) {
24276 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24277 }
24278 arg4 = static_cast< int >(val4);
24279 }
24280 if (obj4) {
24281 ecode5 = SWIG_AsVal_int(obj4, &val5);
24282 if (!SWIG_IsOK(ecode5)) {
24283 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24284 }
24285 arg5 = static_cast< int >(val5);
24286 }
24287 {
24288 PyThreadState* __tstate = wxPyBeginAllowThreads();
24289 {
24290 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24291 result = (wxDateTime *) &_result_ref;
24292 }
24293 wxPyEndAllowThreads(__tstate);
24294 if (PyErr_Occurred()) SWIG_fail;
24295 }
24296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24297 return resultobj;
24298 fail:
24299 return NULL;
24300 }
24301
24302
24303 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24304 PyObject *resultobj = 0;
24305 wxDateTime *arg1 = (wxDateTime *) 0 ;
24306 int arg2 ;
24307 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24308 int arg4 = (int) wxDateTime::Inv_Year ;
24309 int arg5 = (int) 0 ;
24310 int arg6 = (int) 0 ;
24311 int arg7 = (int) 0 ;
24312 int arg8 = (int) 0 ;
24313 wxDateTime *result = 0 ;
24314 void *argp1 = 0 ;
24315 int res1 = 0 ;
24316 int val2 ;
24317 int ecode2 = 0 ;
24318 int val3 ;
24319 int ecode3 = 0 ;
24320 int val4 ;
24321 int ecode4 = 0 ;
24322 int val5 ;
24323 int ecode5 = 0 ;
24324 int val6 ;
24325 int ecode6 = 0 ;
24326 int val7 ;
24327 int ecode7 = 0 ;
24328 int val8 ;
24329 int ecode8 = 0 ;
24330 PyObject * obj0 = 0 ;
24331 PyObject * obj1 = 0 ;
24332 PyObject * obj2 = 0 ;
24333 PyObject * obj3 = 0 ;
24334 PyObject * obj4 = 0 ;
24335 PyObject * obj5 = 0 ;
24336 PyObject * obj6 = 0 ;
24337 PyObject * obj7 = 0 ;
24338 char * kwnames[] = {
24339 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24340 };
24341
24342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24344 if (!SWIG_IsOK(res1)) {
24345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24346 }
24347 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24348 ecode2 = SWIG_AsVal_int(obj1, &val2);
24349 if (!SWIG_IsOK(ecode2)) {
24350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24351 }
24352 arg2 = static_cast< int >(val2);
24353 if (obj2) {
24354 ecode3 = SWIG_AsVal_int(obj2, &val3);
24355 if (!SWIG_IsOK(ecode3)) {
24356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24357 }
24358 arg3 = static_cast< wxDateTime::Month >(val3);
24359 }
24360 if (obj3) {
24361 ecode4 = SWIG_AsVal_int(obj3, &val4);
24362 if (!SWIG_IsOK(ecode4)) {
24363 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24364 }
24365 arg4 = static_cast< int >(val4);
24366 }
24367 if (obj4) {
24368 ecode5 = SWIG_AsVal_int(obj4, &val5);
24369 if (!SWIG_IsOK(ecode5)) {
24370 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24371 }
24372 arg5 = static_cast< int >(val5);
24373 }
24374 if (obj5) {
24375 ecode6 = SWIG_AsVal_int(obj5, &val6);
24376 if (!SWIG_IsOK(ecode6)) {
24377 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24378 }
24379 arg6 = static_cast< int >(val6);
24380 }
24381 if (obj6) {
24382 ecode7 = SWIG_AsVal_int(obj6, &val7);
24383 if (!SWIG_IsOK(ecode7)) {
24384 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24385 }
24386 arg7 = static_cast< int >(val7);
24387 }
24388 if (obj7) {
24389 ecode8 = SWIG_AsVal_int(obj7, &val8);
24390 if (!SWIG_IsOK(ecode8)) {
24391 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24392 }
24393 arg8 = static_cast< int >(val8);
24394 }
24395 {
24396 PyThreadState* __tstate = wxPyBeginAllowThreads();
24397 {
24398 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24399 result = (wxDateTime *) &_result_ref;
24400 }
24401 wxPyEndAllowThreads(__tstate);
24402 if (PyErr_Occurred()) SWIG_fail;
24403 }
24404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24405 return resultobj;
24406 fail:
24407 return NULL;
24408 }
24409
24410
24411 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24412 PyObject *resultobj = 0;
24413 wxDateTime *arg1 = (wxDateTime *) 0 ;
24414 wxDateTime *result = 0 ;
24415 void *argp1 = 0 ;
24416 int res1 = 0 ;
24417 PyObject *swig_obj[1] ;
24418
24419 if (!args) SWIG_fail;
24420 swig_obj[0] = args;
24421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24422 if (!SWIG_IsOK(res1)) {
24423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24424 }
24425 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24426 {
24427 PyThreadState* __tstate = wxPyBeginAllowThreads();
24428 {
24429 wxDateTime &_result_ref = (arg1)->ResetTime();
24430 result = (wxDateTime *) &_result_ref;
24431 }
24432 wxPyEndAllowThreads(__tstate);
24433 if (PyErr_Occurred()) SWIG_fail;
24434 }
24435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24436 return resultobj;
24437 fail:
24438 return NULL;
24439 }
24440
24441
24442 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24443 PyObject *resultobj = 0;
24444 wxDateTime *arg1 = (wxDateTime *) 0 ;
24445 int arg2 ;
24446 wxDateTime *result = 0 ;
24447 void *argp1 = 0 ;
24448 int res1 = 0 ;
24449 int val2 ;
24450 int ecode2 = 0 ;
24451 PyObject * obj0 = 0 ;
24452 PyObject * obj1 = 0 ;
24453 char * kwnames[] = {
24454 (char *) "self",(char *) "year", NULL
24455 };
24456
24457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24459 if (!SWIG_IsOK(res1)) {
24460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24461 }
24462 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24463 ecode2 = SWIG_AsVal_int(obj1, &val2);
24464 if (!SWIG_IsOK(ecode2)) {
24465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24466 }
24467 arg2 = static_cast< int >(val2);
24468 {
24469 PyThreadState* __tstate = wxPyBeginAllowThreads();
24470 {
24471 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24472 result = (wxDateTime *) &_result_ref;
24473 }
24474 wxPyEndAllowThreads(__tstate);
24475 if (PyErr_Occurred()) SWIG_fail;
24476 }
24477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24478 return resultobj;
24479 fail:
24480 return NULL;
24481 }
24482
24483
24484 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24485 PyObject *resultobj = 0;
24486 wxDateTime *arg1 = (wxDateTime *) 0 ;
24487 wxDateTime::Month arg2 ;
24488 wxDateTime *result = 0 ;
24489 void *argp1 = 0 ;
24490 int res1 = 0 ;
24491 int val2 ;
24492 int ecode2 = 0 ;
24493 PyObject * obj0 = 0 ;
24494 PyObject * obj1 = 0 ;
24495 char * kwnames[] = {
24496 (char *) "self",(char *) "month", NULL
24497 };
24498
24499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24501 if (!SWIG_IsOK(res1)) {
24502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24503 }
24504 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24505 ecode2 = SWIG_AsVal_int(obj1, &val2);
24506 if (!SWIG_IsOK(ecode2)) {
24507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24508 }
24509 arg2 = static_cast< wxDateTime::Month >(val2);
24510 {
24511 PyThreadState* __tstate = wxPyBeginAllowThreads();
24512 {
24513 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24514 result = (wxDateTime *) &_result_ref;
24515 }
24516 wxPyEndAllowThreads(__tstate);
24517 if (PyErr_Occurred()) SWIG_fail;
24518 }
24519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24520 return resultobj;
24521 fail:
24522 return NULL;
24523 }
24524
24525
24526 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24527 PyObject *resultobj = 0;
24528 wxDateTime *arg1 = (wxDateTime *) 0 ;
24529 int arg2 ;
24530 wxDateTime *result = 0 ;
24531 void *argp1 = 0 ;
24532 int res1 = 0 ;
24533 int val2 ;
24534 int ecode2 = 0 ;
24535 PyObject * obj0 = 0 ;
24536 PyObject * obj1 = 0 ;
24537 char * kwnames[] = {
24538 (char *) "self",(char *) "day", NULL
24539 };
24540
24541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24543 if (!SWIG_IsOK(res1)) {
24544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24545 }
24546 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24547 ecode2 = SWIG_AsVal_int(obj1, &val2);
24548 if (!SWIG_IsOK(ecode2)) {
24549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24550 }
24551 arg2 = static_cast< int >(val2);
24552 {
24553 PyThreadState* __tstate = wxPyBeginAllowThreads();
24554 {
24555 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24556 result = (wxDateTime *) &_result_ref;
24557 }
24558 wxPyEndAllowThreads(__tstate);
24559 if (PyErr_Occurred()) SWIG_fail;
24560 }
24561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24562 return resultobj;
24563 fail:
24564 return NULL;
24565 }
24566
24567
24568 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24569 PyObject *resultobj = 0;
24570 wxDateTime *arg1 = (wxDateTime *) 0 ;
24571 int arg2 ;
24572 wxDateTime *result = 0 ;
24573 void *argp1 = 0 ;
24574 int res1 = 0 ;
24575 int val2 ;
24576 int ecode2 = 0 ;
24577 PyObject * obj0 = 0 ;
24578 PyObject * obj1 = 0 ;
24579 char * kwnames[] = {
24580 (char *) "self",(char *) "hour", NULL
24581 };
24582
24583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24585 if (!SWIG_IsOK(res1)) {
24586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24587 }
24588 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24589 ecode2 = SWIG_AsVal_int(obj1, &val2);
24590 if (!SWIG_IsOK(ecode2)) {
24591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24592 }
24593 arg2 = static_cast< int >(val2);
24594 {
24595 PyThreadState* __tstate = wxPyBeginAllowThreads();
24596 {
24597 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24598 result = (wxDateTime *) &_result_ref;
24599 }
24600 wxPyEndAllowThreads(__tstate);
24601 if (PyErr_Occurred()) SWIG_fail;
24602 }
24603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24604 return resultobj;
24605 fail:
24606 return NULL;
24607 }
24608
24609
24610 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24611 PyObject *resultobj = 0;
24612 wxDateTime *arg1 = (wxDateTime *) 0 ;
24613 int arg2 ;
24614 wxDateTime *result = 0 ;
24615 void *argp1 = 0 ;
24616 int res1 = 0 ;
24617 int val2 ;
24618 int ecode2 = 0 ;
24619 PyObject * obj0 = 0 ;
24620 PyObject * obj1 = 0 ;
24621 char * kwnames[] = {
24622 (char *) "self",(char *) "minute", NULL
24623 };
24624
24625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24627 if (!SWIG_IsOK(res1)) {
24628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24629 }
24630 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24631 ecode2 = SWIG_AsVal_int(obj1, &val2);
24632 if (!SWIG_IsOK(ecode2)) {
24633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24634 }
24635 arg2 = static_cast< int >(val2);
24636 {
24637 PyThreadState* __tstate = wxPyBeginAllowThreads();
24638 {
24639 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24640 result = (wxDateTime *) &_result_ref;
24641 }
24642 wxPyEndAllowThreads(__tstate);
24643 if (PyErr_Occurred()) SWIG_fail;
24644 }
24645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24646 return resultobj;
24647 fail:
24648 return NULL;
24649 }
24650
24651
24652 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24653 PyObject *resultobj = 0;
24654 wxDateTime *arg1 = (wxDateTime *) 0 ;
24655 int arg2 ;
24656 wxDateTime *result = 0 ;
24657 void *argp1 = 0 ;
24658 int res1 = 0 ;
24659 int val2 ;
24660 int ecode2 = 0 ;
24661 PyObject * obj0 = 0 ;
24662 PyObject * obj1 = 0 ;
24663 char * kwnames[] = {
24664 (char *) "self",(char *) "second", NULL
24665 };
24666
24667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24669 if (!SWIG_IsOK(res1)) {
24670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24671 }
24672 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24673 ecode2 = SWIG_AsVal_int(obj1, &val2);
24674 if (!SWIG_IsOK(ecode2)) {
24675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24676 }
24677 arg2 = static_cast< int >(val2);
24678 {
24679 PyThreadState* __tstate = wxPyBeginAllowThreads();
24680 {
24681 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24682 result = (wxDateTime *) &_result_ref;
24683 }
24684 wxPyEndAllowThreads(__tstate);
24685 if (PyErr_Occurred()) SWIG_fail;
24686 }
24687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24688 return resultobj;
24689 fail:
24690 return NULL;
24691 }
24692
24693
24694 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24695 PyObject *resultobj = 0;
24696 wxDateTime *arg1 = (wxDateTime *) 0 ;
24697 int arg2 ;
24698 wxDateTime *result = 0 ;
24699 void *argp1 = 0 ;
24700 int res1 = 0 ;
24701 int val2 ;
24702 int ecode2 = 0 ;
24703 PyObject * obj0 = 0 ;
24704 PyObject * obj1 = 0 ;
24705 char * kwnames[] = {
24706 (char *) "self",(char *) "millisecond", NULL
24707 };
24708
24709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24711 if (!SWIG_IsOK(res1)) {
24712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24713 }
24714 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24715 ecode2 = SWIG_AsVal_int(obj1, &val2);
24716 if (!SWIG_IsOK(ecode2)) {
24717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24718 }
24719 arg2 = static_cast< int >(val2);
24720 {
24721 PyThreadState* __tstate = wxPyBeginAllowThreads();
24722 {
24723 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24724 result = (wxDateTime *) &_result_ref;
24725 }
24726 wxPyEndAllowThreads(__tstate);
24727 if (PyErr_Occurred()) SWIG_fail;
24728 }
24729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24730 return resultobj;
24731 fail:
24732 return NULL;
24733 }
24734
24735
24736 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24737 PyObject *resultobj = 0;
24738 wxDateTime *arg1 = (wxDateTime *) 0 ;
24739 wxDateTime::WeekDay arg2 ;
24740 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24741 wxDateTime *result = 0 ;
24742 void *argp1 = 0 ;
24743 int res1 = 0 ;
24744 int val2 ;
24745 int ecode2 = 0 ;
24746 int val3 ;
24747 int ecode3 = 0 ;
24748 PyObject * obj0 = 0 ;
24749 PyObject * obj1 = 0 ;
24750 PyObject * obj2 = 0 ;
24751 char * kwnames[] = {
24752 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24753 };
24754
24755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24757 if (!SWIG_IsOK(res1)) {
24758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24759 }
24760 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24761 ecode2 = SWIG_AsVal_int(obj1, &val2);
24762 if (!SWIG_IsOK(ecode2)) {
24763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24764 }
24765 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24766 if (obj2) {
24767 ecode3 = SWIG_AsVal_int(obj2, &val3);
24768 if (!SWIG_IsOK(ecode3)) {
24769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24770 }
24771 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24772 }
24773 {
24774 PyThreadState* __tstate = wxPyBeginAllowThreads();
24775 {
24776 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24777 result = (wxDateTime *) &_result_ref;
24778 }
24779 wxPyEndAllowThreads(__tstate);
24780 if (PyErr_Occurred()) SWIG_fail;
24781 }
24782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24783 return resultobj;
24784 fail:
24785 return NULL;
24786 }
24787
24788
24789 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24790 PyObject *resultobj = 0;
24791 wxDateTime *arg1 = (wxDateTime *) 0 ;
24792 wxDateTime::WeekDay arg2 ;
24793 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24794 wxDateTime result;
24795 void *argp1 = 0 ;
24796 int res1 = 0 ;
24797 int val2 ;
24798 int ecode2 = 0 ;
24799 int val3 ;
24800 int ecode3 = 0 ;
24801 PyObject * obj0 = 0 ;
24802 PyObject * obj1 = 0 ;
24803 PyObject * obj2 = 0 ;
24804 char * kwnames[] = {
24805 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24806 };
24807
24808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24810 if (!SWIG_IsOK(res1)) {
24811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24812 }
24813 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24814 ecode2 = SWIG_AsVal_int(obj1, &val2);
24815 if (!SWIG_IsOK(ecode2)) {
24816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24817 }
24818 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24819 if (obj2) {
24820 ecode3 = SWIG_AsVal_int(obj2, &val3);
24821 if (!SWIG_IsOK(ecode3)) {
24822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24823 }
24824 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24825 }
24826 {
24827 PyThreadState* __tstate = wxPyBeginAllowThreads();
24828 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24829 wxPyEndAllowThreads(__tstate);
24830 if (PyErr_Occurred()) SWIG_fail;
24831 }
24832 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24833 return resultobj;
24834 fail:
24835 return NULL;
24836 }
24837
24838
24839 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24840 PyObject *resultobj = 0;
24841 wxDateTime *arg1 = (wxDateTime *) 0 ;
24842 wxDateTime::WeekDay arg2 ;
24843 wxDateTime *result = 0 ;
24844 void *argp1 = 0 ;
24845 int res1 = 0 ;
24846 int val2 ;
24847 int ecode2 = 0 ;
24848 PyObject * obj0 = 0 ;
24849 PyObject * obj1 = 0 ;
24850 char * kwnames[] = {
24851 (char *) "self",(char *) "weekday", NULL
24852 };
24853
24854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24856 if (!SWIG_IsOK(res1)) {
24857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24858 }
24859 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24860 ecode2 = SWIG_AsVal_int(obj1, &val2);
24861 if (!SWIG_IsOK(ecode2)) {
24862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24863 }
24864 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24865 {
24866 PyThreadState* __tstate = wxPyBeginAllowThreads();
24867 {
24868 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24869 result = (wxDateTime *) &_result_ref;
24870 }
24871 wxPyEndAllowThreads(__tstate);
24872 if (PyErr_Occurred()) SWIG_fail;
24873 }
24874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24875 return resultobj;
24876 fail:
24877 return NULL;
24878 }
24879
24880
24881 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24882 PyObject *resultobj = 0;
24883 wxDateTime *arg1 = (wxDateTime *) 0 ;
24884 wxDateTime::WeekDay arg2 ;
24885 wxDateTime result;
24886 void *argp1 = 0 ;
24887 int res1 = 0 ;
24888 int val2 ;
24889 int ecode2 = 0 ;
24890 PyObject * obj0 = 0 ;
24891 PyObject * obj1 = 0 ;
24892 char * kwnames[] = {
24893 (char *) "self",(char *) "weekday", NULL
24894 };
24895
24896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24898 if (!SWIG_IsOK(res1)) {
24899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24900 }
24901 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24902 ecode2 = SWIG_AsVal_int(obj1, &val2);
24903 if (!SWIG_IsOK(ecode2)) {
24904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24905 }
24906 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24907 {
24908 PyThreadState* __tstate = wxPyBeginAllowThreads();
24909 result = (arg1)->GetNextWeekDay(arg2);
24910 wxPyEndAllowThreads(__tstate);
24911 if (PyErr_Occurred()) SWIG_fail;
24912 }
24913 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24914 return resultobj;
24915 fail:
24916 return NULL;
24917 }
24918
24919
24920 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24921 PyObject *resultobj = 0;
24922 wxDateTime *arg1 = (wxDateTime *) 0 ;
24923 wxDateTime::WeekDay arg2 ;
24924 wxDateTime *result = 0 ;
24925 void *argp1 = 0 ;
24926 int res1 = 0 ;
24927 int val2 ;
24928 int ecode2 = 0 ;
24929 PyObject * obj0 = 0 ;
24930 PyObject * obj1 = 0 ;
24931 char * kwnames[] = {
24932 (char *) "self",(char *) "weekday", NULL
24933 };
24934
24935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24937 if (!SWIG_IsOK(res1)) {
24938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24939 }
24940 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24941 ecode2 = SWIG_AsVal_int(obj1, &val2);
24942 if (!SWIG_IsOK(ecode2)) {
24943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24944 }
24945 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24946 {
24947 PyThreadState* __tstate = wxPyBeginAllowThreads();
24948 {
24949 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24950 result = (wxDateTime *) &_result_ref;
24951 }
24952 wxPyEndAllowThreads(__tstate);
24953 if (PyErr_Occurred()) SWIG_fail;
24954 }
24955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24956 return resultobj;
24957 fail:
24958 return NULL;
24959 }
24960
24961
24962 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24963 PyObject *resultobj = 0;
24964 wxDateTime *arg1 = (wxDateTime *) 0 ;
24965 wxDateTime::WeekDay arg2 ;
24966 wxDateTime result;
24967 void *argp1 = 0 ;
24968 int res1 = 0 ;
24969 int val2 ;
24970 int ecode2 = 0 ;
24971 PyObject * obj0 = 0 ;
24972 PyObject * obj1 = 0 ;
24973 char * kwnames[] = {
24974 (char *) "self",(char *) "weekday", NULL
24975 };
24976
24977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24979 if (!SWIG_IsOK(res1)) {
24980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24981 }
24982 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24983 ecode2 = SWIG_AsVal_int(obj1, &val2);
24984 if (!SWIG_IsOK(ecode2)) {
24985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24986 }
24987 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24988 {
24989 PyThreadState* __tstate = wxPyBeginAllowThreads();
24990 result = (arg1)->GetPrevWeekDay(arg2);
24991 wxPyEndAllowThreads(__tstate);
24992 if (PyErr_Occurred()) SWIG_fail;
24993 }
24994 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24995 return resultobj;
24996 fail:
24997 return NULL;
24998 }
24999
25000
25001 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25002 PyObject *resultobj = 0;
25003 wxDateTime *arg1 = (wxDateTime *) 0 ;
25004 wxDateTime::WeekDay arg2 ;
25005 int arg3 = (int) 1 ;
25006 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25007 int arg5 = (int) wxDateTime::Inv_Year ;
25008 bool result;
25009 void *argp1 = 0 ;
25010 int res1 = 0 ;
25011 int val2 ;
25012 int ecode2 = 0 ;
25013 int val3 ;
25014 int ecode3 = 0 ;
25015 int val4 ;
25016 int ecode4 = 0 ;
25017 int val5 ;
25018 int ecode5 = 0 ;
25019 PyObject * obj0 = 0 ;
25020 PyObject * obj1 = 0 ;
25021 PyObject * obj2 = 0 ;
25022 PyObject * obj3 = 0 ;
25023 PyObject * obj4 = 0 ;
25024 char * kwnames[] = {
25025 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25026 };
25027
25028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25030 if (!SWIG_IsOK(res1)) {
25031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25032 }
25033 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25034 ecode2 = SWIG_AsVal_int(obj1, &val2);
25035 if (!SWIG_IsOK(ecode2)) {
25036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25037 }
25038 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25039 if (obj2) {
25040 ecode3 = SWIG_AsVal_int(obj2, &val3);
25041 if (!SWIG_IsOK(ecode3)) {
25042 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25043 }
25044 arg3 = static_cast< int >(val3);
25045 }
25046 if (obj3) {
25047 ecode4 = SWIG_AsVal_int(obj3, &val4);
25048 if (!SWIG_IsOK(ecode4)) {
25049 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25050 }
25051 arg4 = static_cast< wxDateTime::Month >(val4);
25052 }
25053 if (obj4) {
25054 ecode5 = SWIG_AsVal_int(obj4, &val5);
25055 if (!SWIG_IsOK(ecode5)) {
25056 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25057 }
25058 arg5 = static_cast< int >(val5);
25059 }
25060 {
25061 PyThreadState* __tstate = wxPyBeginAllowThreads();
25062 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25063 wxPyEndAllowThreads(__tstate);
25064 if (PyErr_Occurred()) SWIG_fail;
25065 }
25066 {
25067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25068 }
25069 return resultobj;
25070 fail:
25071 return NULL;
25072 }
25073
25074
25075 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25076 PyObject *resultobj = 0;
25077 wxDateTime *arg1 = (wxDateTime *) 0 ;
25078 wxDateTime::WeekDay arg2 ;
25079 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25080 int arg4 = (int) wxDateTime::Inv_Year ;
25081 bool result;
25082 void *argp1 = 0 ;
25083 int res1 = 0 ;
25084 int val2 ;
25085 int ecode2 = 0 ;
25086 int val3 ;
25087 int ecode3 = 0 ;
25088 int val4 ;
25089 int ecode4 = 0 ;
25090 PyObject * obj0 = 0 ;
25091 PyObject * obj1 = 0 ;
25092 PyObject * obj2 = 0 ;
25093 PyObject * obj3 = 0 ;
25094 char * kwnames[] = {
25095 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25096 };
25097
25098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25100 if (!SWIG_IsOK(res1)) {
25101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25102 }
25103 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25104 ecode2 = SWIG_AsVal_int(obj1, &val2);
25105 if (!SWIG_IsOK(ecode2)) {
25106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25107 }
25108 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25109 if (obj2) {
25110 ecode3 = SWIG_AsVal_int(obj2, &val3);
25111 if (!SWIG_IsOK(ecode3)) {
25112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25113 }
25114 arg3 = static_cast< wxDateTime::Month >(val3);
25115 }
25116 if (obj3) {
25117 ecode4 = SWIG_AsVal_int(obj3, &val4);
25118 if (!SWIG_IsOK(ecode4)) {
25119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25120 }
25121 arg4 = static_cast< int >(val4);
25122 }
25123 {
25124 PyThreadState* __tstate = wxPyBeginAllowThreads();
25125 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25126 wxPyEndAllowThreads(__tstate);
25127 if (PyErr_Occurred()) SWIG_fail;
25128 }
25129 {
25130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25131 }
25132 return resultobj;
25133 fail:
25134 return NULL;
25135 }
25136
25137
25138 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25139 PyObject *resultobj = 0;
25140 wxDateTime *arg1 = (wxDateTime *) 0 ;
25141 wxDateTime::WeekDay arg2 ;
25142 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25143 int arg4 = (int) wxDateTime::Inv_Year ;
25144 wxDateTime result;
25145 void *argp1 = 0 ;
25146 int res1 = 0 ;
25147 int val2 ;
25148 int ecode2 = 0 ;
25149 int val3 ;
25150 int ecode3 = 0 ;
25151 int val4 ;
25152 int ecode4 = 0 ;
25153 PyObject * obj0 = 0 ;
25154 PyObject * obj1 = 0 ;
25155 PyObject * obj2 = 0 ;
25156 PyObject * obj3 = 0 ;
25157 char * kwnames[] = {
25158 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25159 };
25160
25161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25163 if (!SWIG_IsOK(res1)) {
25164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25165 }
25166 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25167 ecode2 = SWIG_AsVal_int(obj1, &val2);
25168 if (!SWIG_IsOK(ecode2)) {
25169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25170 }
25171 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25172 if (obj2) {
25173 ecode3 = SWIG_AsVal_int(obj2, &val3);
25174 if (!SWIG_IsOK(ecode3)) {
25175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25176 }
25177 arg3 = static_cast< wxDateTime::Month >(val3);
25178 }
25179 if (obj3) {
25180 ecode4 = SWIG_AsVal_int(obj3, &val4);
25181 if (!SWIG_IsOK(ecode4)) {
25182 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25183 }
25184 arg4 = static_cast< int >(val4);
25185 }
25186 {
25187 PyThreadState* __tstate = wxPyBeginAllowThreads();
25188 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25189 wxPyEndAllowThreads(__tstate);
25190 if (PyErr_Occurred()) SWIG_fail;
25191 }
25192 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25193 return resultobj;
25194 fail:
25195 return NULL;
25196 }
25197
25198
25199 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25200 PyObject *resultobj = 0;
25201 wxDateTime *arg1 = (wxDateTime *) 0 ;
25202 int arg2 ;
25203 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25204 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25205 bool result;
25206 void *argp1 = 0 ;
25207 int res1 = 0 ;
25208 int val2 ;
25209 int ecode2 = 0 ;
25210 int val3 ;
25211 int ecode3 = 0 ;
25212 int val4 ;
25213 int ecode4 = 0 ;
25214 PyObject * obj0 = 0 ;
25215 PyObject * obj1 = 0 ;
25216 PyObject * obj2 = 0 ;
25217 PyObject * obj3 = 0 ;
25218 char * kwnames[] = {
25219 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25220 };
25221
25222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25224 if (!SWIG_IsOK(res1)) {
25225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25226 }
25227 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25228 ecode2 = SWIG_AsVal_int(obj1, &val2);
25229 if (!SWIG_IsOK(ecode2)) {
25230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25231 }
25232 arg2 = static_cast< int >(val2);
25233 if (obj2) {
25234 ecode3 = SWIG_AsVal_int(obj2, &val3);
25235 if (!SWIG_IsOK(ecode3)) {
25236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25237 }
25238 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25239 }
25240 if (obj3) {
25241 ecode4 = SWIG_AsVal_int(obj3, &val4);
25242 if (!SWIG_IsOK(ecode4)) {
25243 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25244 }
25245 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25246 }
25247 {
25248 PyThreadState* __tstate = wxPyBeginAllowThreads();
25249 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25250 wxPyEndAllowThreads(__tstate);
25251 if (PyErr_Occurred()) SWIG_fail;
25252 }
25253 {
25254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25255 }
25256 return resultobj;
25257 fail:
25258 return NULL;
25259 }
25260
25261
25262 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25263 PyObject *resultobj = 0;
25264 wxDateTime *arg1 = (wxDateTime *) 0 ;
25265 int arg2 ;
25266 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25267 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25268 wxDateTime result;
25269 void *argp1 = 0 ;
25270 int res1 = 0 ;
25271 int val2 ;
25272 int ecode2 = 0 ;
25273 int val3 ;
25274 int ecode3 = 0 ;
25275 int val4 ;
25276 int ecode4 = 0 ;
25277 PyObject * obj0 = 0 ;
25278 PyObject * obj1 = 0 ;
25279 PyObject * obj2 = 0 ;
25280 PyObject * obj3 = 0 ;
25281 char * kwnames[] = {
25282 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25283 };
25284
25285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25287 if (!SWIG_IsOK(res1)) {
25288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25289 }
25290 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25291 ecode2 = SWIG_AsVal_int(obj1, &val2);
25292 if (!SWIG_IsOK(ecode2)) {
25293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25294 }
25295 arg2 = static_cast< int >(val2);
25296 if (obj2) {
25297 ecode3 = SWIG_AsVal_int(obj2, &val3);
25298 if (!SWIG_IsOK(ecode3)) {
25299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25300 }
25301 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25302 }
25303 if (obj3) {
25304 ecode4 = SWIG_AsVal_int(obj3, &val4);
25305 if (!SWIG_IsOK(ecode4)) {
25306 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25307 }
25308 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25309 }
25310 {
25311 PyThreadState* __tstate = wxPyBeginAllowThreads();
25312 result = (arg1)->GetWeek(arg2,arg3,arg4);
25313 wxPyEndAllowThreads(__tstate);
25314 if (PyErr_Occurred()) SWIG_fail;
25315 }
25316 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25317 return resultobj;
25318 fail:
25319 return NULL;
25320 }
25321
25322
25323 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25324 PyObject *resultobj = 0;
25325 int arg1 ;
25326 int arg2 ;
25327 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25328 wxDateTime result;
25329 int val1 ;
25330 int ecode1 = 0 ;
25331 int val2 ;
25332 int ecode2 = 0 ;
25333 int val3 ;
25334 int ecode3 = 0 ;
25335 PyObject * obj0 = 0 ;
25336 PyObject * obj1 = 0 ;
25337 PyObject * obj2 = 0 ;
25338 char * kwnames[] = {
25339 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25340 };
25341
25342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25343 ecode1 = SWIG_AsVal_int(obj0, &val1);
25344 if (!SWIG_IsOK(ecode1)) {
25345 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25346 }
25347 arg1 = static_cast< int >(val1);
25348 ecode2 = SWIG_AsVal_int(obj1, &val2);
25349 if (!SWIG_IsOK(ecode2)) {
25350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25351 }
25352 arg2 = static_cast< int >(val2);
25353 if (obj2) {
25354 ecode3 = SWIG_AsVal_int(obj2, &val3);
25355 if (!SWIG_IsOK(ecode3)) {
25356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25357 }
25358 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25359 }
25360 {
25361 PyThreadState* __tstate = wxPyBeginAllowThreads();
25362 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25363 wxPyEndAllowThreads(__tstate);
25364 if (PyErr_Occurred()) SWIG_fail;
25365 }
25366 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25367 return resultobj;
25368 fail:
25369 return NULL;
25370 }
25371
25372
25373 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25374 PyObject *resultobj = 0;
25375 wxDateTime *arg1 = (wxDateTime *) 0 ;
25376 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25377 int arg3 = (int) wxDateTime::Inv_Year ;
25378 wxDateTime *result = 0 ;
25379 void *argp1 = 0 ;
25380 int res1 = 0 ;
25381 int val2 ;
25382 int ecode2 = 0 ;
25383 int val3 ;
25384 int ecode3 = 0 ;
25385 PyObject * obj0 = 0 ;
25386 PyObject * obj1 = 0 ;
25387 PyObject * obj2 = 0 ;
25388 char * kwnames[] = {
25389 (char *) "self",(char *) "month",(char *) "year", NULL
25390 };
25391
25392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25394 if (!SWIG_IsOK(res1)) {
25395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25396 }
25397 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25398 if (obj1) {
25399 ecode2 = SWIG_AsVal_int(obj1, &val2);
25400 if (!SWIG_IsOK(ecode2)) {
25401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25402 }
25403 arg2 = static_cast< wxDateTime::Month >(val2);
25404 }
25405 if (obj2) {
25406 ecode3 = SWIG_AsVal_int(obj2, &val3);
25407 if (!SWIG_IsOK(ecode3)) {
25408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25409 }
25410 arg3 = static_cast< int >(val3);
25411 }
25412 {
25413 PyThreadState* __tstate = wxPyBeginAllowThreads();
25414 {
25415 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25416 result = (wxDateTime *) &_result_ref;
25417 }
25418 wxPyEndAllowThreads(__tstate);
25419 if (PyErr_Occurred()) SWIG_fail;
25420 }
25421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25422 return resultobj;
25423 fail:
25424 return NULL;
25425 }
25426
25427
25428 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25429 PyObject *resultobj = 0;
25430 wxDateTime *arg1 = (wxDateTime *) 0 ;
25431 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25432 int arg3 = (int) wxDateTime::Inv_Year ;
25433 wxDateTime result;
25434 void *argp1 = 0 ;
25435 int res1 = 0 ;
25436 int val2 ;
25437 int ecode2 = 0 ;
25438 int val3 ;
25439 int ecode3 = 0 ;
25440 PyObject * obj0 = 0 ;
25441 PyObject * obj1 = 0 ;
25442 PyObject * obj2 = 0 ;
25443 char * kwnames[] = {
25444 (char *) "self",(char *) "month",(char *) "year", NULL
25445 };
25446
25447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25449 if (!SWIG_IsOK(res1)) {
25450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25451 }
25452 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25453 if (obj1) {
25454 ecode2 = SWIG_AsVal_int(obj1, &val2);
25455 if (!SWIG_IsOK(ecode2)) {
25456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25457 }
25458 arg2 = static_cast< wxDateTime::Month >(val2);
25459 }
25460 if (obj2) {
25461 ecode3 = SWIG_AsVal_int(obj2, &val3);
25462 if (!SWIG_IsOK(ecode3)) {
25463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25464 }
25465 arg3 = static_cast< int >(val3);
25466 }
25467 {
25468 PyThreadState* __tstate = wxPyBeginAllowThreads();
25469 result = (arg1)->GetLastMonthDay(arg2,arg3);
25470 wxPyEndAllowThreads(__tstate);
25471 if (PyErr_Occurred()) SWIG_fail;
25472 }
25473 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25474 return resultobj;
25475 fail:
25476 return NULL;
25477 }
25478
25479
25480 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25481 PyObject *resultobj = 0;
25482 wxDateTime *arg1 = (wxDateTime *) 0 ;
25483 int arg2 ;
25484 wxDateTime *result = 0 ;
25485 void *argp1 = 0 ;
25486 int res1 = 0 ;
25487 int val2 ;
25488 int ecode2 = 0 ;
25489 PyObject * obj0 = 0 ;
25490 PyObject * obj1 = 0 ;
25491 char * kwnames[] = {
25492 (char *) "self",(char *) "yday", NULL
25493 };
25494
25495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25497 if (!SWIG_IsOK(res1)) {
25498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25499 }
25500 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25501 ecode2 = SWIG_AsVal_int(obj1, &val2);
25502 if (!SWIG_IsOK(ecode2)) {
25503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25504 }
25505 arg2 = static_cast< int >(val2);
25506 {
25507 PyThreadState* __tstate = wxPyBeginAllowThreads();
25508 {
25509 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25510 result = (wxDateTime *) &_result_ref;
25511 }
25512 wxPyEndAllowThreads(__tstate);
25513 if (PyErr_Occurred()) SWIG_fail;
25514 }
25515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25516 return resultobj;
25517 fail:
25518 return NULL;
25519 }
25520
25521
25522 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25523 PyObject *resultobj = 0;
25524 wxDateTime *arg1 = (wxDateTime *) 0 ;
25525 int arg2 ;
25526 wxDateTime result;
25527 void *argp1 = 0 ;
25528 int res1 = 0 ;
25529 int val2 ;
25530 int ecode2 = 0 ;
25531 PyObject * obj0 = 0 ;
25532 PyObject * obj1 = 0 ;
25533 char * kwnames[] = {
25534 (char *) "self",(char *) "yday", NULL
25535 };
25536
25537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25539 if (!SWIG_IsOK(res1)) {
25540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25541 }
25542 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25543 ecode2 = SWIG_AsVal_int(obj1, &val2);
25544 if (!SWIG_IsOK(ecode2)) {
25545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25546 }
25547 arg2 = static_cast< int >(val2);
25548 {
25549 PyThreadState* __tstate = wxPyBeginAllowThreads();
25550 result = (arg1)->GetYearDay(arg2);
25551 wxPyEndAllowThreads(__tstate);
25552 if (PyErr_Occurred()) SWIG_fail;
25553 }
25554 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25555 return resultobj;
25556 fail:
25557 return NULL;
25558 }
25559
25560
25561 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25562 PyObject *resultobj = 0;
25563 wxDateTime *arg1 = (wxDateTime *) 0 ;
25564 double result;
25565 void *argp1 = 0 ;
25566 int res1 = 0 ;
25567 PyObject *swig_obj[1] ;
25568
25569 if (!args) SWIG_fail;
25570 swig_obj[0] = args;
25571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25572 if (!SWIG_IsOK(res1)) {
25573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25574 }
25575 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25576 {
25577 PyThreadState* __tstate = wxPyBeginAllowThreads();
25578 result = (double)(arg1)->GetJulianDayNumber();
25579 wxPyEndAllowThreads(__tstate);
25580 if (PyErr_Occurred()) SWIG_fail;
25581 }
25582 resultobj = SWIG_From_double(static_cast< double >(result));
25583 return resultobj;
25584 fail:
25585 return NULL;
25586 }
25587
25588
25589 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25590 PyObject *resultobj = 0;
25591 wxDateTime *arg1 = (wxDateTime *) 0 ;
25592 double result;
25593 void *argp1 = 0 ;
25594 int res1 = 0 ;
25595 PyObject *swig_obj[1] ;
25596
25597 if (!args) SWIG_fail;
25598 swig_obj[0] = args;
25599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25600 if (!SWIG_IsOK(res1)) {
25601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25602 }
25603 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25604 {
25605 PyThreadState* __tstate = wxPyBeginAllowThreads();
25606 result = (double)(arg1)->GetJDN();
25607 wxPyEndAllowThreads(__tstate);
25608 if (PyErr_Occurred()) SWIG_fail;
25609 }
25610 resultobj = SWIG_From_double(static_cast< double >(result));
25611 return resultobj;
25612 fail:
25613 return NULL;
25614 }
25615
25616
25617 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25618 PyObject *resultobj = 0;
25619 wxDateTime *arg1 = (wxDateTime *) 0 ;
25620 double result;
25621 void *argp1 = 0 ;
25622 int res1 = 0 ;
25623 PyObject *swig_obj[1] ;
25624
25625 if (!args) SWIG_fail;
25626 swig_obj[0] = args;
25627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25628 if (!SWIG_IsOK(res1)) {
25629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25630 }
25631 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25632 {
25633 PyThreadState* __tstate = wxPyBeginAllowThreads();
25634 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25635 wxPyEndAllowThreads(__tstate);
25636 if (PyErr_Occurred()) SWIG_fail;
25637 }
25638 resultobj = SWIG_From_double(static_cast< double >(result));
25639 return resultobj;
25640 fail:
25641 return NULL;
25642 }
25643
25644
25645 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25646 PyObject *resultobj = 0;
25647 wxDateTime *arg1 = (wxDateTime *) 0 ;
25648 double result;
25649 void *argp1 = 0 ;
25650 int res1 = 0 ;
25651 PyObject *swig_obj[1] ;
25652
25653 if (!args) SWIG_fail;
25654 swig_obj[0] = args;
25655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25656 if (!SWIG_IsOK(res1)) {
25657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25658 }
25659 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25660 {
25661 PyThreadState* __tstate = wxPyBeginAllowThreads();
25662 result = (double)(arg1)->GetMJD();
25663 wxPyEndAllowThreads(__tstate);
25664 if (PyErr_Occurred()) SWIG_fail;
25665 }
25666 resultobj = SWIG_From_double(static_cast< double >(result));
25667 return resultobj;
25668 fail:
25669 return NULL;
25670 }
25671
25672
25673 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25674 PyObject *resultobj = 0;
25675 wxDateTime *arg1 = (wxDateTime *) 0 ;
25676 double result;
25677 void *argp1 = 0 ;
25678 int res1 = 0 ;
25679 PyObject *swig_obj[1] ;
25680
25681 if (!args) SWIG_fail;
25682 swig_obj[0] = args;
25683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25684 if (!SWIG_IsOK(res1)) {
25685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25686 }
25687 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25688 {
25689 PyThreadState* __tstate = wxPyBeginAllowThreads();
25690 result = (double)(arg1)->GetRataDie();
25691 wxPyEndAllowThreads(__tstate);
25692 if (PyErr_Occurred()) SWIG_fail;
25693 }
25694 resultobj = SWIG_From_double(static_cast< double >(result));
25695 return resultobj;
25696 fail:
25697 return NULL;
25698 }
25699
25700
25701 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25702 PyObject *resultobj = 0;
25703 wxDateTime *arg1 = (wxDateTime *) 0 ;
25704 wxDateTime::TimeZone *arg2 = 0 ;
25705 bool arg3 = (bool) false ;
25706 wxDateTime result;
25707 void *argp1 = 0 ;
25708 int res1 = 0 ;
25709 bool temp2 = false ;
25710 bool val3 ;
25711 int ecode3 = 0 ;
25712 PyObject * obj0 = 0 ;
25713 PyObject * obj1 = 0 ;
25714 PyObject * obj2 = 0 ;
25715 char * kwnames[] = {
25716 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25717 };
25718
25719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25721 if (!SWIG_IsOK(res1)) {
25722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25723 }
25724 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25725 {
25726 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25727 temp2 = true;
25728 }
25729 if (obj2) {
25730 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25731 if (!SWIG_IsOK(ecode3)) {
25732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25733 }
25734 arg3 = static_cast< bool >(val3);
25735 }
25736 {
25737 PyThreadState* __tstate = wxPyBeginAllowThreads();
25738 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25739 wxPyEndAllowThreads(__tstate);
25740 if (PyErr_Occurred()) SWIG_fail;
25741 }
25742 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25743 {
25744 if (temp2) delete arg2;
25745 }
25746 return resultobj;
25747 fail:
25748 {
25749 if (temp2) delete arg2;
25750 }
25751 return NULL;
25752 }
25753
25754
25755 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25756 PyObject *resultobj = 0;
25757 wxDateTime *arg1 = (wxDateTime *) 0 ;
25758 wxDateTime::TimeZone *arg2 = 0 ;
25759 bool arg3 = (bool) false ;
25760 wxDateTime *result = 0 ;
25761 void *argp1 = 0 ;
25762 int res1 = 0 ;
25763 bool temp2 = false ;
25764 bool val3 ;
25765 int ecode3 = 0 ;
25766 PyObject * obj0 = 0 ;
25767 PyObject * obj1 = 0 ;
25768 PyObject * obj2 = 0 ;
25769 char * kwnames[] = {
25770 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25771 };
25772
25773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25775 if (!SWIG_IsOK(res1)) {
25776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25777 }
25778 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25779 {
25780 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25781 temp2 = true;
25782 }
25783 if (obj2) {
25784 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25785 if (!SWIG_IsOK(ecode3)) {
25786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25787 }
25788 arg3 = static_cast< bool >(val3);
25789 }
25790 {
25791 PyThreadState* __tstate = wxPyBeginAllowThreads();
25792 {
25793 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25794 result = (wxDateTime *) &_result_ref;
25795 }
25796 wxPyEndAllowThreads(__tstate);
25797 if (PyErr_Occurred()) SWIG_fail;
25798 }
25799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25800 {
25801 if (temp2) delete arg2;
25802 }
25803 return resultobj;
25804 fail:
25805 {
25806 if (temp2) delete arg2;
25807 }
25808 return NULL;
25809 }
25810
25811
25812 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25813 PyObject *resultobj = 0;
25814 wxDateTime *arg1 = (wxDateTime *) 0 ;
25815 wxDateTime::TimeZone *arg2 = 0 ;
25816 bool arg3 = (bool) false ;
25817 wxDateTime result;
25818 void *argp1 = 0 ;
25819 int res1 = 0 ;
25820 bool temp2 = false ;
25821 bool val3 ;
25822 int ecode3 = 0 ;
25823 PyObject * obj0 = 0 ;
25824 PyObject * obj1 = 0 ;
25825 PyObject * obj2 = 0 ;
25826 char * kwnames[] = {
25827 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25828 };
25829
25830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25832 if (!SWIG_IsOK(res1)) {
25833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25834 }
25835 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25836 {
25837 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25838 temp2 = true;
25839 }
25840 if (obj2) {
25841 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25842 if (!SWIG_IsOK(ecode3)) {
25843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25844 }
25845 arg3 = static_cast< bool >(val3);
25846 }
25847 {
25848 PyThreadState* __tstate = wxPyBeginAllowThreads();
25849 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25850 wxPyEndAllowThreads(__tstate);
25851 if (PyErr_Occurred()) SWIG_fail;
25852 }
25853 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25854 {
25855 if (temp2) delete arg2;
25856 }
25857 return resultobj;
25858 fail:
25859 {
25860 if (temp2) delete arg2;
25861 }
25862 return NULL;
25863 }
25864
25865
25866 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25867 PyObject *resultobj = 0;
25868 wxDateTime *arg1 = (wxDateTime *) 0 ;
25869 wxDateTime::TimeZone *arg2 = 0 ;
25870 bool arg3 = (bool) false ;
25871 wxDateTime *result = 0 ;
25872 void *argp1 = 0 ;
25873 int res1 = 0 ;
25874 bool temp2 = false ;
25875 bool val3 ;
25876 int ecode3 = 0 ;
25877 PyObject * obj0 = 0 ;
25878 PyObject * obj1 = 0 ;
25879 PyObject * obj2 = 0 ;
25880 char * kwnames[] = {
25881 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25882 };
25883
25884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25886 if (!SWIG_IsOK(res1)) {
25887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25888 }
25889 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25890 {
25891 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25892 temp2 = true;
25893 }
25894 if (obj2) {
25895 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25896 if (!SWIG_IsOK(ecode3)) {
25897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25898 }
25899 arg3 = static_cast< bool >(val3);
25900 }
25901 {
25902 PyThreadState* __tstate = wxPyBeginAllowThreads();
25903 {
25904 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25905 result = (wxDateTime *) &_result_ref;
25906 }
25907 wxPyEndAllowThreads(__tstate);
25908 if (PyErr_Occurred()) SWIG_fail;
25909 }
25910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25911 {
25912 if (temp2) delete arg2;
25913 }
25914 return resultobj;
25915 fail:
25916 {
25917 if (temp2) delete arg2;
25918 }
25919 return NULL;
25920 }
25921
25922
25923 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25924 PyObject *resultobj = 0;
25925 wxDateTime *arg1 = (wxDateTime *) 0 ;
25926 bool arg2 = (bool) false ;
25927 wxDateTime result;
25928 void *argp1 = 0 ;
25929 int res1 = 0 ;
25930 bool val2 ;
25931 int ecode2 = 0 ;
25932 PyObject * obj0 = 0 ;
25933 PyObject * obj1 = 0 ;
25934 char * kwnames[] = {
25935 (char *) "self",(char *) "noDST", NULL
25936 };
25937
25938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25940 if (!SWIG_IsOK(res1)) {
25941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25942 }
25943 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25944 if (obj1) {
25945 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25946 if (!SWIG_IsOK(ecode2)) {
25947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25948 }
25949 arg2 = static_cast< bool >(val2);
25950 }
25951 {
25952 PyThreadState* __tstate = wxPyBeginAllowThreads();
25953 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25954 wxPyEndAllowThreads(__tstate);
25955 if (PyErr_Occurred()) SWIG_fail;
25956 }
25957 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25958 return resultobj;
25959 fail:
25960 return NULL;
25961 }
25962
25963
25964 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25965 PyObject *resultobj = 0;
25966 wxDateTime *arg1 = (wxDateTime *) 0 ;
25967 bool arg2 = (bool) false ;
25968 wxDateTime *result = 0 ;
25969 void *argp1 = 0 ;
25970 int res1 = 0 ;
25971 bool val2 ;
25972 int ecode2 = 0 ;
25973 PyObject * obj0 = 0 ;
25974 PyObject * obj1 = 0 ;
25975 char * kwnames[] = {
25976 (char *) "self",(char *) "noDST", NULL
25977 };
25978
25979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25981 if (!SWIG_IsOK(res1)) {
25982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25983 }
25984 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25985 if (obj1) {
25986 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25987 if (!SWIG_IsOK(ecode2)) {
25988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25989 }
25990 arg2 = static_cast< bool >(val2);
25991 }
25992 {
25993 PyThreadState* __tstate = wxPyBeginAllowThreads();
25994 {
25995 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25996 result = (wxDateTime *) &_result_ref;
25997 }
25998 wxPyEndAllowThreads(__tstate);
25999 if (PyErr_Occurred()) SWIG_fail;
26000 }
26001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26002 return resultobj;
26003 fail:
26004 return NULL;
26005 }
26006
26007
26008 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26009 PyObject *resultobj = 0;
26010 wxDateTime *arg1 = (wxDateTime *) 0 ;
26011 bool arg2 = (bool) false ;
26012 wxDateTime result;
26013 void *argp1 = 0 ;
26014 int res1 = 0 ;
26015 bool val2 ;
26016 int ecode2 = 0 ;
26017 PyObject * obj0 = 0 ;
26018 PyObject * obj1 = 0 ;
26019 char * kwnames[] = {
26020 (char *) "self",(char *) "noDST", NULL
26021 };
26022
26023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26025 if (!SWIG_IsOK(res1)) {
26026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26027 }
26028 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26029 if (obj1) {
26030 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26031 if (!SWIG_IsOK(ecode2)) {
26032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26033 }
26034 arg2 = static_cast< bool >(val2);
26035 }
26036 {
26037 PyThreadState* __tstate = wxPyBeginAllowThreads();
26038 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26039 wxPyEndAllowThreads(__tstate);
26040 if (PyErr_Occurred()) SWIG_fail;
26041 }
26042 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26043 return resultobj;
26044 fail:
26045 return NULL;
26046 }
26047
26048
26049 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26050 PyObject *resultobj = 0;
26051 wxDateTime *arg1 = (wxDateTime *) 0 ;
26052 bool arg2 = (bool) false ;
26053 wxDateTime *result = 0 ;
26054 void *argp1 = 0 ;
26055 int res1 = 0 ;
26056 bool val2 ;
26057 int ecode2 = 0 ;
26058 PyObject * obj0 = 0 ;
26059 PyObject * obj1 = 0 ;
26060 char * kwnames[] = {
26061 (char *) "self",(char *) "noDST", NULL
26062 };
26063
26064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26066 if (!SWIG_IsOK(res1)) {
26067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26068 }
26069 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26070 if (obj1) {
26071 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26072 if (!SWIG_IsOK(ecode2)) {
26073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26074 }
26075 arg2 = static_cast< bool >(val2);
26076 }
26077 {
26078 PyThreadState* __tstate = wxPyBeginAllowThreads();
26079 {
26080 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26081 result = (wxDateTime *) &_result_ref;
26082 }
26083 wxPyEndAllowThreads(__tstate);
26084 if (PyErr_Occurred()) SWIG_fail;
26085 }
26086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26087 return resultobj;
26088 fail:
26089 return NULL;
26090 }
26091
26092
26093 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26094 PyObject *resultobj = 0;
26095 wxDateTime *arg1 = (wxDateTime *) 0 ;
26096 bool arg2 = (bool) false ;
26097 wxDateTime result;
26098 void *argp1 = 0 ;
26099 int res1 = 0 ;
26100 bool val2 ;
26101 int ecode2 = 0 ;
26102 PyObject * obj0 = 0 ;
26103 PyObject * obj1 = 0 ;
26104 char * kwnames[] = {
26105 (char *) "self",(char *) "noDST", NULL
26106 };
26107
26108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26110 if (!SWIG_IsOK(res1)) {
26111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26112 }
26113 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26114 if (obj1) {
26115 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26116 if (!SWIG_IsOK(ecode2)) {
26117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26118 }
26119 arg2 = static_cast< bool >(val2);
26120 }
26121 {
26122 PyThreadState* __tstate = wxPyBeginAllowThreads();
26123 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26124 wxPyEndAllowThreads(__tstate);
26125 if (PyErr_Occurred()) SWIG_fail;
26126 }
26127 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26128 return resultobj;
26129 fail:
26130 return NULL;
26131 }
26132
26133
26134 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26135 PyObject *resultobj = 0;
26136 wxDateTime *arg1 = (wxDateTime *) 0 ;
26137 bool arg2 = (bool) false ;
26138 wxDateTime *result = 0 ;
26139 void *argp1 = 0 ;
26140 int res1 = 0 ;
26141 bool val2 ;
26142 int ecode2 = 0 ;
26143 PyObject * obj0 = 0 ;
26144 PyObject * obj1 = 0 ;
26145 char * kwnames[] = {
26146 (char *) "self",(char *) "noDST", NULL
26147 };
26148
26149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26151 if (!SWIG_IsOK(res1)) {
26152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26153 }
26154 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26155 if (obj1) {
26156 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26157 if (!SWIG_IsOK(ecode2)) {
26158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26159 }
26160 arg2 = static_cast< bool >(val2);
26161 }
26162 {
26163 PyThreadState* __tstate = wxPyBeginAllowThreads();
26164 {
26165 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26166 result = (wxDateTime *) &_result_ref;
26167 }
26168 wxPyEndAllowThreads(__tstate);
26169 if (PyErr_Occurred()) SWIG_fail;
26170 }
26171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26172 return resultobj;
26173 fail:
26174 return NULL;
26175 }
26176
26177
26178 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26179 PyObject *resultobj = 0;
26180 wxDateTime *arg1 = (wxDateTime *) 0 ;
26181 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26182 int result;
26183 void *argp1 = 0 ;
26184 int res1 = 0 ;
26185 int val2 ;
26186 int ecode2 = 0 ;
26187 PyObject * obj0 = 0 ;
26188 PyObject * obj1 = 0 ;
26189 char * kwnames[] = {
26190 (char *) "self",(char *) "country", NULL
26191 };
26192
26193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26195 if (!SWIG_IsOK(res1)) {
26196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26197 }
26198 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26199 if (obj1) {
26200 ecode2 = SWIG_AsVal_int(obj1, &val2);
26201 if (!SWIG_IsOK(ecode2)) {
26202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26203 }
26204 arg2 = static_cast< wxDateTime::Country >(val2);
26205 }
26206 {
26207 PyThreadState* __tstate = wxPyBeginAllowThreads();
26208 result = (int)(arg1)->IsDST(arg2);
26209 wxPyEndAllowThreads(__tstate);
26210 if (PyErr_Occurred()) SWIG_fail;
26211 }
26212 resultobj = SWIG_From_int(static_cast< int >(result));
26213 return resultobj;
26214 fail:
26215 return NULL;
26216 }
26217
26218
26219 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26220 PyObject *resultobj = 0;
26221 wxDateTime *arg1 = (wxDateTime *) 0 ;
26222 bool result;
26223 void *argp1 = 0 ;
26224 int res1 = 0 ;
26225 PyObject *swig_obj[1] ;
26226
26227 if (!args) SWIG_fail;
26228 swig_obj[0] = args;
26229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26230 if (!SWIG_IsOK(res1)) {
26231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26232 }
26233 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26234 {
26235 PyThreadState* __tstate = wxPyBeginAllowThreads();
26236 result = (bool)((wxDateTime const *)arg1)->IsValid();
26237 wxPyEndAllowThreads(__tstate);
26238 if (PyErr_Occurred()) SWIG_fail;
26239 }
26240 {
26241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26242 }
26243 return resultobj;
26244 fail:
26245 return NULL;
26246 }
26247
26248
26249 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26250 PyObject *resultobj = 0;
26251 wxDateTime *arg1 = (wxDateTime *) 0 ;
26252 time_t result;
26253 void *argp1 = 0 ;
26254 int res1 = 0 ;
26255 PyObject *swig_obj[1] ;
26256
26257 if (!args) SWIG_fail;
26258 swig_obj[0] = args;
26259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26260 if (!SWIG_IsOK(res1)) {
26261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26262 }
26263 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26264 {
26265 PyThreadState* __tstate = wxPyBeginAllowThreads();
26266 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26267 wxPyEndAllowThreads(__tstate);
26268 if (PyErr_Occurred()) SWIG_fail;
26269 }
26270 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26271 return resultobj;
26272 fail:
26273 return NULL;
26274 }
26275
26276
26277 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26278 PyObject *resultobj = 0;
26279 wxDateTime *arg1 = (wxDateTime *) 0 ;
26280 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26281 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26282 int result;
26283 void *argp1 = 0 ;
26284 int res1 = 0 ;
26285 bool temp2 = false ;
26286 PyObject * obj0 = 0 ;
26287 PyObject * obj1 = 0 ;
26288 char * kwnames[] = {
26289 (char *) "self",(char *) "tz", NULL
26290 };
26291
26292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26294 if (!SWIG_IsOK(res1)) {
26295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26296 }
26297 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26298 if (obj1) {
26299 {
26300 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26301 temp2 = true;
26302 }
26303 }
26304 {
26305 PyThreadState* __tstate = wxPyBeginAllowThreads();
26306 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26307 wxPyEndAllowThreads(__tstate);
26308 if (PyErr_Occurred()) SWIG_fail;
26309 }
26310 resultobj = SWIG_From_int(static_cast< int >(result));
26311 {
26312 if (temp2) delete arg2;
26313 }
26314 return resultobj;
26315 fail:
26316 {
26317 if (temp2) delete arg2;
26318 }
26319 return NULL;
26320 }
26321
26322
26323 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26324 PyObject *resultobj = 0;
26325 wxDateTime *arg1 = (wxDateTime *) 0 ;
26326 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26327 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26328 wxDateTime::Month result;
26329 void *argp1 = 0 ;
26330 int res1 = 0 ;
26331 bool temp2 = false ;
26332 PyObject * obj0 = 0 ;
26333 PyObject * obj1 = 0 ;
26334 char * kwnames[] = {
26335 (char *) "self",(char *) "tz", NULL
26336 };
26337
26338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26340 if (!SWIG_IsOK(res1)) {
26341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26342 }
26343 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26344 if (obj1) {
26345 {
26346 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26347 temp2 = true;
26348 }
26349 }
26350 {
26351 PyThreadState* __tstate = wxPyBeginAllowThreads();
26352 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26353 wxPyEndAllowThreads(__tstate);
26354 if (PyErr_Occurred()) SWIG_fail;
26355 }
26356 resultobj = SWIG_From_int(static_cast< int >(result));
26357 {
26358 if (temp2) delete arg2;
26359 }
26360 return resultobj;
26361 fail:
26362 {
26363 if (temp2) delete arg2;
26364 }
26365 return NULL;
26366 }
26367
26368
26369 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26370 PyObject *resultobj = 0;
26371 wxDateTime *arg1 = (wxDateTime *) 0 ;
26372 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26373 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26374 int result;
26375 void *argp1 = 0 ;
26376 int res1 = 0 ;
26377 bool temp2 = false ;
26378 PyObject * obj0 = 0 ;
26379 PyObject * obj1 = 0 ;
26380 char * kwnames[] = {
26381 (char *) "self",(char *) "tz", NULL
26382 };
26383
26384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26386 if (!SWIG_IsOK(res1)) {
26387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26388 }
26389 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26390 if (obj1) {
26391 {
26392 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26393 temp2 = true;
26394 }
26395 }
26396 {
26397 PyThreadState* __tstate = wxPyBeginAllowThreads();
26398 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26399 wxPyEndAllowThreads(__tstate);
26400 if (PyErr_Occurred()) SWIG_fail;
26401 }
26402 resultobj = SWIG_From_int(static_cast< int >(result));
26403 {
26404 if (temp2) delete arg2;
26405 }
26406 return resultobj;
26407 fail:
26408 {
26409 if (temp2) delete arg2;
26410 }
26411 return NULL;
26412 }
26413
26414
26415 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26416 PyObject *resultobj = 0;
26417 wxDateTime *arg1 = (wxDateTime *) 0 ;
26418 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26419 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26420 wxDateTime::WeekDay result;
26421 void *argp1 = 0 ;
26422 int res1 = 0 ;
26423 bool temp2 = false ;
26424 PyObject * obj0 = 0 ;
26425 PyObject * obj1 = 0 ;
26426 char * kwnames[] = {
26427 (char *) "self",(char *) "tz", NULL
26428 };
26429
26430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26432 if (!SWIG_IsOK(res1)) {
26433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26434 }
26435 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26436 if (obj1) {
26437 {
26438 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26439 temp2 = true;
26440 }
26441 }
26442 {
26443 PyThreadState* __tstate = wxPyBeginAllowThreads();
26444 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26445 wxPyEndAllowThreads(__tstate);
26446 if (PyErr_Occurred()) SWIG_fail;
26447 }
26448 resultobj = SWIG_From_int(static_cast< int >(result));
26449 {
26450 if (temp2) delete arg2;
26451 }
26452 return resultobj;
26453 fail:
26454 {
26455 if (temp2) delete arg2;
26456 }
26457 return NULL;
26458 }
26459
26460
26461 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26462 PyObject *resultobj = 0;
26463 wxDateTime *arg1 = (wxDateTime *) 0 ;
26464 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26465 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26466 int result;
26467 void *argp1 = 0 ;
26468 int res1 = 0 ;
26469 bool temp2 = false ;
26470 PyObject * obj0 = 0 ;
26471 PyObject * obj1 = 0 ;
26472 char * kwnames[] = {
26473 (char *) "self",(char *) "tz", NULL
26474 };
26475
26476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26478 if (!SWIG_IsOK(res1)) {
26479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26480 }
26481 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26482 if (obj1) {
26483 {
26484 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26485 temp2 = true;
26486 }
26487 }
26488 {
26489 PyThreadState* __tstate = wxPyBeginAllowThreads();
26490 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26491 wxPyEndAllowThreads(__tstate);
26492 if (PyErr_Occurred()) SWIG_fail;
26493 }
26494 resultobj = SWIG_From_int(static_cast< int >(result));
26495 {
26496 if (temp2) delete arg2;
26497 }
26498 return resultobj;
26499 fail:
26500 {
26501 if (temp2) delete arg2;
26502 }
26503 return NULL;
26504 }
26505
26506
26507 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26508 PyObject *resultobj = 0;
26509 wxDateTime *arg1 = (wxDateTime *) 0 ;
26510 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26511 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26512 int result;
26513 void *argp1 = 0 ;
26514 int res1 = 0 ;
26515 bool temp2 = false ;
26516 PyObject * obj0 = 0 ;
26517 PyObject * obj1 = 0 ;
26518 char * kwnames[] = {
26519 (char *) "self",(char *) "tz", NULL
26520 };
26521
26522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26524 if (!SWIG_IsOK(res1)) {
26525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26526 }
26527 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26528 if (obj1) {
26529 {
26530 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26531 temp2 = true;
26532 }
26533 }
26534 {
26535 PyThreadState* __tstate = wxPyBeginAllowThreads();
26536 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26537 wxPyEndAllowThreads(__tstate);
26538 if (PyErr_Occurred()) SWIG_fail;
26539 }
26540 resultobj = SWIG_From_int(static_cast< int >(result));
26541 {
26542 if (temp2) delete arg2;
26543 }
26544 return resultobj;
26545 fail:
26546 {
26547 if (temp2) delete arg2;
26548 }
26549 return NULL;
26550 }
26551
26552
26553 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26554 PyObject *resultobj = 0;
26555 wxDateTime *arg1 = (wxDateTime *) 0 ;
26556 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26557 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26558 int result;
26559 void *argp1 = 0 ;
26560 int res1 = 0 ;
26561 bool temp2 = false ;
26562 PyObject * obj0 = 0 ;
26563 PyObject * obj1 = 0 ;
26564 char * kwnames[] = {
26565 (char *) "self",(char *) "tz", NULL
26566 };
26567
26568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26570 if (!SWIG_IsOK(res1)) {
26571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26572 }
26573 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26574 if (obj1) {
26575 {
26576 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26577 temp2 = true;
26578 }
26579 }
26580 {
26581 PyThreadState* __tstate = wxPyBeginAllowThreads();
26582 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26583 wxPyEndAllowThreads(__tstate);
26584 if (PyErr_Occurred()) SWIG_fail;
26585 }
26586 resultobj = SWIG_From_int(static_cast< int >(result));
26587 {
26588 if (temp2) delete arg2;
26589 }
26590 return resultobj;
26591 fail:
26592 {
26593 if (temp2) delete arg2;
26594 }
26595 return NULL;
26596 }
26597
26598
26599 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26600 PyObject *resultobj = 0;
26601 wxDateTime *arg1 = (wxDateTime *) 0 ;
26602 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26603 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26604 int result;
26605 void *argp1 = 0 ;
26606 int res1 = 0 ;
26607 bool temp2 = false ;
26608 PyObject * obj0 = 0 ;
26609 PyObject * obj1 = 0 ;
26610 char * kwnames[] = {
26611 (char *) "self",(char *) "tz", NULL
26612 };
26613
26614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) 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_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26618 }
26619 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26620 if (obj1) {
26621 {
26622 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26623 temp2 = true;
26624 }
26625 }
26626 {
26627 PyThreadState* __tstate = wxPyBeginAllowThreads();
26628 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26629 wxPyEndAllowThreads(__tstate);
26630 if (PyErr_Occurred()) SWIG_fail;
26631 }
26632 resultobj = SWIG_From_int(static_cast< int >(result));
26633 {
26634 if (temp2) delete arg2;
26635 }
26636 return resultobj;
26637 fail:
26638 {
26639 if (temp2) delete arg2;
26640 }
26641 return NULL;
26642 }
26643
26644
26645 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26646 PyObject *resultobj = 0;
26647 wxDateTime *arg1 = (wxDateTime *) 0 ;
26648 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26649 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26650 int result;
26651 void *argp1 = 0 ;
26652 int res1 = 0 ;
26653 bool temp2 = false ;
26654 PyObject * obj0 = 0 ;
26655 PyObject * obj1 = 0 ;
26656 char * kwnames[] = {
26657 (char *) "self",(char *) "tz", NULL
26658 };
26659
26660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26662 if (!SWIG_IsOK(res1)) {
26663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26664 }
26665 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26666 if (obj1) {
26667 {
26668 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26669 temp2 = true;
26670 }
26671 }
26672 {
26673 PyThreadState* __tstate = wxPyBeginAllowThreads();
26674 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26675 wxPyEndAllowThreads(__tstate);
26676 if (PyErr_Occurred()) SWIG_fail;
26677 }
26678 resultobj = SWIG_From_int(static_cast< int >(result));
26679 {
26680 if (temp2) delete arg2;
26681 }
26682 return resultobj;
26683 fail:
26684 {
26685 if (temp2) delete arg2;
26686 }
26687 return NULL;
26688 }
26689
26690
26691 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26692 PyObject *resultobj = 0;
26693 wxDateTime *arg1 = (wxDateTime *) 0 ;
26694 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26695 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26696 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26697 int result;
26698 void *argp1 = 0 ;
26699 int res1 = 0 ;
26700 int val2 ;
26701 int ecode2 = 0 ;
26702 bool temp3 = false ;
26703 PyObject * obj0 = 0 ;
26704 PyObject * obj1 = 0 ;
26705 PyObject * obj2 = 0 ;
26706 char * kwnames[] = {
26707 (char *) "self",(char *) "flags",(char *) "tz", NULL
26708 };
26709
26710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26712 if (!SWIG_IsOK(res1)) {
26713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26714 }
26715 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26716 if (obj1) {
26717 ecode2 = SWIG_AsVal_int(obj1, &val2);
26718 if (!SWIG_IsOK(ecode2)) {
26719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26720 }
26721 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26722 }
26723 if (obj2) {
26724 {
26725 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26726 temp3 = true;
26727 }
26728 }
26729 {
26730 PyThreadState* __tstate = wxPyBeginAllowThreads();
26731 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26732 wxPyEndAllowThreads(__tstate);
26733 if (PyErr_Occurred()) SWIG_fail;
26734 }
26735 resultobj = SWIG_From_int(static_cast< int >(result));
26736 {
26737 if (temp3) delete arg3;
26738 }
26739 return resultobj;
26740 fail:
26741 {
26742 if (temp3) delete arg3;
26743 }
26744 return NULL;
26745 }
26746
26747
26748 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26749 PyObject *resultobj = 0;
26750 wxDateTime *arg1 = (wxDateTime *) 0 ;
26751 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26752 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26753 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26754 int result;
26755 void *argp1 = 0 ;
26756 int res1 = 0 ;
26757 int val2 ;
26758 int ecode2 = 0 ;
26759 bool temp3 = false ;
26760 PyObject * obj0 = 0 ;
26761 PyObject * obj1 = 0 ;
26762 PyObject * obj2 = 0 ;
26763 char * kwnames[] = {
26764 (char *) "self",(char *) "flags",(char *) "tz", NULL
26765 };
26766
26767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) 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_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26771 }
26772 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26773 if (obj1) {
26774 ecode2 = SWIG_AsVal_int(obj1, &val2);
26775 if (!SWIG_IsOK(ecode2)) {
26776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26777 }
26778 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26779 }
26780 if (obj2) {
26781 {
26782 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26783 temp3 = true;
26784 }
26785 }
26786 {
26787 PyThreadState* __tstate = wxPyBeginAllowThreads();
26788 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26789 wxPyEndAllowThreads(__tstate);
26790 if (PyErr_Occurred()) SWIG_fail;
26791 }
26792 resultobj = SWIG_From_int(static_cast< int >(result));
26793 {
26794 if (temp3) delete arg3;
26795 }
26796 return resultobj;
26797 fail:
26798 {
26799 if (temp3) delete arg3;
26800 }
26801 return NULL;
26802 }
26803
26804
26805 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26806 PyObject *resultobj = 0;
26807 wxDateTime *arg1 = (wxDateTime *) 0 ;
26808 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26809 bool result;
26810 void *argp1 = 0 ;
26811 int res1 = 0 ;
26812 int val2 ;
26813 int ecode2 = 0 ;
26814 PyObject * obj0 = 0 ;
26815 PyObject * obj1 = 0 ;
26816 char * kwnames[] = {
26817 (char *) "self",(char *) "country", NULL
26818 };
26819
26820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26822 if (!SWIG_IsOK(res1)) {
26823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26824 }
26825 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26826 if (obj1) {
26827 ecode2 = SWIG_AsVal_int(obj1, &val2);
26828 if (!SWIG_IsOK(ecode2)) {
26829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26830 }
26831 arg2 = static_cast< wxDateTime::Country >(val2);
26832 }
26833 {
26834 PyThreadState* __tstate = wxPyBeginAllowThreads();
26835 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26836 wxPyEndAllowThreads(__tstate);
26837 if (PyErr_Occurred()) SWIG_fail;
26838 }
26839 {
26840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26841 }
26842 return resultobj;
26843 fail:
26844 return NULL;
26845 }
26846
26847
26848 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26849 PyObject *resultobj = 0;
26850 wxDateTime *arg1 = (wxDateTime *) 0 ;
26851 wxDateTime *arg2 = 0 ;
26852 bool result;
26853 void *argp1 = 0 ;
26854 int res1 = 0 ;
26855 void *argp2 = 0 ;
26856 int res2 = 0 ;
26857 PyObject * obj0 = 0 ;
26858 PyObject * obj1 = 0 ;
26859 char * kwnames[] = {
26860 (char *) "self",(char *) "datetime", NULL
26861 };
26862
26863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26865 if (!SWIG_IsOK(res1)) {
26866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26867 }
26868 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26869 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26870 if (!SWIG_IsOK(res2)) {
26871 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26872 }
26873 if (!argp2) {
26874 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26875 }
26876 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26877 {
26878 PyThreadState* __tstate = wxPyBeginAllowThreads();
26879 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26880 wxPyEndAllowThreads(__tstate);
26881 if (PyErr_Occurred()) SWIG_fail;
26882 }
26883 {
26884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26885 }
26886 return resultobj;
26887 fail:
26888 return NULL;
26889 }
26890
26891
26892 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26893 PyObject *resultobj = 0;
26894 wxDateTime *arg1 = (wxDateTime *) 0 ;
26895 wxDateTime *arg2 = 0 ;
26896 bool result;
26897 void *argp1 = 0 ;
26898 int res1 = 0 ;
26899 void *argp2 = 0 ;
26900 int res2 = 0 ;
26901 PyObject * obj0 = 0 ;
26902 PyObject * obj1 = 0 ;
26903 char * kwnames[] = {
26904 (char *) "self",(char *) "datetime", NULL
26905 };
26906
26907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26909 if (!SWIG_IsOK(res1)) {
26910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26911 }
26912 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26913 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26914 if (!SWIG_IsOK(res2)) {
26915 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26916 }
26917 if (!argp2) {
26918 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26919 }
26920 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26921 {
26922 PyThreadState* __tstate = wxPyBeginAllowThreads();
26923 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26924 wxPyEndAllowThreads(__tstate);
26925 if (PyErr_Occurred()) SWIG_fail;
26926 }
26927 {
26928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26929 }
26930 return resultobj;
26931 fail:
26932 return NULL;
26933 }
26934
26935
26936 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26937 PyObject *resultobj = 0;
26938 wxDateTime *arg1 = (wxDateTime *) 0 ;
26939 wxDateTime *arg2 = 0 ;
26940 bool result;
26941 void *argp1 = 0 ;
26942 int res1 = 0 ;
26943 void *argp2 = 0 ;
26944 int res2 = 0 ;
26945 PyObject * obj0 = 0 ;
26946 PyObject * obj1 = 0 ;
26947 char * kwnames[] = {
26948 (char *) "self",(char *) "datetime", NULL
26949 };
26950
26951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26953 if (!SWIG_IsOK(res1)) {
26954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26955 }
26956 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26957 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26958 if (!SWIG_IsOK(res2)) {
26959 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26960 }
26961 if (!argp2) {
26962 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26963 }
26964 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26965 {
26966 PyThreadState* __tstate = wxPyBeginAllowThreads();
26967 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26968 wxPyEndAllowThreads(__tstate);
26969 if (PyErr_Occurred()) SWIG_fail;
26970 }
26971 {
26972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26973 }
26974 return resultobj;
26975 fail:
26976 return NULL;
26977 }
26978
26979
26980 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26981 PyObject *resultobj = 0;
26982 wxDateTime *arg1 = (wxDateTime *) 0 ;
26983 wxDateTime *arg2 = 0 ;
26984 wxDateTime *arg3 = 0 ;
26985 bool result;
26986 void *argp1 = 0 ;
26987 int res1 = 0 ;
26988 void *argp2 = 0 ;
26989 int res2 = 0 ;
26990 void *argp3 = 0 ;
26991 int res3 = 0 ;
26992 PyObject * obj0 = 0 ;
26993 PyObject * obj1 = 0 ;
26994 PyObject * obj2 = 0 ;
26995 char * kwnames[] = {
26996 (char *) "self",(char *) "t1",(char *) "t2", NULL
26997 };
26998
26999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27001 if (!SWIG_IsOK(res1)) {
27002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27003 }
27004 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27005 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27006 if (!SWIG_IsOK(res2)) {
27007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27008 }
27009 if (!argp2) {
27010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27011 }
27012 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27013 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27014 if (!SWIG_IsOK(res3)) {
27015 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27016 }
27017 if (!argp3) {
27018 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27019 }
27020 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27021 {
27022 PyThreadState* __tstate = wxPyBeginAllowThreads();
27023 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27024 wxPyEndAllowThreads(__tstate);
27025 if (PyErr_Occurred()) SWIG_fail;
27026 }
27027 {
27028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27029 }
27030 return resultobj;
27031 fail:
27032 return NULL;
27033 }
27034
27035
27036 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27037 PyObject *resultobj = 0;
27038 wxDateTime *arg1 = (wxDateTime *) 0 ;
27039 wxDateTime *arg2 = 0 ;
27040 wxDateTime *arg3 = 0 ;
27041 bool result;
27042 void *argp1 = 0 ;
27043 int res1 = 0 ;
27044 void *argp2 = 0 ;
27045 int res2 = 0 ;
27046 void *argp3 = 0 ;
27047 int res3 = 0 ;
27048 PyObject * obj0 = 0 ;
27049 PyObject * obj1 = 0 ;
27050 PyObject * obj2 = 0 ;
27051 char * kwnames[] = {
27052 (char *) "self",(char *) "t1",(char *) "t2", NULL
27053 };
27054
27055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) 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_IsBetween" "', 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_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27064 }
27065 if (!argp2) {
27066 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27067 }
27068 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27069 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27070 if (!SWIG_IsOK(res3)) {
27071 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27072 }
27073 if (!argp3) {
27074 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27075 }
27076 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27077 {
27078 PyThreadState* __tstate = wxPyBeginAllowThreads();
27079 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27080 wxPyEndAllowThreads(__tstate);
27081 if (PyErr_Occurred()) SWIG_fail;
27082 }
27083 {
27084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27085 }
27086 return resultobj;
27087 fail:
27088 return NULL;
27089 }
27090
27091
27092 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27093 PyObject *resultobj = 0;
27094 wxDateTime *arg1 = (wxDateTime *) 0 ;
27095 wxDateTime *arg2 = 0 ;
27096 bool result;
27097 void *argp1 = 0 ;
27098 int res1 = 0 ;
27099 void *argp2 = 0 ;
27100 int res2 = 0 ;
27101 PyObject * obj0 = 0 ;
27102 PyObject * obj1 = 0 ;
27103 char * kwnames[] = {
27104 (char *) "self",(char *) "dt", NULL
27105 };
27106
27107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27109 if (!SWIG_IsOK(res1)) {
27110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27111 }
27112 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27113 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27114 if (!SWIG_IsOK(res2)) {
27115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27116 }
27117 if (!argp2) {
27118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27119 }
27120 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27121 {
27122 PyThreadState* __tstate = wxPyBeginAllowThreads();
27123 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27124 wxPyEndAllowThreads(__tstate);
27125 if (PyErr_Occurred()) SWIG_fail;
27126 }
27127 {
27128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27129 }
27130 return resultobj;
27131 fail:
27132 return NULL;
27133 }
27134
27135
27136 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27137 PyObject *resultobj = 0;
27138 wxDateTime *arg1 = (wxDateTime *) 0 ;
27139 wxDateTime *arg2 = 0 ;
27140 bool result;
27141 void *argp1 = 0 ;
27142 int res1 = 0 ;
27143 void *argp2 = 0 ;
27144 int res2 = 0 ;
27145 PyObject * obj0 = 0 ;
27146 PyObject * obj1 = 0 ;
27147 char * kwnames[] = {
27148 (char *) "self",(char *) "dt", NULL
27149 };
27150
27151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27153 if (!SWIG_IsOK(res1)) {
27154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27155 }
27156 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27157 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27158 if (!SWIG_IsOK(res2)) {
27159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27160 }
27161 if (!argp2) {
27162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27163 }
27164 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27165 {
27166 PyThreadState* __tstate = wxPyBeginAllowThreads();
27167 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27168 wxPyEndAllowThreads(__tstate);
27169 if (PyErr_Occurred()) SWIG_fail;
27170 }
27171 {
27172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27173 }
27174 return resultobj;
27175 fail:
27176 return NULL;
27177 }
27178
27179
27180 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27181 PyObject *resultobj = 0;
27182 wxDateTime *arg1 = (wxDateTime *) 0 ;
27183 wxDateTime *arg2 = 0 ;
27184 wxTimeSpan *arg3 = 0 ;
27185 bool result;
27186 void *argp1 = 0 ;
27187 int res1 = 0 ;
27188 void *argp2 = 0 ;
27189 int res2 = 0 ;
27190 void *argp3 = 0 ;
27191 int res3 = 0 ;
27192 PyObject * obj0 = 0 ;
27193 PyObject * obj1 = 0 ;
27194 PyObject * obj2 = 0 ;
27195 char * kwnames[] = {
27196 (char *) "self",(char *) "dt",(char *) "ts", NULL
27197 };
27198
27199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27201 if (!SWIG_IsOK(res1)) {
27202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27203 }
27204 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27205 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27206 if (!SWIG_IsOK(res2)) {
27207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27208 }
27209 if (!argp2) {
27210 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27211 }
27212 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27213 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27214 if (!SWIG_IsOK(res3)) {
27215 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27216 }
27217 if (!argp3) {
27218 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27219 }
27220 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27221 {
27222 PyThreadState* __tstate = wxPyBeginAllowThreads();
27223 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27224 wxPyEndAllowThreads(__tstate);
27225 if (PyErr_Occurred()) SWIG_fail;
27226 }
27227 {
27228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27229 }
27230 return resultobj;
27231 fail:
27232 return NULL;
27233 }
27234
27235
27236 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27237 PyObject *resultobj = 0;
27238 wxDateTime *arg1 = (wxDateTime *) 0 ;
27239 wxTimeSpan *arg2 = 0 ;
27240 wxDateTime *result = 0 ;
27241 void *argp1 = 0 ;
27242 int res1 = 0 ;
27243 void *argp2 = 0 ;
27244 int res2 = 0 ;
27245 PyObject * obj0 = 0 ;
27246 PyObject * obj1 = 0 ;
27247 char * kwnames[] = {
27248 (char *) "self",(char *) "diff", NULL
27249 };
27250
27251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27253 if (!SWIG_IsOK(res1)) {
27254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27255 }
27256 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27257 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27258 if (!SWIG_IsOK(res2)) {
27259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27260 }
27261 if (!argp2) {
27262 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27263 }
27264 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27265 {
27266 PyThreadState* __tstate = wxPyBeginAllowThreads();
27267 {
27268 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27269 result = (wxDateTime *) &_result_ref;
27270 }
27271 wxPyEndAllowThreads(__tstate);
27272 if (PyErr_Occurred()) SWIG_fail;
27273 }
27274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27275 return resultobj;
27276 fail:
27277 return NULL;
27278 }
27279
27280
27281 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27282 PyObject *resultobj = 0;
27283 wxDateTime *arg1 = (wxDateTime *) 0 ;
27284 wxDateSpan *arg2 = 0 ;
27285 wxDateTime *result = 0 ;
27286 void *argp1 = 0 ;
27287 int res1 = 0 ;
27288 void *argp2 = 0 ;
27289 int res2 = 0 ;
27290 PyObject * obj0 = 0 ;
27291 PyObject * obj1 = 0 ;
27292 char * kwnames[] = {
27293 (char *) "self",(char *) "diff", NULL
27294 };
27295
27296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27298 if (!SWIG_IsOK(res1)) {
27299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27300 }
27301 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27302 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27303 if (!SWIG_IsOK(res2)) {
27304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27305 }
27306 if (!argp2) {
27307 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27308 }
27309 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27310 {
27311 PyThreadState* __tstate = wxPyBeginAllowThreads();
27312 {
27313 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27314 result = (wxDateTime *) &_result_ref;
27315 }
27316 wxPyEndAllowThreads(__tstate);
27317 if (PyErr_Occurred()) SWIG_fail;
27318 }
27319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27320 return resultobj;
27321 fail:
27322 return NULL;
27323 }
27324
27325
27326 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27327 PyObject *resultobj = 0;
27328 wxDateTime *arg1 = (wxDateTime *) 0 ;
27329 wxTimeSpan *arg2 = 0 ;
27330 wxDateTime *result = 0 ;
27331 void *argp1 = 0 ;
27332 int res1 = 0 ;
27333 void *argp2 = 0 ;
27334 int res2 = 0 ;
27335 PyObject * obj0 = 0 ;
27336 PyObject * obj1 = 0 ;
27337 char * kwnames[] = {
27338 (char *) "self",(char *) "diff", NULL
27339 };
27340
27341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27343 if (!SWIG_IsOK(res1)) {
27344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27345 }
27346 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27347 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27348 if (!SWIG_IsOK(res2)) {
27349 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27350 }
27351 if (!argp2) {
27352 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27353 }
27354 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27355 {
27356 PyThreadState* __tstate = wxPyBeginAllowThreads();
27357 {
27358 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27359 result = (wxDateTime *) &_result_ref;
27360 }
27361 wxPyEndAllowThreads(__tstate);
27362 if (PyErr_Occurred()) SWIG_fail;
27363 }
27364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27365 return resultobj;
27366 fail:
27367 return NULL;
27368 }
27369
27370
27371 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27372 PyObject *resultobj = 0;
27373 wxDateTime *arg1 = (wxDateTime *) 0 ;
27374 wxDateSpan *arg2 = 0 ;
27375 wxDateTime *result = 0 ;
27376 void *argp1 = 0 ;
27377 int res1 = 0 ;
27378 void *argp2 = 0 ;
27379 int res2 = 0 ;
27380 PyObject * obj0 = 0 ;
27381 PyObject * obj1 = 0 ;
27382 char * kwnames[] = {
27383 (char *) "self",(char *) "diff", NULL
27384 };
27385
27386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27388 if (!SWIG_IsOK(res1)) {
27389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27390 }
27391 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27392 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27393 if (!SWIG_IsOK(res2)) {
27394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27395 }
27396 if (!argp2) {
27397 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27398 }
27399 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27400 {
27401 PyThreadState* __tstate = wxPyBeginAllowThreads();
27402 {
27403 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27404 result = (wxDateTime *) &_result_ref;
27405 }
27406 wxPyEndAllowThreads(__tstate);
27407 if (PyErr_Occurred()) SWIG_fail;
27408 }
27409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27410 return resultobj;
27411 fail:
27412 return NULL;
27413 }
27414
27415
27416 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27417 PyObject *resultobj = 0;
27418 wxDateTime *arg1 = (wxDateTime *) 0 ;
27419 wxDateTime *arg2 = 0 ;
27420 wxTimeSpan result;
27421 void *argp1 = 0 ;
27422 int res1 = 0 ;
27423 void *argp2 = 0 ;
27424 int res2 = 0 ;
27425 PyObject * obj0 = 0 ;
27426 PyObject * obj1 = 0 ;
27427 char * kwnames[] = {
27428 (char *) "self",(char *) "dt", NULL
27429 };
27430
27431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27433 if (!SWIG_IsOK(res1)) {
27434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27435 }
27436 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27437 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27438 if (!SWIG_IsOK(res2)) {
27439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27440 }
27441 if (!argp2) {
27442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27443 }
27444 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27445 {
27446 PyThreadState* __tstate = wxPyBeginAllowThreads();
27447 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27448 wxPyEndAllowThreads(__tstate);
27449 if (PyErr_Occurred()) SWIG_fail;
27450 }
27451 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27452 return resultobj;
27453 fail:
27454 return NULL;
27455 }
27456
27457
27458 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27459 PyObject *resultobj = 0;
27460 wxDateTime *arg1 = (wxDateTime *) 0 ;
27461 wxTimeSpan *arg2 = 0 ;
27462 wxDateTime *result = 0 ;
27463 void *argp1 = 0 ;
27464 int res1 = 0 ;
27465 void *argp2 = 0 ;
27466 int res2 = 0 ;
27467
27468 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27470 if (!SWIG_IsOK(res1)) {
27471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27472 }
27473 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27474 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27475 if (!SWIG_IsOK(res2)) {
27476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27477 }
27478 if (!argp2) {
27479 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27480 }
27481 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27482 {
27483 PyThreadState* __tstate = wxPyBeginAllowThreads();
27484 {
27485 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27486 result = (wxDateTime *) &_result_ref;
27487 }
27488 wxPyEndAllowThreads(__tstate);
27489 if (PyErr_Occurred()) SWIG_fail;
27490 }
27491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27492 return resultobj;
27493 fail:
27494 return NULL;
27495 }
27496
27497
27498 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27499 PyObject *resultobj = 0;
27500 wxDateTime *arg1 = (wxDateTime *) 0 ;
27501 wxDateSpan *arg2 = 0 ;
27502 wxDateTime *result = 0 ;
27503 void *argp1 = 0 ;
27504 int res1 = 0 ;
27505 void *argp2 = 0 ;
27506 int res2 = 0 ;
27507
27508 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27510 if (!SWIG_IsOK(res1)) {
27511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27512 }
27513 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27514 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27515 if (!SWIG_IsOK(res2)) {
27516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27517 }
27518 if (!argp2) {
27519 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27520 }
27521 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27522 {
27523 PyThreadState* __tstate = wxPyBeginAllowThreads();
27524 {
27525 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27526 result = (wxDateTime *) &_result_ref;
27527 }
27528 wxPyEndAllowThreads(__tstate);
27529 if (PyErr_Occurred()) SWIG_fail;
27530 }
27531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27532 return resultobj;
27533 fail:
27534 return NULL;
27535 }
27536
27537
27538 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27539 int argc;
27540 PyObject *argv[3];
27541
27542 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27543 --argc;
27544 if (argc == 2) {
27545 int _v = 0;
27546 {
27547 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27548 _v = SWIG_CheckState(res);
27549 }
27550 if (!_v) goto check_1;
27551 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27552 }
27553 check_1:
27554
27555 if (argc == 2) {
27556 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27557 }
27558
27559 fail:
27560 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27561 return NULL;
27562 }
27563
27564
27565 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27566 PyObject *resultobj = 0;
27567 wxDateTime *arg1 = (wxDateTime *) 0 ;
27568 wxTimeSpan *arg2 = 0 ;
27569 wxDateTime *result = 0 ;
27570 void *argp1 = 0 ;
27571 int res1 = 0 ;
27572 void *argp2 = 0 ;
27573 int res2 = 0 ;
27574
27575 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27577 if (!SWIG_IsOK(res1)) {
27578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27579 }
27580 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27581 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27582 if (!SWIG_IsOK(res2)) {
27583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27584 }
27585 if (!argp2) {
27586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27587 }
27588 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27589 {
27590 PyThreadState* __tstate = wxPyBeginAllowThreads();
27591 {
27592 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27593 result = (wxDateTime *) &_result_ref;
27594 }
27595 wxPyEndAllowThreads(__tstate);
27596 if (PyErr_Occurred()) SWIG_fail;
27597 }
27598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27599 return resultobj;
27600 fail:
27601 return NULL;
27602 }
27603
27604
27605 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27606 PyObject *resultobj = 0;
27607 wxDateTime *arg1 = (wxDateTime *) 0 ;
27608 wxDateSpan *arg2 = 0 ;
27609 wxDateTime *result = 0 ;
27610 void *argp1 = 0 ;
27611 int res1 = 0 ;
27612 void *argp2 = 0 ;
27613 int res2 = 0 ;
27614
27615 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27617 if (!SWIG_IsOK(res1)) {
27618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27619 }
27620 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27621 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27622 if (!SWIG_IsOK(res2)) {
27623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27624 }
27625 if (!argp2) {
27626 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27627 }
27628 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27629 {
27630 PyThreadState* __tstate = wxPyBeginAllowThreads();
27631 {
27632 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27633 result = (wxDateTime *) &_result_ref;
27634 }
27635 wxPyEndAllowThreads(__tstate);
27636 if (PyErr_Occurred()) SWIG_fail;
27637 }
27638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27639 return resultobj;
27640 fail:
27641 return NULL;
27642 }
27643
27644
27645 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27646 int argc;
27647 PyObject *argv[3];
27648
27649 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27650 --argc;
27651 if (argc == 2) {
27652 int _v = 0;
27653 {
27654 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27655 _v = SWIG_CheckState(res);
27656 }
27657 if (!_v) goto check_1;
27658 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27659 }
27660 check_1:
27661
27662 if (argc == 2) {
27663 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27664 }
27665
27666 fail:
27667 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27668 return NULL;
27669 }
27670
27671
27672 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27673 PyObject *resultobj = 0;
27674 wxDateTime *arg1 = (wxDateTime *) 0 ;
27675 wxTimeSpan *arg2 = 0 ;
27676 wxDateTime result;
27677 void *argp1 = 0 ;
27678 int res1 = 0 ;
27679 void *argp2 = 0 ;
27680 int res2 = 0 ;
27681
27682 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27684 if (!SWIG_IsOK(res1)) {
27685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27686 }
27687 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27688 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27689 if (!SWIG_IsOK(res2)) {
27690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27691 }
27692 if (!argp2) {
27693 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27694 }
27695 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27696 {
27697 PyThreadState* __tstate = wxPyBeginAllowThreads();
27698 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27699 wxPyEndAllowThreads(__tstate);
27700 if (PyErr_Occurred()) SWIG_fail;
27701 }
27702 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27703 return resultobj;
27704 fail:
27705 return NULL;
27706 }
27707
27708
27709 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27710 PyObject *resultobj = 0;
27711 wxDateTime *arg1 = (wxDateTime *) 0 ;
27712 wxDateSpan *arg2 = 0 ;
27713 wxDateTime result;
27714 void *argp1 = 0 ;
27715 int res1 = 0 ;
27716 void *argp2 = 0 ;
27717 int res2 = 0 ;
27718
27719 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27721 if (!SWIG_IsOK(res1)) {
27722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27723 }
27724 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27725 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27726 if (!SWIG_IsOK(res2)) {
27727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27728 }
27729 if (!argp2) {
27730 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27731 }
27732 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27733 {
27734 PyThreadState* __tstate = wxPyBeginAllowThreads();
27735 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27736 wxPyEndAllowThreads(__tstate);
27737 if (PyErr_Occurred()) SWIG_fail;
27738 }
27739 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27740 return resultobj;
27741 fail:
27742 return NULL;
27743 }
27744
27745
27746 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27747 int argc;
27748 PyObject *argv[3];
27749
27750 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27751 --argc;
27752 if (argc == 2) {
27753 int _v = 0;
27754 {
27755 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27756 _v = SWIG_CheckState(res);
27757 }
27758 if (!_v) goto check_1;
27759 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27760 }
27761 check_1:
27762
27763 if (argc == 2) {
27764 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27765 }
27766
27767 fail:
27768 Py_INCREF(Py_NotImplemented);
27769 return Py_NotImplemented;
27770 }
27771
27772
27773 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27774 PyObject *resultobj = 0;
27775 wxDateTime *arg1 = (wxDateTime *) 0 ;
27776 wxDateTime *arg2 = 0 ;
27777 wxTimeSpan result;
27778 void *argp1 = 0 ;
27779 int res1 = 0 ;
27780 void *argp2 = 0 ;
27781 int res2 = 0 ;
27782
27783 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27785 if (!SWIG_IsOK(res1)) {
27786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27787 }
27788 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27789 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27790 if (!SWIG_IsOK(res2)) {
27791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27792 }
27793 if (!argp2) {
27794 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27795 }
27796 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27797 {
27798 PyThreadState* __tstate = wxPyBeginAllowThreads();
27799 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27800 wxPyEndAllowThreads(__tstate);
27801 if (PyErr_Occurred()) SWIG_fail;
27802 }
27803 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27804 return resultobj;
27805 fail:
27806 return NULL;
27807 }
27808
27809
27810 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27811 PyObject *resultobj = 0;
27812 wxDateTime *arg1 = (wxDateTime *) 0 ;
27813 wxTimeSpan *arg2 = 0 ;
27814 wxDateTime result;
27815 void *argp1 = 0 ;
27816 int res1 = 0 ;
27817 void *argp2 = 0 ;
27818 int res2 = 0 ;
27819
27820 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27822 if (!SWIG_IsOK(res1)) {
27823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27824 }
27825 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27826 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27827 if (!SWIG_IsOK(res2)) {
27828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27829 }
27830 if (!argp2) {
27831 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27832 }
27833 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27834 {
27835 PyThreadState* __tstate = wxPyBeginAllowThreads();
27836 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27837 wxPyEndAllowThreads(__tstate);
27838 if (PyErr_Occurred()) SWIG_fail;
27839 }
27840 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27841 return resultobj;
27842 fail:
27843 return NULL;
27844 }
27845
27846
27847 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27848 PyObject *resultobj = 0;
27849 wxDateTime *arg1 = (wxDateTime *) 0 ;
27850 wxDateSpan *arg2 = 0 ;
27851 wxDateTime result;
27852 void *argp1 = 0 ;
27853 int res1 = 0 ;
27854 void *argp2 = 0 ;
27855 int res2 = 0 ;
27856
27857 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27859 if (!SWIG_IsOK(res1)) {
27860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27861 }
27862 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27863 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27864 if (!SWIG_IsOK(res2)) {
27865 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27866 }
27867 if (!argp2) {
27868 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27869 }
27870 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27871 {
27872 PyThreadState* __tstate = wxPyBeginAllowThreads();
27873 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27874 wxPyEndAllowThreads(__tstate);
27875 if (PyErr_Occurred()) SWIG_fail;
27876 }
27877 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27878 return resultobj;
27879 fail:
27880 return NULL;
27881 }
27882
27883
27884 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27885 int argc;
27886 PyObject *argv[3];
27887
27888 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27889 --argc;
27890 if (argc == 2) {
27891 int _v = 0;
27892 {
27893 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27894 _v = SWIG_CheckState(res);
27895 }
27896 if (!_v) goto check_1;
27897 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27898 }
27899 check_1:
27900
27901 if (argc == 2) {
27902 int _v = 0;
27903 {
27904 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27905 _v = SWIG_CheckState(res);
27906 }
27907 if (!_v) goto check_2;
27908 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27909 }
27910 check_2:
27911
27912 if (argc == 2) {
27913 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27914 }
27915
27916 fail:
27917 Py_INCREF(Py_NotImplemented);
27918 return Py_NotImplemented;
27919 }
27920
27921
27922 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27923 PyObject *resultobj = 0;
27924 wxDateTime *arg1 = (wxDateTime *) 0 ;
27925 wxDateTime *arg2 = (wxDateTime *) 0 ;
27926 bool result;
27927 void *argp1 = 0 ;
27928 int res1 = 0 ;
27929 void *argp2 = 0 ;
27930 int res2 = 0 ;
27931 PyObject * obj0 = 0 ;
27932 PyObject * obj1 = 0 ;
27933 char * kwnames[] = {
27934 (char *) "self",(char *) "other", NULL
27935 };
27936
27937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27939 if (!SWIG_IsOK(res1)) {
27940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27941 }
27942 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27943 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27944 if (!SWIG_IsOK(res2)) {
27945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27946 }
27947 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27948 {
27949 PyThreadState* __tstate = wxPyBeginAllowThreads();
27950 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27951 wxPyEndAllowThreads(__tstate);
27952 if (PyErr_Occurred()) SWIG_fail;
27953 }
27954 {
27955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27956 }
27957 return resultobj;
27958 fail:
27959 return NULL;
27960 }
27961
27962
27963 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27964 PyObject *resultobj = 0;
27965 wxDateTime *arg1 = (wxDateTime *) 0 ;
27966 wxDateTime *arg2 = (wxDateTime *) 0 ;
27967 bool result;
27968 void *argp1 = 0 ;
27969 int res1 = 0 ;
27970 void *argp2 = 0 ;
27971 int res2 = 0 ;
27972 PyObject * obj0 = 0 ;
27973 PyObject * obj1 = 0 ;
27974 char * kwnames[] = {
27975 (char *) "self",(char *) "other", NULL
27976 };
27977
27978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27980 if (!SWIG_IsOK(res1)) {
27981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27982 }
27983 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27984 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27985 if (!SWIG_IsOK(res2)) {
27986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27987 }
27988 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27989 {
27990 PyThreadState* __tstate = wxPyBeginAllowThreads();
27991 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27992 wxPyEndAllowThreads(__tstate);
27993 if (PyErr_Occurred()) SWIG_fail;
27994 }
27995 {
27996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27997 }
27998 return resultobj;
27999 fail:
28000 return NULL;
28001 }
28002
28003
28004 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28005 PyObject *resultobj = 0;
28006 wxDateTime *arg1 = (wxDateTime *) 0 ;
28007 wxDateTime *arg2 = (wxDateTime *) 0 ;
28008 bool result;
28009 void *argp1 = 0 ;
28010 int res1 = 0 ;
28011 void *argp2 = 0 ;
28012 int res2 = 0 ;
28013 PyObject * obj0 = 0 ;
28014 PyObject * obj1 = 0 ;
28015 char * kwnames[] = {
28016 (char *) "self",(char *) "other", NULL
28017 };
28018
28019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28021 if (!SWIG_IsOK(res1)) {
28022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28023 }
28024 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28025 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28026 if (!SWIG_IsOK(res2)) {
28027 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28028 }
28029 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28030 {
28031 PyThreadState* __tstate = wxPyBeginAllowThreads();
28032 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28033 wxPyEndAllowThreads(__tstate);
28034 if (PyErr_Occurred()) SWIG_fail;
28035 }
28036 {
28037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28038 }
28039 return resultobj;
28040 fail:
28041 return NULL;
28042 }
28043
28044
28045 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28046 PyObject *resultobj = 0;
28047 wxDateTime *arg1 = (wxDateTime *) 0 ;
28048 wxDateTime *arg2 = (wxDateTime *) 0 ;
28049 bool result;
28050 void *argp1 = 0 ;
28051 int res1 = 0 ;
28052 void *argp2 = 0 ;
28053 int res2 = 0 ;
28054 PyObject * obj0 = 0 ;
28055 PyObject * obj1 = 0 ;
28056 char * kwnames[] = {
28057 (char *) "self",(char *) "other", NULL
28058 };
28059
28060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28062 if (!SWIG_IsOK(res1)) {
28063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28064 }
28065 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28066 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28067 if (!SWIG_IsOK(res2)) {
28068 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28069 }
28070 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28071 {
28072 PyThreadState* __tstate = wxPyBeginAllowThreads();
28073 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28074 wxPyEndAllowThreads(__tstate);
28075 if (PyErr_Occurred()) SWIG_fail;
28076 }
28077 {
28078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28079 }
28080 return resultobj;
28081 fail:
28082 return NULL;
28083 }
28084
28085
28086 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28087 PyObject *resultobj = 0;
28088 wxDateTime *arg1 = (wxDateTime *) 0 ;
28089 wxDateTime *arg2 = (wxDateTime *) 0 ;
28090 bool result;
28091 void *argp1 = 0 ;
28092 int res1 = 0 ;
28093 void *argp2 = 0 ;
28094 int res2 = 0 ;
28095 PyObject * obj0 = 0 ;
28096 PyObject * obj1 = 0 ;
28097 char * kwnames[] = {
28098 (char *) "self",(char *) "other", NULL
28099 };
28100
28101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28103 if (!SWIG_IsOK(res1)) {
28104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28105 }
28106 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28107 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28108 if (!SWIG_IsOK(res2)) {
28109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28110 }
28111 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28112 {
28113 PyThreadState* __tstate = wxPyBeginAllowThreads();
28114 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28115 wxPyEndAllowThreads(__tstate);
28116 if (PyErr_Occurred()) SWIG_fail;
28117 }
28118 {
28119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28120 }
28121 return resultobj;
28122 fail:
28123 return NULL;
28124 }
28125
28126
28127 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28128 PyObject *resultobj = 0;
28129 wxDateTime *arg1 = (wxDateTime *) 0 ;
28130 wxDateTime *arg2 = (wxDateTime *) 0 ;
28131 bool result;
28132 void *argp1 = 0 ;
28133 int res1 = 0 ;
28134 void *argp2 = 0 ;
28135 int res2 = 0 ;
28136 PyObject * obj0 = 0 ;
28137 PyObject * obj1 = 0 ;
28138 char * kwnames[] = {
28139 (char *) "self",(char *) "other", NULL
28140 };
28141
28142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28144 if (!SWIG_IsOK(res1)) {
28145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28146 }
28147 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28148 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28149 if (!SWIG_IsOK(res2)) {
28150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28151 }
28152 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28153 {
28154 PyThreadState* __tstate = wxPyBeginAllowThreads();
28155 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28156 wxPyEndAllowThreads(__tstate);
28157 if (PyErr_Occurred()) SWIG_fail;
28158 }
28159 {
28160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28161 }
28162 return resultobj;
28163 fail:
28164 return NULL;
28165 }
28166
28167
28168 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28169 PyObject *resultobj = 0;
28170 wxDateTime *arg1 = (wxDateTime *) 0 ;
28171 wxString *arg2 = 0 ;
28172 int result;
28173 void *argp1 = 0 ;
28174 int res1 = 0 ;
28175 bool temp2 = false ;
28176 PyObject * obj0 = 0 ;
28177 PyObject * obj1 = 0 ;
28178 char * kwnames[] = {
28179 (char *) "self",(char *) "date", NULL
28180 };
28181
28182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28184 if (!SWIG_IsOK(res1)) {
28185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28186 }
28187 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28188 {
28189 arg2 = wxString_in_helper(obj1);
28190 if (arg2 == NULL) SWIG_fail;
28191 temp2 = true;
28192 }
28193 {
28194 PyThreadState* __tstate = wxPyBeginAllowThreads();
28195 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28196 wxPyEndAllowThreads(__tstate);
28197 if (PyErr_Occurred()) SWIG_fail;
28198 }
28199 resultobj = SWIG_From_int(static_cast< int >(result));
28200 {
28201 if (temp2)
28202 delete arg2;
28203 }
28204 return resultobj;
28205 fail:
28206 {
28207 if (temp2)
28208 delete arg2;
28209 }
28210 return NULL;
28211 }
28212
28213
28214 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28215 PyObject *resultobj = 0;
28216 wxDateTime *arg1 = (wxDateTime *) 0 ;
28217 wxString *arg2 = 0 ;
28218 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28219 wxString *arg3 = (wxString *) &arg3_defvalue ;
28220 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28221 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28222 int result;
28223 void *argp1 = 0 ;
28224 int res1 = 0 ;
28225 bool temp2 = false ;
28226 bool temp3 = false ;
28227 void *argp4 = 0 ;
28228 int res4 = 0 ;
28229 PyObject * obj0 = 0 ;
28230 PyObject * obj1 = 0 ;
28231 PyObject * obj2 = 0 ;
28232 PyObject * obj3 = 0 ;
28233 char * kwnames[] = {
28234 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28235 };
28236
28237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28239 if (!SWIG_IsOK(res1)) {
28240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28241 }
28242 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28243 {
28244 arg2 = wxString_in_helper(obj1);
28245 if (arg2 == NULL) SWIG_fail;
28246 temp2 = true;
28247 }
28248 if (obj2) {
28249 {
28250 arg3 = wxString_in_helper(obj2);
28251 if (arg3 == NULL) SWIG_fail;
28252 temp3 = true;
28253 }
28254 }
28255 if (obj3) {
28256 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28257 if (!SWIG_IsOK(res4)) {
28258 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28259 }
28260 if (!argp4) {
28261 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28262 }
28263 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28264 }
28265 {
28266 PyThreadState* __tstate = wxPyBeginAllowThreads();
28267 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28268 wxPyEndAllowThreads(__tstate);
28269 if (PyErr_Occurred()) SWIG_fail;
28270 }
28271 resultobj = SWIG_From_int(static_cast< int >(result));
28272 {
28273 if (temp2)
28274 delete arg2;
28275 }
28276 {
28277 if (temp3)
28278 delete arg3;
28279 }
28280 return resultobj;
28281 fail:
28282 {
28283 if (temp2)
28284 delete arg2;
28285 }
28286 {
28287 if (temp3)
28288 delete arg3;
28289 }
28290 return NULL;
28291 }
28292
28293
28294 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28295 PyObject *resultobj = 0;
28296 wxDateTime *arg1 = (wxDateTime *) 0 ;
28297 wxString *arg2 = 0 ;
28298 int result;
28299 void *argp1 = 0 ;
28300 int res1 = 0 ;
28301 bool temp2 = false ;
28302 PyObject * obj0 = 0 ;
28303 PyObject * obj1 = 0 ;
28304 char * kwnames[] = {
28305 (char *) "self",(char *) "datetime", NULL
28306 };
28307
28308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28310 if (!SWIG_IsOK(res1)) {
28311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28312 }
28313 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28314 {
28315 arg2 = wxString_in_helper(obj1);
28316 if (arg2 == NULL) SWIG_fail;
28317 temp2 = true;
28318 }
28319 {
28320 PyThreadState* __tstate = wxPyBeginAllowThreads();
28321 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28322 wxPyEndAllowThreads(__tstate);
28323 if (PyErr_Occurred()) SWIG_fail;
28324 }
28325 resultobj = SWIG_From_int(static_cast< int >(result));
28326 {
28327 if (temp2)
28328 delete arg2;
28329 }
28330 return resultobj;
28331 fail:
28332 {
28333 if (temp2)
28334 delete arg2;
28335 }
28336 return NULL;
28337 }
28338
28339
28340 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28341 PyObject *resultobj = 0;
28342 wxDateTime *arg1 = (wxDateTime *) 0 ;
28343 wxString *arg2 = 0 ;
28344 int result;
28345 void *argp1 = 0 ;
28346 int res1 = 0 ;
28347 bool temp2 = false ;
28348 PyObject * obj0 = 0 ;
28349 PyObject * obj1 = 0 ;
28350 char * kwnames[] = {
28351 (char *) "self",(char *) "date", NULL
28352 };
28353
28354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28356 if (!SWIG_IsOK(res1)) {
28357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28358 }
28359 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28360 {
28361 arg2 = wxString_in_helper(obj1);
28362 if (arg2 == NULL) SWIG_fail;
28363 temp2 = true;
28364 }
28365 {
28366 PyThreadState* __tstate = wxPyBeginAllowThreads();
28367 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28368 wxPyEndAllowThreads(__tstate);
28369 if (PyErr_Occurred()) SWIG_fail;
28370 }
28371 resultobj = SWIG_From_int(static_cast< int >(result));
28372 {
28373 if (temp2)
28374 delete arg2;
28375 }
28376 return resultobj;
28377 fail:
28378 {
28379 if (temp2)
28380 delete arg2;
28381 }
28382 return NULL;
28383 }
28384
28385
28386 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28387 PyObject *resultobj = 0;
28388 wxDateTime *arg1 = (wxDateTime *) 0 ;
28389 wxString *arg2 = 0 ;
28390 int result;
28391 void *argp1 = 0 ;
28392 int res1 = 0 ;
28393 bool temp2 = false ;
28394 PyObject * obj0 = 0 ;
28395 PyObject * obj1 = 0 ;
28396 char * kwnames[] = {
28397 (char *) "self",(char *) "time", NULL
28398 };
28399
28400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28402 if (!SWIG_IsOK(res1)) {
28403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28404 }
28405 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28406 {
28407 arg2 = wxString_in_helper(obj1);
28408 if (arg2 == NULL) SWIG_fail;
28409 temp2 = true;
28410 }
28411 {
28412 PyThreadState* __tstate = wxPyBeginAllowThreads();
28413 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28414 wxPyEndAllowThreads(__tstate);
28415 if (PyErr_Occurred()) SWIG_fail;
28416 }
28417 resultobj = SWIG_From_int(static_cast< int >(result));
28418 {
28419 if (temp2)
28420 delete arg2;
28421 }
28422 return resultobj;
28423 fail:
28424 {
28425 if (temp2)
28426 delete arg2;
28427 }
28428 return NULL;
28429 }
28430
28431
28432 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28433 PyObject *resultobj = 0;
28434 wxDateTime *arg1 = (wxDateTime *) 0 ;
28435 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28436 wxString *arg2 = (wxString *) &arg2_defvalue ;
28437 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28438 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28439 wxString result;
28440 void *argp1 = 0 ;
28441 int res1 = 0 ;
28442 bool temp2 = false ;
28443 bool temp3 = false ;
28444 PyObject * obj0 = 0 ;
28445 PyObject * obj1 = 0 ;
28446 PyObject * obj2 = 0 ;
28447 char * kwnames[] = {
28448 (char *) "self",(char *) "format",(char *) "tz", NULL
28449 };
28450
28451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28453 if (!SWIG_IsOK(res1)) {
28454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28455 }
28456 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28457 if (obj1) {
28458 {
28459 arg2 = wxString_in_helper(obj1);
28460 if (arg2 == NULL) SWIG_fail;
28461 temp2 = true;
28462 }
28463 }
28464 if (obj2) {
28465 {
28466 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28467 temp3 = true;
28468 }
28469 }
28470 {
28471 PyThreadState* __tstate = wxPyBeginAllowThreads();
28472 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28473 wxPyEndAllowThreads(__tstate);
28474 if (PyErr_Occurred()) SWIG_fail;
28475 }
28476 {
28477 #if wxUSE_UNICODE
28478 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28479 #else
28480 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28481 #endif
28482 }
28483 {
28484 if (temp2)
28485 delete arg2;
28486 }
28487 {
28488 if (temp3) delete arg3;
28489 }
28490 return resultobj;
28491 fail:
28492 {
28493 if (temp2)
28494 delete arg2;
28495 }
28496 {
28497 if (temp3) delete arg3;
28498 }
28499 return NULL;
28500 }
28501
28502
28503 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28504 PyObject *resultobj = 0;
28505 wxDateTime *arg1 = (wxDateTime *) 0 ;
28506 wxString result;
28507 void *argp1 = 0 ;
28508 int res1 = 0 ;
28509 PyObject *swig_obj[1] ;
28510
28511 if (!args) SWIG_fail;
28512 swig_obj[0] = args;
28513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28514 if (!SWIG_IsOK(res1)) {
28515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28516 }
28517 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28518 {
28519 PyThreadState* __tstate = wxPyBeginAllowThreads();
28520 result = ((wxDateTime const *)arg1)->FormatDate();
28521 wxPyEndAllowThreads(__tstate);
28522 if (PyErr_Occurred()) SWIG_fail;
28523 }
28524 {
28525 #if wxUSE_UNICODE
28526 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28527 #else
28528 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28529 #endif
28530 }
28531 return resultobj;
28532 fail:
28533 return NULL;
28534 }
28535
28536
28537 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28538 PyObject *resultobj = 0;
28539 wxDateTime *arg1 = (wxDateTime *) 0 ;
28540 wxString result;
28541 void *argp1 = 0 ;
28542 int res1 = 0 ;
28543 PyObject *swig_obj[1] ;
28544
28545 if (!args) SWIG_fail;
28546 swig_obj[0] = args;
28547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28548 if (!SWIG_IsOK(res1)) {
28549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28550 }
28551 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28552 {
28553 PyThreadState* __tstate = wxPyBeginAllowThreads();
28554 result = ((wxDateTime const *)arg1)->FormatTime();
28555 wxPyEndAllowThreads(__tstate);
28556 if (PyErr_Occurred()) SWIG_fail;
28557 }
28558 {
28559 #if wxUSE_UNICODE
28560 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28561 #else
28562 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28563 #endif
28564 }
28565 return resultobj;
28566 fail:
28567 return NULL;
28568 }
28569
28570
28571 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28572 PyObject *resultobj = 0;
28573 wxDateTime *arg1 = (wxDateTime *) 0 ;
28574 wxString result;
28575 void *argp1 = 0 ;
28576 int res1 = 0 ;
28577 PyObject *swig_obj[1] ;
28578
28579 if (!args) SWIG_fail;
28580 swig_obj[0] = args;
28581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28582 if (!SWIG_IsOK(res1)) {
28583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28584 }
28585 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28586 {
28587 PyThreadState* __tstate = wxPyBeginAllowThreads();
28588 result = ((wxDateTime const *)arg1)->FormatISODate();
28589 wxPyEndAllowThreads(__tstate);
28590 if (PyErr_Occurred()) SWIG_fail;
28591 }
28592 {
28593 #if wxUSE_UNICODE
28594 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28595 #else
28596 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28597 #endif
28598 }
28599 return resultobj;
28600 fail:
28601 return NULL;
28602 }
28603
28604
28605 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28606 PyObject *resultobj = 0;
28607 wxDateTime *arg1 = (wxDateTime *) 0 ;
28608 wxString result;
28609 void *argp1 = 0 ;
28610 int res1 = 0 ;
28611 PyObject *swig_obj[1] ;
28612
28613 if (!args) SWIG_fail;
28614 swig_obj[0] = args;
28615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28616 if (!SWIG_IsOK(res1)) {
28617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28618 }
28619 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28620 {
28621 PyThreadState* __tstate = wxPyBeginAllowThreads();
28622 result = ((wxDateTime const *)arg1)->FormatISOTime();
28623 wxPyEndAllowThreads(__tstate);
28624 if (PyErr_Occurred()) SWIG_fail;
28625 }
28626 {
28627 #if wxUSE_UNICODE
28628 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28629 #else
28630 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28631 #endif
28632 }
28633 return resultobj;
28634 fail:
28635 return NULL;
28636 }
28637
28638
28639 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28640 PyObject *obj;
28641 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28642 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28643 return SWIG_Py_Void();
28644 }
28645
28646 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28647 return SWIG_Python_InitShadowInstance(args);
28648 }
28649
28650 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(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 *) "ms", NULL
28659 };
28660
28661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",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_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28665 }
28666 arg1 = static_cast< long >(val1);
28667 {
28668 PyThreadState* __tstate = wxPyBeginAllowThreads();
28669 result = wxTimeSpan::Milliseconds(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_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28681 PyObject *resultobj = 0;
28682 wxTimeSpan result;
28683
28684 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28685 {
28686 PyThreadState* __tstate = wxPyBeginAllowThreads();
28687 result = wxTimeSpan::Millisecond();
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_Seconds(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 *) "sec", NULL
28707 };
28708
28709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",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_Seconds" "', expected argument " "1"" of type '" "long""'");
28713 }
28714 arg1 = static_cast< long >(val1);
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 result = wxTimeSpan::Seconds(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_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28729 PyObject *resultobj = 0;
28730 wxTimeSpan result;
28731
28732 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28733 {
28734 PyThreadState* __tstate = wxPyBeginAllowThreads();
28735 result = wxTimeSpan::Second();
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_Minutes(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 *) "min", NULL
28755 };
28756
28757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",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_Minutes" "', expected argument " "1"" of type '" "long""'");
28761 }
28762 arg1 = static_cast< long >(val1);
28763 {
28764 PyThreadState* __tstate = wxPyBeginAllowThreads();
28765 result = wxTimeSpan::Minutes(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_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28777 PyObject *resultobj = 0;
28778 wxTimeSpan result;
28779
28780 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28781 {
28782 PyThreadState* __tstate = wxPyBeginAllowThreads();
28783 result = wxTimeSpan::Minute();
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_Hours(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 *) "hours", NULL
28803 };
28804
28805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",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_Hours" "', expected argument " "1"" of type '" "long""'");
28809 }
28810 arg1 = static_cast< long >(val1);
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 result = wxTimeSpan::Hours(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_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28825 PyObject *resultobj = 0;
28826 wxTimeSpan result;
28827
28828 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28829 {
28830 PyThreadState* __tstate = wxPyBeginAllowThreads();
28831 result = wxTimeSpan::Hour();
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_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28843 PyObject *resultobj = 0;
28844 long arg1 ;
28845 wxTimeSpan result;
28846 long val1 ;
28847 int ecode1 = 0 ;
28848 PyObject * obj0 = 0 ;
28849 char * kwnames[] = {
28850 (char *) "days", NULL
28851 };
28852
28853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28854 ecode1 = SWIG_AsVal_long(obj0, &val1);
28855 if (!SWIG_IsOK(ecode1)) {
28856 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28857 }
28858 arg1 = static_cast< long >(val1);
28859 {
28860 PyThreadState* __tstate = wxPyBeginAllowThreads();
28861 result = wxTimeSpan::Days(arg1);
28862 wxPyEndAllowThreads(__tstate);
28863 if (PyErr_Occurred()) SWIG_fail;
28864 }
28865 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28866 return resultobj;
28867 fail:
28868 return NULL;
28869 }
28870
28871
28872 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28873 PyObject *resultobj = 0;
28874 wxTimeSpan result;
28875
28876 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28877 {
28878 PyThreadState* __tstate = wxPyBeginAllowThreads();
28879 result = wxTimeSpan::Day();
28880 wxPyEndAllowThreads(__tstate);
28881 if (PyErr_Occurred()) SWIG_fail;
28882 }
28883 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28884 return resultobj;
28885 fail:
28886 return NULL;
28887 }
28888
28889
28890 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28891 PyObject *resultobj = 0;
28892 long arg1 ;
28893 wxTimeSpan result;
28894 long val1 ;
28895 int ecode1 = 0 ;
28896 PyObject * obj0 = 0 ;
28897 char * kwnames[] = {
28898 (char *) "days", NULL
28899 };
28900
28901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28902 ecode1 = SWIG_AsVal_long(obj0, &val1);
28903 if (!SWIG_IsOK(ecode1)) {
28904 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28905 }
28906 arg1 = static_cast< long >(val1);
28907 {
28908 PyThreadState* __tstate = wxPyBeginAllowThreads();
28909 result = wxTimeSpan::Weeks(arg1);
28910 wxPyEndAllowThreads(__tstate);
28911 if (PyErr_Occurred()) SWIG_fail;
28912 }
28913 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28914 return resultobj;
28915 fail:
28916 return NULL;
28917 }
28918
28919
28920 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28921 PyObject *resultobj = 0;
28922 wxTimeSpan result;
28923
28924 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28925 {
28926 PyThreadState* __tstate = wxPyBeginAllowThreads();
28927 result = wxTimeSpan::Week();
28928 wxPyEndAllowThreads(__tstate);
28929 if (PyErr_Occurred()) SWIG_fail;
28930 }
28931 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28932 return resultobj;
28933 fail:
28934 return NULL;
28935 }
28936
28937
28938 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28939 PyObject *resultobj = 0;
28940 long arg1 = (long) 0 ;
28941 long arg2 = (long) 0 ;
28942 long arg3 = (long) 0 ;
28943 long arg4 = (long) 0 ;
28944 wxTimeSpan *result = 0 ;
28945 long val1 ;
28946 int ecode1 = 0 ;
28947 long val2 ;
28948 int ecode2 = 0 ;
28949 long val3 ;
28950 int ecode3 = 0 ;
28951 long val4 ;
28952 int ecode4 = 0 ;
28953 PyObject * obj0 = 0 ;
28954 PyObject * obj1 = 0 ;
28955 PyObject * obj2 = 0 ;
28956 PyObject * obj3 = 0 ;
28957 char * kwnames[] = {
28958 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28959 };
28960
28961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28962 if (obj0) {
28963 ecode1 = SWIG_AsVal_long(obj0, &val1);
28964 if (!SWIG_IsOK(ecode1)) {
28965 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28966 }
28967 arg1 = static_cast< long >(val1);
28968 }
28969 if (obj1) {
28970 ecode2 = SWIG_AsVal_long(obj1, &val2);
28971 if (!SWIG_IsOK(ecode2)) {
28972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28973 }
28974 arg2 = static_cast< long >(val2);
28975 }
28976 if (obj2) {
28977 ecode3 = SWIG_AsVal_long(obj2, &val3);
28978 if (!SWIG_IsOK(ecode3)) {
28979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28980 }
28981 arg3 = static_cast< long >(val3);
28982 }
28983 if (obj3) {
28984 ecode4 = SWIG_AsVal_long(obj3, &val4);
28985 if (!SWIG_IsOK(ecode4)) {
28986 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28987 }
28988 arg4 = static_cast< long >(val4);
28989 }
28990 {
28991 PyThreadState* __tstate = wxPyBeginAllowThreads();
28992 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28993 wxPyEndAllowThreads(__tstate);
28994 if (PyErr_Occurred()) SWIG_fail;
28995 }
28996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28997 return resultobj;
28998 fail:
28999 return NULL;
29000 }
29001
29002
29003 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29004 PyObject *resultobj = 0;
29005 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29006 void *argp1 = 0 ;
29007 int res1 = 0 ;
29008 PyObject *swig_obj[1] ;
29009
29010 if (!args) SWIG_fail;
29011 swig_obj[0] = args;
29012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29013 if (!SWIG_IsOK(res1)) {
29014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29015 }
29016 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29017 {
29018 PyThreadState* __tstate = wxPyBeginAllowThreads();
29019 delete arg1;
29020
29021 wxPyEndAllowThreads(__tstate);
29022 if (PyErr_Occurred()) SWIG_fail;
29023 }
29024 resultobj = SWIG_Py_Void();
29025 return resultobj;
29026 fail:
29027 return NULL;
29028 }
29029
29030
29031 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29032 PyObject *resultobj = 0;
29033 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29034 wxTimeSpan *arg2 = 0 ;
29035 wxTimeSpan *result = 0 ;
29036 void *argp1 = 0 ;
29037 int res1 = 0 ;
29038 void *argp2 = 0 ;
29039 int res2 = 0 ;
29040 PyObject * obj0 = 0 ;
29041 PyObject * obj1 = 0 ;
29042 char * kwnames[] = {
29043 (char *) "self",(char *) "diff", NULL
29044 };
29045
29046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29048 if (!SWIG_IsOK(res1)) {
29049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29050 }
29051 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29052 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29053 if (!SWIG_IsOK(res2)) {
29054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29055 }
29056 if (!argp2) {
29057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29058 }
29059 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29060 {
29061 PyThreadState* __tstate = wxPyBeginAllowThreads();
29062 {
29063 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29064 result = (wxTimeSpan *) &_result_ref;
29065 }
29066 wxPyEndAllowThreads(__tstate);
29067 if (PyErr_Occurred()) SWIG_fail;
29068 }
29069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29070 return resultobj;
29071 fail:
29072 return NULL;
29073 }
29074
29075
29076 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29077 PyObject *resultobj = 0;
29078 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29079 wxTimeSpan *arg2 = 0 ;
29080 wxTimeSpan *result = 0 ;
29081 void *argp1 = 0 ;
29082 int res1 = 0 ;
29083 void *argp2 = 0 ;
29084 int res2 = 0 ;
29085 PyObject * obj0 = 0 ;
29086 PyObject * obj1 = 0 ;
29087 char * kwnames[] = {
29088 (char *) "self",(char *) "diff", NULL
29089 };
29090
29091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29093 if (!SWIG_IsOK(res1)) {
29094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29095 }
29096 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29097 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29098 if (!SWIG_IsOK(res2)) {
29099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29100 }
29101 if (!argp2) {
29102 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29103 }
29104 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29105 {
29106 PyThreadState* __tstate = wxPyBeginAllowThreads();
29107 {
29108 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29109 result = (wxTimeSpan *) &_result_ref;
29110 }
29111 wxPyEndAllowThreads(__tstate);
29112 if (PyErr_Occurred()) SWIG_fail;
29113 }
29114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29115 return resultobj;
29116 fail:
29117 return NULL;
29118 }
29119
29120
29121 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29122 PyObject *resultobj = 0;
29123 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29124 int arg2 ;
29125 wxTimeSpan *result = 0 ;
29126 void *argp1 = 0 ;
29127 int res1 = 0 ;
29128 int val2 ;
29129 int ecode2 = 0 ;
29130 PyObject * obj0 = 0 ;
29131 PyObject * obj1 = 0 ;
29132 char * kwnames[] = {
29133 (char *) "self",(char *) "n", NULL
29134 };
29135
29136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29138 if (!SWIG_IsOK(res1)) {
29139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29140 }
29141 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29142 ecode2 = SWIG_AsVal_int(obj1, &val2);
29143 if (!SWIG_IsOK(ecode2)) {
29144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29145 }
29146 arg2 = static_cast< int >(val2);
29147 {
29148 PyThreadState* __tstate = wxPyBeginAllowThreads();
29149 {
29150 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29151 result = (wxTimeSpan *) &_result_ref;
29152 }
29153 wxPyEndAllowThreads(__tstate);
29154 if (PyErr_Occurred()) SWIG_fail;
29155 }
29156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29157 return resultobj;
29158 fail:
29159 return NULL;
29160 }
29161
29162
29163 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29164 PyObject *resultobj = 0;
29165 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29166 wxTimeSpan *result = 0 ;
29167 void *argp1 = 0 ;
29168 int res1 = 0 ;
29169 PyObject *swig_obj[1] ;
29170
29171 if (!args) SWIG_fail;
29172 swig_obj[0] = args;
29173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29174 if (!SWIG_IsOK(res1)) {
29175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29176 }
29177 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29178 {
29179 PyThreadState* __tstate = wxPyBeginAllowThreads();
29180 {
29181 wxTimeSpan &_result_ref = (arg1)->Neg();
29182 result = (wxTimeSpan *) &_result_ref;
29183 }
29184 wxPyEndAllowThreads(__tstate);
29185 if (PyErr_Occurred()) SWIG_fail;
29186 }
29187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29188 return resultobj;
29189 fail:
29190 return NULL;
29191 }
29192
29193
29194 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29195 PyObject *resultobj = 0;
29196 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29197 wxTimeSpan result;
29198 void *argp1 = 0 ;
29199 int res1 = 0 ;
29200 PyObject *swig_obj[1] ;
29201
29202 if (!args) SWIG_fail;
29203 swig_obj[0] = args;
29204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29205 if (!SWIG_IsOK(res1)) {
29206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29207 }
29208 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29209 {
29210 PyThreadState* __tstate = wxPyBeginAllowThreads();
29211 result = ((wxTimeSpan const *)arg1)->Abs();
29212 wxPyEndAllowThreads(__tstate);
29213 if (PyErr_Occurred()) SWIG_fail;
29214 }
29215 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29216 return resultobj;
29217 fail:
29218 return NULL;
29219 }
29220
29221
29222 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29223 PyObject *resultobj = 0;
29224 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29225 wxTimeSpan *arg2 = 0 ;
29226 wxTimeSpan *result = 0 ;
29227 void *argp1 = 0 ;
29228 int res1 = 0 ;
29229 void *argp2 = 0 ;
29230 int res2 = 0 ;
29231 PyObject * obj0 = 0 ;
29232 PyObject * obj1 = 0 ;
29233 char * kwnames[] = {
29234 (char *) "self",(char *) "diff", NULL
29235 };
29236
29237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29239 if (!SWIG_IsOK(res1)) {
29240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29241 }
29242 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29243 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29244 if (!SWIG_IsOK(res2)) {
29245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29246 }
29247 if (!argp2) {
29248 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29249 }
29250 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29251 {
29252 PyThreadState* __tstate = wxPyBeginAllowThreads();
29253 {
29254 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29255 result = (wxTimeSpan *) &_result_ref;
29256 }
29257 wxPyEndAllowThreads(__tstate);
29258 if (PyErr_Occurred()) SWIG_fail;
29259 }
29260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29261 return resultobj;
29262 fail:
29263 return NULL;
29264 }
29265
29266
29267 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29268 PyObject *resultobj = 0;
29269 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29270 wxTimeSpan *arg2 = 0 ;
29271 wxTimeSpan *result = 0 ;
29272 void *argp1 = 0 ;
29273 int res1 = 0 ;
29274 void *argp2 = 0 ;
29275 int res2 = 0 ;
29276 PyObject * obj0 = 0 ;
29277 PyObject * obj1 = 0 ;
29278 char * kwnames[] = {
29279 (char *) "self",(char *) "diff", NULL
29280 };
29281
29282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29284 if (!SWIG_IsOK(res1)) {
29285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29286 }
29287 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29288 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29289 if (!SWIG_IsOK(res2)) {
29290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29291 }
29292 if (!argp2) {
29293 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29294 }
29295 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29296 {
29297 PyThreadState* __tstate = wxPyBeginAllowThreads();
29298 {
29299 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29300 result = (wxTimeSpan *) &_result_ref;
29301 }
29302 wxPyEndAllowThreads(__tstate);
29303 if (PyErr_Occurred()) SWIG_fail;
29304 }
29305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29306 return resultobj;
29307 fail:
29308 return NULL;
29309 }
29310
29311
29312 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29313 PyObject *resultobj = 0;
29314 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29315 int arg2 ;
29316 wxTimeSpan *result = 0 ;
29317 void *argp1 = 0 ;
29318 int res1 = 0 ;
29319 int val2 ;
29320 int ecode2 = 0 ;
29321 PyObject * obj0 = 0 ;
29322 PyObject * obj1 = 0 ;
29323 char * kwnames[] = {
29324 (char *) "self",(char *) "n", NULL
29325 };
29326
29327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29329 if (!SWIG_IsOK(res1)) {
29330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29331 }
29332 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29333 ecode2 = SWIG_AsVal_int(obj1, &val2);
29334 if (!SWIG_IsOK(ecode2)) {
29335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29336 }
29337 arg2 = static_cast< int >(val2);
29338 {
29339 PyThreadState* __tstate = wxPyBeginAllowThreads();
29340 {
29341 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29342 result = (wxTimeSpan *) &_result_ref;
29343 }
29344 wxPyEndAllowThreads(__tstate);
29345 if (PyErr_Occurred()) SWIG_fail;
29346 }
29347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29348 return resultobj;
29349 fail:
29350 return NULL;
29351 }
29352
29353
29354 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29355 PyObject *resultobj = 0;
29356 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29357 wxTimeSpan *result = 0 ;
29358 void *argp1 = 0 ;
29359 int res1 = 0 ;
29360 PyObject *swig_obj[1] ;
29361
29362 if (!args) SWIG_fail;
29363 swig_obj[0] = args;
29364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29365 if (!SWIG_IsOK(res1)) {
29366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29367 }
29368 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29369 {
29370 PyThreadState* __tstate = wxPyBeginAllowThreads();
29371 {
29372 wxTimeSpan &_result_ref = (arg1)->operator -();
29373 result = (wxTimeSpan *) &_result_ref;
29374 }
29375 wxPyEndAllowThreads(__tstate);
29376 if (PyErr_Occurred()) SWIG_fail;
29377 }
29378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29379 return resultobj;
29380 fail:
29381 return NULL;
29382 }
29383
29384
29385 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29386 PyObject *resultobj = 0;
29387 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29388 wxTimeSpan *arg2 = 0 ;
29389 wxTimeSpan result;
29390 void *argp1 = 0 ;
29391 int res1 = 0 ;
29392 void *argp2 = 0 ;
29393 int res2 = 0 ;
29394 PyObject * obj0 = 0 ;
29395 PyObject * obj1 = 0 ;
29396 char * kwnames[] = {
29397 (char *) "self",(char *) "other", NULL
29398 };
29399
29400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29402 if (!SWIG_IsOK(res1)) {
29403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29404 }
29405 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29406 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29407 if (!SWIG_IsOK(res2)) {
29408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29409 }
29410 if (!argp2) {
29411 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29412 }
29413 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29414 {
29415 PyThreadState* __tstate = wxPyBeginAllowThreads();
29416 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29417 wxPyEndAllowThreads(__tstate);
29418 if (PyErr_Occurred()) SWIG_fail;
29419 }
29420 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29421 return resultobj;
29422 fail:
29423 return NULL;
29424 }
29425
29426
29427 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29428 PyObject *resultobj = 0;
29429 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29430 wxTimeSpan *arg2 = 0 ;
29431 wxTimeSpan result;
29432 void *argp1 = 0 ;
29433 int res1 = 0 ;
29434 void *argp2 = 0 ;
29435 int res2 = 0 ;
29436 PyObject * obj0 = 0 ;
29437 PyObject * obj1 = 0 ;
29438 char * kwnames[] = {
29439 (char *) "self",(char *) "other", NULL
29440 };
29441
29442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29444 if (!SWIG_IsOK(res1)) {
29445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29446 }
29447 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29448 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29449 if (!SWIG_IsOK(res2)) {
29450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29451 }
29452 if (!argp2) {
29453 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29454 }
29455 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29456 {
29457 PyThreadState* __tstate = wxPyBeginAllowThreads();
29458 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29459 wxPyEndAllowThreads(__tstate);
29460 if (PyErr_Occurred()) SWIG_fail;
29461 }
29462 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29463 return resultobj;
29464 fail:
29465 return NULL;
29466 }
29467
29468
29469 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29470 PyObject *resultobj = 0;
29471 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29472 int arg2 ;
29473 wxTimeSpan result;
29474 void *argp1 = 0 ;
29475 int res1 = 0 ;
29476 int val2 ;
29477 int ecode2 = 0 ;
29478 PyObject * obj0 = 0 ;
29479 PyObject * obj1 = 0 ;
29480 char * kwnames[] = {
29481 (char *) "self",(char *) "n", NULL
29482 };
29483
29484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29486 if (!SWIG_IsOK(res1)) {
29487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29488 }
29489 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29490 ecode2 = SWIG_AsVal_int(obj1, &val2);
29491 if (!SWIG_IsOK(ecode2)) {
29492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29493 }
29494 arg2 = static_cast< int >(val2);
29495 {
29496 PyThreadState* __tstate = wxPyBeginAllowThreads();
29497 result = wxTimeSpan___mul__(arg1,arg2);
29498 wxPyEndAllowThreads(__tstate);
29499 if (PyErr_Occurred()) SWIG_fail;
29500 }
29501 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29502 return resultobj;
29503 fail:
29504 return NULL;
29505 }
29506
29507
29508 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29509 PyObject *resultobj = 0;
29510 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29511 int arg2 ;
29512 wxTimeSpan result;
29513 void *argp1 = 0 ;
29514 int res1 = 0 ;
29515 int val2 ;
29516 int ecode2 = 0 ;
29517 PyObject * obj0 = 0 ;
29518 PyObject * obj1 = 0 ;
29519 char * kwnames[] = {
29520 (char *) "self",(char *) "n", NULL
29521 };
29522
29523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29525 if (!SWIG_IsOK(res1)) {
29526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29527 }
29528 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29529 ecode2 = SWIG_AsVal_int(obj1, &val2);
29530 if (!SWIG_IsOK(ecode2)) {
29531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29532 }
29533 arg2 = static_cast< int >(val2);
29534 {
29535 PyThreadState* __tstate = wxPyBeginAllowThreads();
29536 result = wxTimeSpan___rmul__(arg1,arg2);
29537 wxPyEndAllowThreads(__tstate);
29538 if (PyErr_Occurred()) SWIG_fail;
29539 }
29540 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29541 return resultobj;
29542 fail:
29543 return NULL;
29544 }
29545
29546
29547 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29548 PyObject *resultobj = 0;
29549 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29550 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29551 bool result;
29552 void *argp1 = 0 ;
29553 int res1 = 0 ;
29554 void *argp2 = 0 ;
29555 int res2 = 0 ;
29556 PyObject * obj0 = 0 ;
29557 PyObject * obj1 = 0 ;
29558 char * kwnames[] = {
29559 (char *) "self",(char *) "other", NULL
29560 };
29561
29562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29564 if (!SWIG_IsOK(res1)) {
29565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29566 }
29567 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29568 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29569 if (!SWIG_IsOK(res2)) {
29570 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29571 }
29572 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29573 {
29574 PyThreadState* __tstate = wxPyBeginAllowThreads();
29575 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29576 wxPyEndAllowThreads(__tstate);
29577 if (PyErr_Occurred()) SWIG_fail;
29578 }
29579 {
29580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29581 }
29582 return resultobj;
29583 fail:
29584 return NULL;
29585 }
29586
29587
29588 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29589 PyObject *resultobj = 0;
29590 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29591 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29592 bool result;
29593 void *argp1 = 0 ;
29594 int res1 = 0 ;
29595 void *argp2 = 0 ;
29596 int res2 = 0 ;
29597 PyObject * obj0 = 0 ;
29598 PyObject * obj1 = 0 ;
29599 char * kwnames[] = {
29600 (char *) "self",(char *) "other", NULL
29601 };
29602
29603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29605 if (!SWIG_IsOK(res1)) {
29606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29607 }
29608 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29609 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29610 if (!SWIG_IsOK(res2)) {
29611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29612 }
29613 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29614 {
29615 PyThreadState* __tstate = wxPyBeginAllowThreads();
29616 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29617 wxPyEndAllowThreads(__tstate);
29618 if (PyErr_Occurred()) SWIG_fail;
29619 }
29620 {
29621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29622 }
29623 return resultobj;
29624 fail:
29625 return NULL;
29626 }
29627
29628
29629 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29630 PyObject *resultobj = 0;
29631 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29632 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29633 bool result;
29634 void *argp1 = 0 ;
29635 int res1 = 0 ;
29636 void *argp2 = 0 ;
29637 int res2 = 0 ;
29638 PyObject * obj0 = 0 ;
29639 PyObject * obj1 = 0 ;
29640 char * kwnames[] = {
29641 (char *) "self",(char *) "other", NULL
29642 };
29643
29644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29646 if (!SWIG_IsOK(res1)) {
29647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29648 }
29649 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29650 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29651 if (!SWIG_IsOK(res2)) {
29652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29653 }
29654 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29655 {
29656 PyThreadState* __tstate = wxPyBeginAllowThreads();
29657 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29658 wxPyEndAllowThreads(__tstate);
29659 if (PyErr_Occurred()) SWIG_fail;
29660 }
29661 {
29662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29663 }
29664 return resultobj;
29665 fail:
29666 return NULL;
29667 }
29668
29669
29670 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29671 PyObject *resultobj = 0;
29672 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29673 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29674 bool result;
29675 void *argp1 = 0 ;
29676 int res1 = 0 ;
29677 void *argp2 = 0 ;
29678 int res2 = 0 ;
29679 PyObject * obj0 = 0 ;
29680 PyObject * obj1 = 0 ;
29681 char * kwnames[] = {
29682 (char *) "self",(char *) "other", NULL
29683 };
29684
29685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29687 if (!SWIG_IsOK(res1)) {
29688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29689 }
29690 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29691 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29692 if (!SWIG_IsOK(res2)) {
29693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29694 }
29695 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29696 {
29697 PyThreadState* __tstate = wxPyBeginAllowThreads();
29698 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29699 wxPyEndAllowThreads(__tstate);
29700 if (PyErr_Occurred()) SWIG_fail;
29701 }
29702 {
29703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29704 }
29705 return resultobj;
29706 fail:
29707 return NULL;
29708 }
29709
29710
29711 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29712 PyObject *resultobj = 0;
29713 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29714 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29715 bool result;
29716 void *argp1 = 0 ;
29717 int res1 = 0 ;
29718 void *argp2 = 0 ;
29719 int res2 = 0 ;
29720 PyObject * obj0 = 0 ;
29721 PyObject * obj1 = 0 ;
29722 char * kwnames[] = {
29723 (char *) "self",(char *) "other", NULL
29724 };
29725
29726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29728 if (!SWIG_IsOK(res1)) {
29729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29730 }
29731 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29732 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29733 if (!SWIG_IsOK(res2)) {
29734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29735 }
29736 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29737 {
29738 PyThreadState* __tstate = wxPyBeginAllowThreads();
29739 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29740 wxPyEndAllowThreads(__tstate);
29741 if (PyErr_Occurred()) SWIG_fail;
29742 }
29743 {
29744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29745 }
29746 return resultobj;
29747 fail:
29748 return NULL;
29749 }
29750
29751
29752 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29753 PyObject *resultobj = 0;
29754 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29755 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29756 bool result;
29757 void *argp1 = 0 ;
29758 int res1 = 0 ;
29759 void *argp2 = 0 ;
29760 int res2 = 0 ;
29761 PyObject * obj0 = 0 ;
29762 PyObject * obj1 = 0 ;
29763 char * kwnames[] = {
29764 (char *) "self",(char *) "other", NULL
29765 };
29766
29767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29769 if (!SWIG_IsOK(res1)) {
29770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29771 }
29772 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29773 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29774 if (!SWIG_IsOK(res2)) {
29775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29776 }
29777 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29778 {
29779 PyThreadState* __tstate = wxPyBeginAllowThreads();
29780 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29781 wxPyEndAllowThreads(__tstate);
29782 if (PyErr_Occurred()) SWIG_fail;
29783 }
29784 {
29785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29786 }
29787 return resultobj;
29788 fail:
29789 return NULL;
29790 }
29791
29792
29793 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29794 PyObject *resultobj = 0;
29795 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29796 bool result;
29797 void *argp1 = 0 ;
29798 int res1 = 0 ;
29799 PyObject *swig_obj[1] ;
29800
29801 if (!args) SWIG_fail;
29802 swig_obj[0] = args;
29803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29804 if (!SWIG_IsOK(res1)) {
29805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29806 }
29807 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29808 {
29809 PyThreadState* __tstate = wxPyBeginAllowThreads();
29810 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29811 wxPyEndAllowThreads(__tstate);
29812 if (PyErr_Occurred()) SWIG_fail;
29813 }
29814 {
29815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29816 }
29817 return resultobj;
29818 fail:
29819 return NULL;
29820 }
29821
29822
29823 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29824 PyObject *resultobj = 0;
29825 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29826 bool result;
29827 void *argp1 = 0 ;
29828 int res1 = 0 ;
29829 PyObject *swig_obj[1] ;
29830
29831 if (!args) SWIG_fail;
29832 swig_obj[0] = args;
29833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29834 if (!SWIG_IsOK(res1)) {
29835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29836 }
29837 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29838 {
29839 PyThreadState* __tstate = wxPyBeginAllowThreads();
29840 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29841 wxPyEndAllowThreads(__tstate);
29842 if (PyErr_Occurred()) SWIG_fail;
29843 }
29844 {
29845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29846 }
29847 return resultobj;
29848 fail:
29849 return NULL;
29850 }
29851
29852
29853 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29854 PyObject *resultobj = 0;
29855 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29856 bool result;
29857 void *argp1 = 0 ;
29858 int res1 = 0 ;
29859 PyObject *swig_obj[1] ;
29860
29861 if (!args) SWIG_fail;
29862 swig_obj[0] = args;
29863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29864 if (!SWIG_IsOK(res1)) {
29865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29866 }
29867 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29868 {
29869 PyThreadState* __tstate = wxPyBeginAllowThreads();
29870 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 {
29875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29876 }
29877 return resultobj;
29878 fail:
29879 return NULL;
29880 }
29881
29882
29883 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29884 PyObject *resultobj = 0;
29885 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29886 wxTimeSpan *arg2 = 0 ;
29887 bool result;
29888 void *argp1 = 0 ;
29889 int res1 = 0 ;
29890 void *argp2 = 0 ;
29891 int res2 = 0 ;
29892 PyObject * obj0 = 0 ;
29893 PyObject * obj1 = 0 ;
29894 char * kwnames[] = {
29895 (char *) "self",(char *) "ts", NULL
29896 };
29897
29898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29900 if (!SWIG_IsOK(res1)) {
29901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29902 }
29903 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29904 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29905 if (!SWIG_IsOK(res2)) {
29906 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29907 }
29908 if (!argp2) {
29909 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29910 }
29911 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29912 {
29913 PyThreadState* __tstate = wxPyBeginAllowThreads();
29914 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29915 wxPyEndAllowThreads(__tstate);
29916 if (PyErr_Occurred()) SWIG_fail;
29917 }
29918 {
29919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29920 }
29921 return resultobj;
29922 fail:
29923 return NULL;
29924 }
29925
29926
29927 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29928 PyObject *resultobj = 0;
29929 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29930 wxTimeSpan *arg2 = 0 ;
29931 bool result;
29932 void *argp1 = 0 ;
29933 int res1 = 0 ;
29934 void *argp2 = 0 ;
29935 int res2 = 0 ;
29936 PyObject * obj0 = 0 ;
29937 PyObject * obj1 = 0 ;
29938 char * kwnames[] = {
29939 (char *) "self",(char *) "ts", NULL
29940 };
29941
29942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29944 if (!SWIG_IsOK(res1)) {
29945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29946 }
29947 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29948 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29949 if (!SWIG_IsOK(res2)) {
29950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29951 }
29952 if (!argp2) {
29953 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29954 }
29955 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29956 {
29957 PyThreadState* __tstate = wxPyBeginAllowThreads();
29958 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29959 wxPyEndAllowThreads(__tstate);
29960 if (PyErr_Occurred()) SWIG_fail;
29961 }
29962 {
29963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29964 }
29965 return resultobj;
29966 fail:
29967 return NULL;
29968 }
29969
29970
29971 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29972 PyObject *resultobj = 0;
29973 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29974 wxTimeSpan *arg2 = 0 ;
29975 bool result;
29976 void *argp1 = 0 ;
29977 int res1 = 0 ;
29978 void *argp2 = 0 ;
29979 int res2 = 0 ;
29980 PyObject * obj0 = 0 ;
29981 PyObject * obj1 = 0 ;
29982 char * kwnames[] = {
29983 (char *) "self",(char *) "t", NULL
29984 };
29985
29986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29988 if (!SWIG_IsOK(res1)) {
29989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29990 }
29991 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29992 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29993 if (!SWIG_IsOK(res2)) {
29994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29995 }
29996 if (!argp2) {
29997 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29998 }
29999 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30000 {
30001 PyThreadState* __tstate = wxPyBeginAllowThreads();
30002 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
30003 wxPyEndAllowThreads(__tstate);
30004 if (PyErr_Occurred()) SWIG_fail;
30005 }
30006 {
30007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30008 }
30009 return resultobj;
30010 fail:
30011 return NULL;
30012 }
30013
30014
30015 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30016 PyObject *resultobj = 0;
30017 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30018 int result;
30019 void *argp1 = 0 ;
30020 int res1 = 0 ;
30021 PyObject *swig_obj[1] ;
30022
30023 if (!args) SWIG_fail;
30024 swig_obj[0] = args;
30025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30026 if (!SWIG_IsOK(res1)) {
30027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30028 }
30029 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30030 {
30031 PyThreadState* __tstate = wxPyBeginAllowThreads();
30032 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30033 wxPyEndAllowThreads(__tstate);
30034 if (PyErr_Occurred()) SWIG_fail;
30035 }
30036 resultobj = SWIG_From_int(static_cast< int >(result));
30037 return resultobj;
30038 fail:
30039 return NULL;
30040 }
30041
30042
30043 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30044 PyObject *resultobj = 0;
30045 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30046 int result;
30047 void *argp1 = 0 ;
30048 int res1 = 0 ;
30049 PyObject *swig_obj[1] ;
30050
30051 if (!args) SWIG_fail;
30052 swig_obj[0] = args;
30053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30054 if (!SWIG_IsOK(res1)) {
30055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30056 }
30057 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30058 {
30059 PyThreadState* __tstate = wxPyBeginAllowThreads();
30060 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30061 wxPyEndAllowThreads(__tstate);
30062 if (PyErr_Occurred()) SWIG_fail;
30063 }
30064 resultobj = SWIG_From_int(static_cast< int >(result));
30065 return resultobj;
30066 fail:
30067 return NULL;
30068 }
30069
30070
30071 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30072 PyObject *resultobj = 0;
30073 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30074 int result;
30075 void *argp1 = 0 ;
30076 int res1 = 0 ;
30077 PyObject *swig_obj[1] ;
30078
30079 if (!args) SWIG_fail;
30080 swig_obj[0] = args;
30081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30082 if (!SWIG_IsOK(res1)) {
30083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30084 }
30085 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30086 {
30087 PyThreadState* __tstate = wxPyBeginAllowThreads();
30088 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30089 wxPyEndAllowThreads(__tstate);
30090 if (PyErr_Occurred()) SWIG_fail;
30091 }
30092 resultobj = SWIG_From_int(static_cast< int >(result));
30093 return resultobj;
30094 fail:
30095 return NULL;
30096 }
30097
30098
30099 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30100 PyObject *resultobj = 0;
30101 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30102 int result;
30103 void *argp1 = 0 ;
30104 int res1 = 0 ;
30105 PyObject *swig_obj[1] ;
30106
30107 if (!args) SWIG_fail;
30108 swig_obj[0] = args;
30109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30110 if (!SWIG_IsOK(res1)) {
30111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30112 }
30113 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30114 {
30115 PyThreadState* __tstate = wxPyBeginAllowThreads();
30116 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30117 wxPyEndAllowThreads(__tstate);
30118 if (PyErr_Occurred()) SWIG_fail;
30119 }
30120 resultobj = SWIG_From_int(static_cast< int >(result));
30121 return resultobj;
30122 fail:
30123 return NULL;
30124 }
30125
30126
30127 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30128 PyObject *resultobj = 0;
30129 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30130 wxLongLong result;
30131 void *argp1 = 0 ;
30132 int res1 = 0 ;
30133 PyObject *swig_obj[1] ;
30134
30135 if (!args) SWIG_fail;
30136 swig_obj[0] = args;
30137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30138 if (!SWIG_IsOK(res1)) {
30139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30140 }
30141 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30142 {
30143 PyThreadState* __tstate = wxPyBeginAllowThreads();
30144 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30145 wxPyEndAllowThreads(__tstate);
30146 if (PyErr_Occurred()) SWIG_fail;
30147 }
30148 {
30149 PyObject *hi, *lo, *shifter, *shifted;
30150 hi = PyLong_FromLong( (&result)->GetHi() );
30151 lo = PyLong_FromLong( (&result)->GetLo() );
30152 shifter = PyLong_FromLong(32);
30153 shifted = PyNumber_Lshift(hi, shifter);
30154 resultobj = PyNumber_Or(shifted, lo);
30155 Py_DECREF(hi);
30156 Py_DECREF(lo);
30157 Py_DECREF(shifter);
30158 Py_DECREF(shifted);
30159 }
30160 return resultobj;
30161 fail:
30162 return NULL;
30163 }
30164
30165
30166 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30167 PyObject *resultobj = 0;
30168 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30169 wxLongLong result;
30170 void *argp1 = 0 ;
30171 int res1 = 0 ;
30172 PyObject *swig_obj[1] ;
30173
30174 if (!args) SWIG_fail;
30175 swig_obj[0] = args;
30176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30177 if (!SWIG_IsOK(res1)) {
30178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30179 }
30180 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30181 {
30182 PyThreadState* __tstate = wxPyBeginAllowThreads();
30183 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30184 wxPyEndAllowThreads(__tstate);
30185 if (PyErr_Occurred()) SWIG_fail;
30186 }
30187 {
30188 PyObject *hi, *lo, *shifter, *shifted;
30189 hi = PyLong_FromLong( (&result)->GetHi() );
30190 lo = PyLong_FromLong( (&result)->GetLo() );
30191 shifter = PyLong_FromLong(32);
30192 shifted = PyNumber_Lshift(hi, shifter);
30193 resultobj = PyNumber_Or(shifted, lo);
30194 Py_DECREF(hi);
30195 Py_DECREF(lo);
30196 Py_DECREF(shifter);
30197 Py_DECREF(shifted);
30198 }
30199 return resultobj;
30200 fail:
30201 return NULL;
30202 }
30203
30204
30205 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30206 PyObject *resultobj = 0;
30207 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30208 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30209 wxString *arg2 = (wxString *) &arg2_defvalue ;
30210 wxString result;
30211 void *argp1 = 0 ;
30212 int res1 = 0 ;
30213 bool temp2 = false ;
30214 PyObject * obj0 = 0 ;
30215 PyObject * obj1 = 0 ;
30216 char * kwnames[] = {
30217 (char *) "self",(char *) "format", NULL
30218 };
30219
30220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30222 if (!SWIG_IsOK(res1)) {
30223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30224 }
30225 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30226 if (obj1) {
30227 {
30228 arg2 = wxString_in_helper(obj1);
30229 if (arg2 == NULL) SWIG_fail;
30230 temp2 = true;
30231 }
30232 }
30233 {
30234 PyThreadState* __tstate = wxPyBeginAllowThreads();
30235 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30236 wxPyEndAllowThreads(__tstate);
30237 if (PyErr_Occurred()) SWIG_fail;
30238 }
30239 {
30240 #if wxUSE_UNICODE
30241 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30242 #else
30243 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30244 #endif
30245 }
30246 {
30247 if (temp2)
30248 delete arg2;
30249 }
30250 return resultobj;
30251 fail:
30252 {
30253 if (temp2)
30254 delete arg2;
30255 }
30256 return NULL;
30257 }
30258
30259
30260 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30261 PyObject *obj;
30262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30263 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30264 return SWIG_Py_Void();
30265 }
30266
30267 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30268 return SWIG_Python_InitShadowInstance(args);
30269 }
30270
30271 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30272 PyObject *resultobj = 0;
30273 int arg1 = (int) 0 ;
30274 int arg2 = (int) 0 ;
30275 int arg3 = (int) 0 ;
30276 int arg4 = (int) 0 ;
30277 wxDateSpan *result = 0 ;
30278 int val1 ;
30279 int ecode1 = 0 ;
30280 int val2 ;
30281 int ecode2 = 0 ;
30282 int val3 ;
30283 int ecode3 = 0 ;
30284 int val4 ;
30285 int ecode4 = 0 ;
30286 PyObject * obj0 = 0 ;
30287 PyObject * obj1 = 0 ;
30288 PyObject * obj2 = 0 ;
30289 PyObject * obj3 = 0 ;
30290 char * kwnames[] = {
30291 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30292 };
30293
30294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30295 if (obj0) {
30296 ecode1 = SWIG_AsVal_int(obj0, &val1);
30297 if (!SWIG_IsOK(ecode1)) {
30298 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30299 }
30300 arg1 = static_cast< int >(val1);
30301 }
30302 if (obj1) {
30303 ecode2 = SWIG_AsVal_int(obj1, &val2);
30304 if (!SWIG_IsOK(ecode2)) {
30305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30306 }
30307 arg2 = static_cast< int >(val2);
30308 }
30309 if (obj2) {
30310 ecode3 = SWIG_AsVal_int(obj2, &val3);
30311 if (!SWIG_IsOK(ecode3)) {
30312 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30313 }
30314 arg3 = static_cast< int >(val3);
30315 }
30316 if (obj3) {
30317 ecode4 = SWIG_AsVal_int(obj3, &val4);
30318 if (!SWIG_IsOK(ecode4)) {
30319 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30320 }
30321 arg4 = static_cast< int >(val4);
30322 }
30323 {
30324 PyThreadState* __tstate = wxPyBeginAllowThreads();
30325 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30326 wxPyEndAllowThreads(__tstate);
30327 if (PyErr_Occurred()) SWIG_fail;
30328 }
30329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30330 return resultobj;
30331 fail:
30332 return NULL;
30333 }
30334
30335
30336 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30337 PyObject *resultobj = 0;
30338 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30339 void *argp1 = 0 ;
30340 int res1 = 0 ;
30341 PyObject *swig_obj[1] ;
30342
30343 if (!args) SWIG_fail;
30344 swig_obj[0] = args;
30345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30346 if (!SWIG_IsOK(res1)) {
30347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30348 }
30349 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30350 {
30351 PyThreadState* __tstate = wxPyBeginAllowThreads();
30352 delete arg1;
30353
30354 wxPyEndAllowThreads(__tstate);
30355 if (PyErr_Occurred()) SWIG_fail;
30356 }
30357 resultobj = SWIG_Py_Void();
30358 return resultobj;
30359 fail:
30360 return NULL;
30361 }
30362
30363
30364 SWIGINTERN PyObject *_wrap_DateSpan_Days(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 *) "days", NULL
30373 };
30374
30375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",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_Days" "', expected argument " "1"" of type '" "int""'");
30379 }
30380 arg1 = static_cast< int >(val1);
30381 {
30382 PyThreadState* __tstate = wxPyBeginAllowThreads();
30383 result = wxDateSpan::Days(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_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30395 PyObject *resultobj = 0;
30396 wxDateSpan result;
30397
30398 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30399 {
30400 PyThreadState* __tstate = wxPyBeginAllowThreads();
30401 result = wxDateSpan::Day();
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_Weeks(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 *) "weeks", NULL
30421 };
30422
30423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",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_Weeks" "', expected argument " "1"" of type '" "int""'");
30427 }
30428 arg1 = static_cast< int >(val1);
30429 {
30430 PyThreadState* __tstate = wxPyBeginAllowThreads();
30431 result = wxDateSpan::Weeks(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_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30443 PyObject *resultobj = 0;
30444 wxDateSpan result;
30445
30446 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30447 {
30448 PyThreadState* __tstate = wxPyBeginAllowThreads();
30449 result = wxDateSpan::Week();
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_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30461 PyObject *resultobj = 0;
30462 int arg1 ;
30463 wxDateSpan result;
30464 int val1 ;
30465 int ecode1 = 0 ;
30466 PyObject * obj0 = 0 ;
30467 char * kwnames[] = {
30468 (char *) "mon", NULL
30469 };
30470
30471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30472 ecode1 = SWIG_AsVal_int(obj0, &val1);
30473 if (!SWIG_IsOK(ecode1)) {
30474 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30475 }
30476 arg1 = static_cast< int >(val1);
30477 {
30478 PyThreadState* __tstate = wxPyBeginAllowThreads();
30479 result = wxDateSpan::Months(arg1);
30480 wxPyEndAllowThreads(__tstate);
30481 if (PyErr_Occurred()) SWIG_fail;
30482 }
30483 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30484 return resultobj;
30485 fail:
30486 return NULL;
30487 }
30488
30489
30490 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30491 PyObject *resultobj = 0;
30492 wxDateSpan result;
30493
30494 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30495 {
30496 PyThreadState* __tstate = wxPyBeginAllowThreads();
30497 result = wxDateSpan::Month();
30498 wxPyEndAllowThreads(__tstate);
30499 if (PyErr_Occurred()) SWIG_fail;
30500 }
30501 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30502 return resultobj;
30503 fail:
30504 return NULL;
30505 }
30506
30507
30508 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30509 PyObject *resultobj = 0;
30510 int arg1 ;
30511 wxDateSpan result;
30512 int val1 ;
30513 int ecode1 = 0 ;
30514 PyObject * obj0 = 0 ;
30515 char * kwnames[] = {
30516 (char *) "years", NULL
30517 };
30518
30519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30520 ecode1 = SWIG_AsVal_int(obj0, &val1);
30521 if (!SWIG_IsOK(ecode1)) {
30522 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30523 }
30524 arg1 = static_cast< int >(val1);
30525 {
30526 PyThreadState* __tstate = wxPyBeginAllowThreads();
30527 result = wxDateSpan::Years(arg1);
30528 wxPyEndAllowThreads(__tstate);
30529 if (PyErr_Occurred()) SWIG_fail;
30530 }
30531 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30532 return resultobj;
30533 fail:
30534 return NULL;
30535 }
30536
30537
30538 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30539 PyObject *resultobj = 0;
30540 wxDateSpan result;
30541
30542 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30543 {
30544 PyThreadState* __tstate = wxPyBeginAllowThreads();
30545 result = wxDateSpan::Year();
30546 wxPyEndAllowThreads(__tstate);
30547 if (PyErr_Occurred()) SWIG_fail;
30548 }
30549 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30550 return resultobj;
30551 fail:
30552 return NULL;
30553 }
30554
30555
30556 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30557 PyObject *resultobj = 0;
30558 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30559 int arg2 ;
30560 wxDateSpan *result = 0 ;
30561 void *argp1 = 0 ;
30562 int res1 = 0 ;
30563 int val2 ;
30564 int ecode2 = 0 ;
30565 PyObject * obj0 = 0 ;
30566 PyObject * obj1 = 0 ;
30567 char * kwnames[] = {
30568 (char *) "self",(char *) "n", NULL
30569 };
30570
30571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30573 if (!SWIG_IsOK(res1)) {
30574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30575 }
30576 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30577 ecode2 = SWIG_AsVal_int(obj1, &val2);
30578 if (!SWIG_IsOK(ecode2)) {
30579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30580 }
30581 arg2 = static_cast< int >(val2);
30582 {
30583 PyThreadState* __tstate = wxPyBeginAllowThreads();
30584 {
30585 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30586 result = (wxDateSpan *) &_result_ref;
30587 }
30588 wxPyEndAllowThreads(__tstate);
30589 if (PyErr_Occurred()) SWIG_fail;
30590 }
30591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30592 return resultobj;
30593 fail:
30594 return NULL;
30595 }
30596
30597
30598 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30599 PyObject *resultobj = 0;
30600 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30601 int arg2 ;
30602 wxDateSpan *result = 0 ;
30603 void *argp1 = 0 ;
30604 int res1 = 0 ;
30605 int val2 ;
30606 int ecode2 = 0 ;
30607 PyObject * obj0 = 0 ;
30608 PyObject * obj1 = 0 ;
30609 char * kwnames[] = {
30610 (char *) "self",(char *) "n", NULL
30611 };
30612
30613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30615 if (!SWIG_IsOK(res1)) {
30616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30617 }
30618 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30619 ecode2 = SWIG_AsVal_int(obj1, &val2);
30620 if (!SWIG_IsOK(ecode2)) {
30621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30622 }
30623 arg2 = static_cast< int >(val2);
30624 {
30625 PyThreadState* __tstate = wxPyBeginAllowThreads();
30626 {
30627 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30628 result = (wxDateSpan *) &_result_ref;
30629 }
30630 wxPyEndAllowThreads(__tstate);
30631 if (PyErr_Occurred()) SWIG_fail;
30632 }
30633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30634 return resultobj;
30635 fail:
30636 return NULL;
30637 }
30638
30639
30640 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30641 PyObject *resultobj = 0;
30642 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30643 int arg2 ;
30644 wxDateSpan *result = 0 ;
30645 void *argp1 = 0 ;
30646 int res1 = 0 ;
30647 int val2 ;
30648 int ecode2 = 0 ;
30649 PyObject * obj0 = 0 ;
30650 PyObject * obj1 = 0 ;
30651 char * kwnames[] = {
30652 (char *) "self",(char *) "n", NULL
30653 };
30654
30655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30657 if (!SWIG_IsOK(res1)) {
30658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30659 }
30660 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30661 ecode2 = SWIG_AsVal_int(obj1, &val2);
30662 if (!SWIG_IsOK(ecode2)) {
30663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30664 }
30665 arg2 = static_cast< int >(val2);
30666 {
30667 PyThreadState* __tstate = wxPyBeginAllowThreads();
30668 {
30669 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30670 result = (wxDateSpan *) &_result_ref;
30671 }
30672 wxPyEndAllowThreads(__tstate);
30673 if (PyErr_Occurred()) SWIG_fail;
30674 }
30675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30676 return resultobj;
30677 fail:
30678 return NULL;
30679 }
30680
30681
30682 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30683 PyObject *resultobj = 0;
30684 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30685 int arg2 ;
30686 wxDateSpan *result = 0 ;
30687 void *argp1 = 0 ;
30688 int res1 = 0 ;
30689 int val2 ;
30690 int ecode2 = 0 ;
30691 PyObject * obj0 = 0 ;
30692 PyObject * obj1 = 0 ;
30693 char * kwnames[] = {
30694 (char *) "self",(char *) "n", NULL
30695 };
30696
30697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30699 if (!SWIG_IsOK(res1)) {
30700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30701 }
30702 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30703 ecode2 = SWIG_AsVal_int(obj1, &val2);
30704 if (!SWIG_IsOK(ecode2)) {
30705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30706 }
30707 arg2 = static_cast< int >(val2);
30708 {
30709 PyThreadState* __tstate = wxPyBeginAllowThreads();
30710 {
30711 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30712 result = (wxDateSpan *) &_result_ref;
30713 }
30714 wxPyEndAllowThreads(__tstate);
30715 if (PyErr_Occurred()) SWIG_fail;
30716 }
30717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30718 return resultobj;
30719 fail:
30720 return NULL;
30721 }
30722
30723
30724 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30725 PyObject *resultobj = 0;
30726 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30727 int result;
30728 void *argp1 = 0 ;
30729 int res1 = 0 ;
30730 PyObject *swig_obj[1] ;
30731
30732 if (!args) SWIG_fail;
30733 swig_obj[0] = args;
30734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30735 if (!SWIG_IsOK(res1)) {
30736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30737 }
30738 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30739 {
30740 PyThreadState* __tstate = wxPyBeginAllowThreads();
30741 result = (int)((wxDateSpan const *)arg1)->GetYears();
30742 wxPyEndAllowThreads(__tstate);
30743 if (PyErr_Occurred()) SWIG_fail;
30744 }
30745 resultobj = SWIG_From_int(static_cast< int >(result));
30746 return resultobj;
30747 fail:
30748 return NULL;
30749 }
30750
30751
30752 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30753 PyObject *resultobj = 0;
30754 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30755 int result;
30756 void *argp1 = 0 ;
30757 int res1 = 0 ;
30758 PyObject *swig_obj[1] ;
30759
30760 if (!args) SWIG_fail;
30761 swig_obj[0] = args;
30762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30763 if (!SWIG_IsOK(res1)) {
30764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30765 }
30766 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30767 {
30768 PyThreadState* __tstate = wxPyBeginAllowThreads();
30769 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30770 wxPyEndAllowThreads(__tstate);
30771 if (PyErr_Occurred()) SWIG_fail;
30772 }
30773 resultobj = SWIG_From_int(static_cast< int >(result));
30774 return resultobj;
30775 fail:
30776 return NULL;
30777 }
30778
30779
30780 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30781 PyObject *resultobj = 0;
30782 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30783 int result;
30784 void *argp1 = 0 ;
30785 int res1 = 0 ;
30786 PyObject *swig_obj[1] ;
30787
30788 if (!args) SWIG_fail;
30789 swig_obj[0] = args;
30790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30791 if (!SWIG_IsOK(res1)) {
30792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30793 }
30794 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30795 {
30796 PyThreadState* __tstate = wxPyBeginAllowThreads();
30797 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30798 wxPyEndAllowThreads(__tstate);
30799 if (PyErr_Occurred()) SWIG_fail;
30800 }
30801 resultobj = SWIG_From_int(static_cast< int >(result));
30802 return resultobj;
30803 fail:
30804 return NULL;
30805 }
30806
30807
30808 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30809 PyObject *resultobj = 0;
30810 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30811 int result;
30812 void *argp1 = 0 ;
30813 int res1 = 0 ;
30814 PyObject *swig_obj[1] ;
30815
30816 if (!args) SWIG_fail;
30817 swig_obj[0] = args;
30818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30819 if (!SWIG_IsOK(res1)) {
30820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30821 }
30822 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30823 {
30824 PyThreadState* __tstate = wxPyBeginAllowThreads();
30825 result = (int)((wxDateSpan const *)arg1)->GetDays();
30826 wxPyEndAllowThreads(__tstate);
30827 if (PyErr_Occurred()) SWIG_fail;
30828 }
30829 resultobj = SWIG_From_int(static_cast< int >(result));
30830 return resultobj;
30831 fail:
30832 return NULL;
30833 }
30834
30835
30836 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30837 PyObject *resultobj = 0;
30838 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30839 int result;
30840 void *argp1 = 0 ;
30841 int res1 = 0 ;
30842 PyObject *swig_obj[1] ;
30843
30844 if (!args) SWIG_fail;
30845 swig_obj[0] = args;
30846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30847 if (!SWIG_IsOK(res1)) {
30848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30849 }
30850 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30851 {
30852 PyThreadState* __tstate = wxPyBeginAllowThreads();
30853 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30854 wxPyEndAllowThreads(__tstate);
30855 if (PyErr_Occurred()) SWIG_fail;
30856 }
30857 resultobj = SWIG_From_int(static_cast< int >(result));
30858 return resultobj;
30859 fail:
30860 return NULL;
30861 }
30862
30863
30864 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30865 PyObject *resultobj = 0;
30866 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30867 wxDateSpan *arg2 = 0 ;
30868 wxDateSpan *result = 0 ;
30869 void *argp1 = 0 ;
30870 int res1 = 0 ;
30871 void *argp2 = 0 ;
30872 int res2 = 0 ;
30873 PyObject * obj0 = 0 ;
30874 PyObject * obj1 = 0 ;
30875 char * kwnames[] = {
30876 (char *) "self",(char *) "other", NULL
30877 };
30878
30879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30881 if (!SWIG_IsOK(res1)) {
30882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30883 }
30884 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30885 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30886 if (!SWIG_IsOK(res2)) {
30887 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30888 }
30889 if (!argp2) {
30890 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30891 }
30892 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30893 {
30894 PyThreadState* __tstate = wxPyBeginAllowThreads();
30895 {
30896 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30897 result = (wxDateSpan *) &_result_ref;
30898 }
30899 wxPyEndAllowThreads(__tstate);
30900 if (PyErr_Occurred()) SWIG_fail;
30901 }
30902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30903 return resultobj;
30904 fail:
30905 return NULL;
30906 }
30907
30908
30909 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30910 PyObject *resultobj = 0;
30911 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30912 wxDateSpan *arg2 = 0 ;
30913 wxDateSpan *result = 0 ;
30914 void *argp1 = 0 ;
30915 int res1 = 0 ;
30916 void *argp2 = 0 ;
30917 int res2 = 0 ;
30918 PyObject * obj0 = 0 ;
30919 PyObject * obj1 = 0 ;
30920 char * kwnames[] = {
30921 (char *) "self",(char *) "other", NULL
30922 };
30923
30924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30926 if (!SWIG_IsOK(res1)) {
30927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30928 }
30929 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30930 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30931 if (!SWIG_IsOK(res2)) {
30932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30933 }
30934 if (!argp2) {
30935 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30936 }
30937 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30938 {
30939 PyThreadState* __tstate = wxPyBeginAllowThreads();
30940 {
30941 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30942 result = (wxDateSpan *) &_result_ref;
30943 }
30944 wxPyEndAllowThreads(__tstate);
30945 if (PyErr_Occurred()) SWIG_fail;
30946 }
30947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30948 return resultobj;
30949 fail:
30950 return NULL;
30951 }
30952
30953
30954 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30955 PyObject *resultobj = 0;
30956 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30957 wxDateSpan *result = 0 ;
30958 void *argp1 = 0 ;
30959 int res1 = 0 ;
30960 PyObject *swig_obj[1] ;
30961
30962 if (!args) SWIG_fail;
30963 swig_obj[0] = args;
30964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30965 if (!SWIG_IsOK(res1)) {
30966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30967 }
30968 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30969 {
30970 PyThreadState* __tstate = wxPyBeginAllowThreads();
30971 {
30972 wxDateSpan &_result_ref = (arg1)->Neg();
30973 result = (wxDateSpan *) &_result_ref;
30974 }
30975 wxPyEndAllowThreads(__tstate);
30976 if (PyErr_Occurred()) SWIG_fail;
30977 }
30978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30979 return resultobj;
30980 fail:
30981 return NULL;
30982 }
30983
30984
30985 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30986 PyObject *resultobj = 0;
30987 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30988 int arg2 ;
30989 wxDateSpan *result = 0 ;
30990 void *argp1 = 0 ;
30991 int res1 = 0 ;
30992 int val2 ;
30993 int ecode2 = 0 ;
30994 PyObject * obj0 = 0 ;
30995 PyObject * obj1 = 0 ;
30996 char * kwnames[] = {
30997 (char *) "self",(char *) "factor", NULL
30998 };
30999
31000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
31001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31002 if (!SWIG_IsOK(res1)) {
31003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31004 }
31005 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31006 ecode2 = SWIG_AsVal_int(obj1, &val2);
31007 if (!SWIG_IsOK(ecode2)) {
31008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
31009 }
31010 arg2 = static_cast< int >(val2);
31011 {
31012 PyThreadState* __tstate = wxPyBeginAllowThreads();
31013 {
31014 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
31015 result = (wxDateSpan *) &_result_ref;
31016 }
31017 wxPyEndAllowThreads(__tstate);
31018 if (PyErr_Occurred()) SWIG_fail;
31019 }
31020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31021 return resultobj;
31022 fail:
31023 return NULL;
31024 }
31025
31026
31027 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31028 PyObject *resultobj = 0;
31029 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31030 wxDateSpan *arg2 = 0 ;
31031 wxDateSpan *result = 0 ;
31032 void *argp1 = 0 ;
31033 int res1 = 0 ;
31034 void *argp2 = 0 ;
31035 int res2 = 0 ;
31036 PyObject * obj0 = 0 ;
31037 PyObject * obj1 = 0 ;
31038 char * kwnames[] = {
31039 (char *) "self",(char *) "other", NULL
31040 };
31041
31042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31044 if (!SWIG_IsOK(res1)) {
31045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31046 }
31047 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31048 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31049 if (!SWIG_IsOK(res2)) {
31050 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31051 }
31052 if (!argp2) {
31053 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31054 }
31055 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31056 {
31057 PyThreadState* __tstate = wxPyBeginAllowThreads();
31058 {
31059 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31060 result = (wxDateSpan *) &_result_ref;
31061 }
31062 wxPyEndAllowThreads(__tstate);
31063 if (PyErr_Occurred()) SWIG_fail;
31064 }
31065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31066 return resultobj;
31067 fail:
31068 return NULL;
31069 }
31070
31071
31072 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31073 PyObject *resultobj = 0;
31074 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31075 wxDateSpan *arg2 = 0 ;
31076 wxDateSpan *result = 0 ;
31077 void *argp1 = 0 ;
31078 int res1 = 0 ;
31079 void *argp2 = 0 ;
31080 int res2 = 0 ;
31081 PyObject * obj0 = 0 ;
31082 PyObject * obj1 = 0 ;
31083 char * kwnames[] = {
31084 (char *) "self",(char *) "other", NULL
31085 };
31086
31087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31089 if (!SWIG_IsOK(res1)) {
31090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31091 }
31092 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31093 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31094 if (!SWIG_IsOK(res2)) {
31095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31096 }
31097 if (!argp2) {
31098 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31099 }
31100 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31101 {
31102 PyThreadState* __tstate = wxPyBeginAllowThreads();
31103 {
31104 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31105 result = (wxDateSpan *) &_result_ref;
31106 }
31107 wxPyEndAllowThreads(__tstate);
31108 if (PyErr_Occurred()) SWIG_fail;
31109 }
31110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31111 return resultobj;
31112 fail:
31113 return NULL;
31114 }
31115
31116
31117 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31118 PyObject *resultobj = 0;
31119 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31120 wxDateSpan *result = 0 ;
31121 void *argp1 = 0 ;
31122 int res1 = 0 ;
31123 PyObject *swig_obj[1] ;
31124
31125 if (!args) SWIG_fail;
31126 swig_obj[0] = args;
31127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31128 if (!SWIG_IsOK(res1)) {
31129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31130 }
31131 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31132 {
31133 PyThreadState* __tstate = wxPyBeginAllowThreads();
31134 {
31135 wxDateSpan &_result_ref = (arg1)->operator -();
31136 result = (wxDateSpan *) &_result_ref;
31137 }
31138 wxPyEndAllowThreads(__tstate);
31139 if (PyErr_Occurred()) SWIG_fail;
31140 }
31141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31142 return resultobj;
31143 fail:
31144 return NULL;
31145 }
31146
31147
31148 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31149 PyObject *resultobj = 0;
31150 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31151 int arg2 ;
31152 wxDateSpan *result = 0 ;
31153 void *argp1 = 0 ;
31154 int res1 = 0 ;
31155 int val2 ;
31156 int ecode2 = 0 ;
31157 PyObject * obj0 = 0 ;
31158 PyObject * obj1 = 0 ;
31159 char * kwnames[] = {
31160 (char *) "self",(char *) "factor", NULL
31161 };
31162
31163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31165 if (!SWIG_IsOK(res1)) {
31166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31167 }
31168 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31169 ecode2 = SWIG_AsVal_int(obj1, &val2);
31170 if (!SWIG_IsOK(ecode2)) {
31171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31172 }
31173 arg2 = static_cast< int >(val2);
31174 {
31175 PyThreadState* __tstate = wxPyBeginAllowThreads();
31176 {
31177 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31178 result = (wxDateSpan *) &_result_ref;
31179 }
31180 wxPyEndAllowThreads(__tstate);
31181 if (PyErr_Occurred()) SWIG_fail;
31182 }
31183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31184 return resultobj;
31185 fail:
31186 return NULL;
31187 }
31188
31189
31190 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31191 PyObject *resultobj = 0;
31192 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31193 wxDateSpan *arg2 = 0 ;
31194 wxDateSpan result;
31195 void *argp1 = 0 ;
31196 int res1 = 0 ;
31197 void *argp2 = 0 ;
31198 int res2 = 0 ;
31199 PyObject * obj0 = 0 ;
31200 PyObject * obj1 = 0 ;
31201 char * kwnames[] = {
31202 (char *) "self",(char *) "other", NULL
31203 };
31204
31205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31207 if (!SWIG_IsOK(res1)) {
31208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31209 }
31210 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31211 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31212 if (!SWIG_IsOK(res2)) {
31213 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31214 }
31215 if (!argp2) {
31216 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31217 }
31218 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31219 {
31220 PyThreadState* __tstate = wxPyBeginAllowThreads();
31221 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31222 wxPyEndAllowThreads(__tstate);
31223 if (PyErr_Occurred()) SWIG_fail;
31224 }
31225 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31226 return resultobj;
31227 fail:
31228 return NULL;
31229 }
31230
31231
31232 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31233 PyObject *resultobj = 0;
31234 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31235 wxDateSpan *arg2 = 0 ;
31236 wxDateSpan result;
31237 void *argp1 = 0 ;
31238 int res1 = 0 ;
31239 void *argp2 = 0 ;
31240 int res2 = 0 ;
31241 PyObject * obj0 = 0 ;
31242 PyObject * obj1 = 0 ;
31243 char * kwnames[] = {
31244 (char *) "self",(char *) "other", NULL
31245 };
31246
31247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31249 if (!SWIG_IsOK(res1)) {
31250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31251 }
31252 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31253 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31254 if (!SWIG_IsOK(res2)) {
31255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31256 }
31257 if (!argp2) {
31258 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31259 }
31260 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31261 {
31262 PyThreadState* __tstate = wxPyBeginAllowThreads();
31263 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31264 wxPyEndAllowThreads(__tstate);
31265 if (PyErr_Occurred()) SWIG_fail;
31266 }
31267 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31268 return resultobj;
31269 fail:
31270 return NULL;
31271 }
31272
31273
31274 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31275 PyObject *resultobj = 0;
31276 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31277 int arg2 ;
31278 wxDateSpan result;
31279 void *argp1 = 0 ;
31280 int res1 = 0 ;
31281 int val2 ;
31282 int ecode2 = 0 ;
31283 PyObject * obj0 = 0 ;
31284 PyObject * obj1 = 0 ;
31285 char * kwnames[] = {
31286 (char *) "self",(char *) "n", NULL
31287 };
31288
31289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31291 if (!SWIG_IsOK(res1)) {
31292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31293 }
31294 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31295 ecode2 = SWIG_AsVal_int(obj1, &val2);
31296 if (!SWIG_IsOK(ecode2)) {
31297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31298 }
31299 arg2 = static_cast< int >(val2);
31300 {
31301 PyThreadState* __tstate = wxPyBeginAllowThreads();
31302 result = wxDateSpan___mul__(arg1,arg2);
31303 wxPyEndAllowThreads(__tstate);
31304 if (PyErr_Occurred()) SWIG_fail;
31305 }
31306 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31307 return resultobj;
31308 fail:
31309 return NULL;
31310 }
31311
31312
31313 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31314 PyObject *resultobj = 0;
31315 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31316 int arg2 ;
31317 wxDateSpan result;
31318 void *argp1 = 0 ;
31319 int res1 = 0 ;
31320 int val2 ;
31321 int ecode2 = 0 ;
31322 PyObject * obj0 = 0 ;
31323 PyObject * obj1 = 0 ;
31324 char * kwnames[] = {
31325 (char *) "self",(char *) "n", NULL
31326 };
31327
31328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31330 if (!SWIG_IsOK(res1)) {
31331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31332 }
31333 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31334 ecode2 = SWIG_AsVal_int(obj1, &val2);
31335 if (!SWIG_IsOK(ecode2)) {
31336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31337 }
31338 arg2 = static_cast< int >(val2);
31339 {
31340 PyThreadState* __tstate = wxPyBeginAllowThreads();
31341 result = wxDateSpan___rmul__(arg1,arg2);
31342 wxPyEndAllowThreads(__tstate);
31343 if (PyErr_Occurred()) SWIG_fail;
31344 }
31345 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31346 return resultobj;
31347 fail:
31348 return NULL;
31349 }
31350
31351
31352 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31353 PyObject *resultobj = 0;
31354 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31355 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31356 bool result;
31357 void *argp1 = 0 ;
31358 int res1 = 0 ;
31359 void *argp2 = 0 ;
31360 int res2 = 0 ;
31361 PyObject * obj0 = 0 ;
31362 PyObject * obj1 = 0 ;
31363 char * kwnames[] = {
31364 (char *) "self",(char *) "other", NULL
31365 };
31366
31367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31369 if (!SWIG_IsOK(res1)) {
31370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31371 }
31372 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31373 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31374 if (!SWIG_IsOK(res2)) {
31375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31376 }
31377 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31378 {
31379 PyThreadState* __tstate = wxPyBeginAllowThreads();
31380 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31381 wxPyEndAllowThreads(__tstate);
31382 if (PyErr_Occurred()) SWIG_fail;
31383 }
31384 {
31385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31386 }
31387 return resultobj;
31388 fail:
31389 return NULL;
31390 }
31391
31392
31393 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31394 PyObject *resultobj = 0;
31395 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31396 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31397 bool result;
31398 void *argp1 = 0 ;
31399 int res1 = 0 ;
31400 void *argp2 = 0 ;
31401 int res2 = 0 ;
31402 PyObject * obj0 = 0 ;
31403 PyObject * obj1 = 0 ;
31404 char * kwnames[] = {
31405 (char *) "self",(char *) "other", NULL
31406 };
31407
31408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31410 if (!SWIG_IsOK(res1)) {
31411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31412 }
31413 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31414 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31415 if (!SWIG_IsOK(res2)) {
31416 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31417 }
31418 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31419 {
31420 PyThreadState* __tstate = wxPyBeginAllowThreads();
31421 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31422 wxPyEndAllowThreads(__tstate);
31423 if (PyErr_Occurred()) SWIG_fail;
31424 }
31425 {
31426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31427 }
31428 return resultobj;
31429 fail:
31430 return NULL;
31431 }
31432
31433
31434 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31435 PyObject *obj;
31436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31437 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31438 return SWIG_Py_Void();
31439 }
31440
31441 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31442 return SWIG_Python_InitShadowInstance(args);
31443 }
31444
31445 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31446 PyObject *resultobj = 0;
31447 long result;
31448
31449 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31450 {
31451 PyThreadState* __tstate = wxPyBeginAllowThreads();
31452 result = (long)wxGetLocalTime();
31453 wxPyEndAllowThreads(__tstate);
31454 if (PyErr_Occurred()) SWIG_fail;
31455 }
31456 resultobj = SWIG_From_long(static_cast< long >(result));
31457 return resultobj;
31458 fail:
31459 return NULL;
31460 }
31461
31462
31463 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31464 PyObject *resultobj = 0;
31465 long result;
31466
31467 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31468 {
31469 PyThreadState* __tstate = wxPyBeginAllowThreads();
31470 result = (long)wxGetUTCTime();
31471 wxPyEndAllowThreads(__tstate);
31472 if (PyErr_Occurred()) SWIG_fail;
31473 }
31474 resultobj = SWIG_From_long(static_cast< long >(result));
31475 return resultobj;
31476 fail:
31477 return NULL;
31478 }
31479
31480
31481 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31482 PyObject *resultobj = 0;
31483 long result;
31484
31485 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31486 {
31487 PyThreadState* __tstate = wxPyBeginAllowThreads();
31488 result = (long)wxGetCurrentTime();
31489 wxPyEndAllowThreads(__tstate);
31490 if (PyErr_Occurred()) SWIG_fail;
31491 }
31492 resultobj = SWIG_From_long(static_cast< long >(result));
31493 return resultobj;
31494 fail:
31495 return NULL;
31496 }
31497
31498
31499 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31500 PyObject *resultobj = 0;
31501 wxLongLong result;
31502
31503 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31504 {
31505 PyThreadState* __tstate = wxPyBeginAllowThreads();
31506 result = wxGetLocalTimeMillis();
31507 wxPyEndAllowThreads(__tstate);
31508 if (PyErr_Occurred()) SWIG_fail;
31509 }
31510 {
31511 PyObject *hi, *lo, *shifter, *shifted;
31512 hi = PyLong_FromLong( (&result)->GetHi() );
31513 lo = PyLong_FromLong( (&result)->GetLo() );
31514 shifter = PyLong_FromLong(32);
31515 shifted = PyNumber_Lshift(hi, shifter);
31516 resultobj = PyNumber_Or(shifted, lo);
31517 Py_DECREF(hi);
31518 Py_DECREF(lo);
31519 Py_DECREF(shifter);
31520 Py_DECREF(shifted);
31521 }
31522 return resultobj;
31523 fail:
31524 return NULL;
31525 }
31526
31527
31528 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31529 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31530 return 1;
31531 }
31532
31533
31534 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31535 PyObject *pyobj = 0;
31536
31537 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31538 return pyobj;
31539 }
31540
31541
31542 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31543 PyObject *resultobj = 0;
31544 wxDataFormatId arg1 ;
31545 wxDataFormat *result = 0 ;
31546 int val1 ;
31547 int ecode1 = 0 ;
31548 PyObject * obj0 = 0 ;
31549 char * kwnames[] = {
31550 (char *) "type", NULL
31551 };
31552
31553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31554 ecode1 = SWIG_AsVal_int(obj0, &val1);
31555 if (!SWIG_IsOK(ecode1)) {
31556 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31557 }
31558 arg1 = static_cast< wxDataFormatId >(val1);
31559 {
31560 PyThreadState* __tstate = wxPyBeginAllowThreads();
31561 result = (wxDataFormat *)new wxDataFormat(arg1);
31562 wxPyEndAllowThreads(__tstate);
31563 if (PyErr_Occurred()) SWIG_fail;
31564 }
31565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31566 return resultobj;
31567 fail:
31568 return NULL;
31569 }
31570
31571
31572 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31573 PyObject *resultobj = 0;
31574 wxString *arg1 = 0 ;
31575 wxDataFormat *result = 0 ;
31576 bool temp1 = false ;
31577 PyObject * obj0 = 0 ;
31578 char * kwnames[] = {
31579 (char *) "format", NULL
31580 };
31581
31582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31583 {
31584 arg1 = wxString_in_helper(obj0);
31585 if (arg1 == NULL) SWIG_fail;
31586 temp1 = true;
31587 }
31588 {
31589 PyThreadState* __tstate = wxPyBeginAllowThreads();
31590 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31591 wxPyEndAllowThreads(__tstate);
31592 if (PyErr_Occurred()) SWIG_fail;
31593 }
31594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31595 {
31596 if (temp1)
31597 delete arg1;
31598 }
31599 return resultobj;
31600 fail:
31601 {
31602 if (temp1)
31603 delete arg1;
31604 }
31605 return NULL;
31606 }
31607
31608
31609 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31610 PyObject *resultobj = 0;
31611 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31612 void *argp1 = 0 ;
31613 int res1 = 0 ;
31614 PyObject *swig_obj[1] ;
31615
31616 if (!args) SWIG_fail;
31617 swig_obj[0] = args;
31618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31619 if (!SWIG_IsOK(res1)) {
31620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31621 }
31622 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31623 {
31624 PyThreadState* __tstate = wxPyBeginAllowThreads();
31625 delete arg1;
31626
31627 wxPyEndAllowThreads(__tstate);
31628 if (PyErr_Occurred()) SWIG_fail;
31629 }
31630 resultobj = SWIG_Py_Void();
31631 return resultobj;
31632 fail:
31633 return NULL;
31634 }
31635
31636
31637 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31638 PyObject *resultobj = 0;
31639 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31640 wxDataFormatId arg2 ;
31641 bool result;
31642 void *argp1 = 0 ;
31643 int res1 = 0 ;
31644 int val2 ;
31645 int ecode2 = 0 ;
31646
31647 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31649 if (!SWIG_IsOK(res1)) {
31650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31651 }
31652 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31653 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31654 if (!SWIG_IsOK(ecode2)) {
31655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31656 }
31657 arg2 = static_cast< wxDataFormatId >(val2);
31658 {
31659 PyThreadState* __tstate = wxPyBeginAllowThreads();
31660 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31661 wxPyEndAllowThreads(__tstate);
31662 if (PyErr_Occurred()) SWIG_fail;
31663 }
31664 {
31665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31666 }
31667 return resultobj;
31668 fail:
31669 return NULL;
31670 }
31671
31672
31673 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31674 PyObject *resultobj = 0;
31675 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31676 wxDataFormatId arg2 ;
31677 bool result;
31678 void *argp1 = 0 ;
31679 int res1 = 0 ;
31680 int val2 ;
31681 int ecode2 = 0 ;
31682
31683 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31685 if (!SWIG_IsOK(res1)) {
31686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31687 }
31688 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31689 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31690 if (!SWIG_IsOK(ecode2)) {
31691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31692 }
31693 arg2 = static_cast< wxDataFormatId >(val2);
31694 {
31695 PyThreadState* __tstate = wxPyBeginAllowThreads();
31696 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31697 wxPyEndAllowThreads(__tstate);
31698 if (PyErr_Occurred()) SWIG_fail;
31699 }
31700 {
31701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31702 }
31703 return resultobj;
31704 fail:
31705 return NULL;
31706 }
31707
31708
31709 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31710 PyObject *resultobj = 0;
31711 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31712 wxDataFormat *arg2 = 0 ;
31713 bool result;
31714 void *argp1 = 0 ;
31715 int res1 = 0 ;
31716 void *argp2 = 0 ;
31717 int res2 = 0 ;
31718
31719 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31721 if (!SWIG_IsOK(res1)) {
31722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31723 }
31724 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31725 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31726 if (!SWIG_IsOK(res2)) {
31727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31728 }
31729 if (!argp2) {
31730 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31731 }
31732 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31733 {
31734 PyThreadState* __tstate = wxPyBeginAllowThreads();
31735 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31736 wxPyEndAllowThreads(__tstate);
31737 if (PyErr_Occurred()) SWIG_fail;
31738 }
31739 {
31740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31741 }
31742 return resultobj;
31743 fail:
31744 return NULL;
31745 }
31746
31747
31748 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31749 int argc;
31750 PyObject *argv[3];
31751
31752 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31753 --argc;
31754 if (argc == 2) {
31755 int _v = 0;
31756 {
31757 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31758 _v = SWIG_CheckState(res);
31759 }
31760 if (!_v) goto check_1;
31761 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31762 }
31763 check_1:
31764
31765 if (argc == 2) {
31766 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31767 }
31768
31769 fail:
31770 Py_INCREF(Py_NotImplemented);
31771 return Py_NotImplemented;
31772 }
31773
31774
31775 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31776 PyObject *resultobj = 0;
31777 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31778 wxDataFormat *arg2 = 0 ;
31779 bool result;
31780 void *argp1 = 0 ;
31781 int res1 = 0 ;
31782 void *argp2 = 0 ;
31783 int res2 = 0 ;
31784
31785 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31787 if (!SWIG_IsOK(res1)) {
31788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31789 }
31790 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31791 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31792 if (!SWIG_IsOK(res2)) {
31793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31794 }
31795 if (!argp2) {
31796 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31797 }
31798 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31799 {
31800 PyThreadState* __tstate = wxPyBeginAllowThreads();
31801 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31802 wxPyEndAllowThreads(__tstate);
31803 if (PyErr_Occurred()) SWIG_fail;
31804 }
31805 {
31806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31807 }
31808 return resultobj;
31809 fail:
31810 return NULL;
31811 }
31812
31813
31814 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31815 int argc;
31816 PyObject *argv[3];
31817
31818 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31819 --argc;
31820 if (argc == 2) {
31821 int _v = 0;
31822 {
31823 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31824 _v = SWIG_CheckState(res);
31825 }
31826 if (!_v) goto check_1;
31827 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31828 }
31829 check_1:
31830
31831 if (argc == 2) {
31832 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31833 }
31834
31835 fail:
31836 Py_INCREF(Py_NotImplemented);
31837 return Py_NotImplemented;
31838 }
31839
31840
31841 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31842 PyObject *resultobj = 0;
31843 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31844 wxDataFormatId arg2 ;
31845 void *argp1 = 0 ;
31846 int res1 = 0 ;
31847 int val2 ;
31848 int ecode2 = 0 ;
31849 PyObject * obj0 = 0 ;
31850 PyObject * obj1 = 0 ;
31851 char * kwnames[] = {
31852 (char *) "self",(char *) "format", NULL
31853 };
31854
31855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31857 if (!SWIG_IsOK(res1)) {
31858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31859 }
31860 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31861 ecode2 = SWIG_AsVal_int(obj1, &val2);
31862 if (!SWIG_IsOK(ecode2)) {
31863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31864 }
31865 arg2 = static_cast< wxDataFormatId >(val2);
31866 {
31867 PyThreadState* __tstate = wxPyBeginAllowThreads();
31868 (arg1)->SetType(arg2);
31869 wxPyEndAllowThreads(__tstate);
31870 if (PyErr_Occurred()) SWIG_fail;
31871 }
31872 resultobj = SWIG_Py_Void();
31873 return resultobj;
31874 fail:
31875 return NULL;
31876 }
31877
31878
31879 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31880 PyObject *resultobj = 0;
31881 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31882 wxDataFormatId result;
31883 void *argp1 = 0 ;
31884 int res1 = 0 ;
31885 PyObject *swig_obj[1] ;
31886
31887 if (!args) SWIG_fail;
31888 swig_obj[0] = args;
31889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31890 if (!SWIG_IsOK(res1)) {
31891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31892 }
31893 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31894 {
31895 PyThreadState* __tstate = wxPyBeginAllowThreads();
31896 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31897 wxPyEndAllowThreads(__tstate);
31898 if (PyErr_Occurred()) SWIG_fail;
31899 }
31900 resultobj = SWIG_From_int(static_cast< int >(result));
31901 return resultobj;
31902 fail:
31903 return NULL;
31904 }
31905
31906
31907 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31908 PyObject *resultobj = 0;
31909 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31910 wxString result;
31911 void *argp1 = 0 ;
31912 int res1 = 0 ;
31913 PyObject *swig_obj[1] ;
31914
31915 if (!args) SWIG_fail;
31916 swig_obj[0] = args;
31917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31918 if (!SWIG_IsOK(res1)) {
31919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31920 }
31921 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31922 {
31923 PyThreadState* __tstate = wxPyBeginAllowThreads();
31924 result = ((wxDataFormat const *)arg1)->GetId();
31925 wxPyEndAllowThreads(__tstate);
31926 if (PyErr_Occurred()) SWIG_fail;
31927 }
31928 {
31929 #if wxUSE_UNICODE
31930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31931 #else
31932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31933 #endif
31934 }
31935 return resultobj;
31936 fail:
31937 return NULL;
31938 }
31939
31940
31941 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31942 PyObject *resultobj = 0;
31943 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31944 wxString *arg2 = 0 ;
31945 void *argp1 = 0 ;
31946 int res1 = 0 ;
31947 bool temp2 = false ;
31948 PyObject * obj0 = 0 ;
31949 PyObject * obj1 = 0 ;
31950 char * kwnames[] = {
31951 (char *) "self",(char *) "format", NULL
31952 };
31953
31954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31956 if (!SWIG_IsOK(res1)) {
31957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31958 }
31959 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31960 {
31961 arg2 = wxString_in_helper(obj1);
31962 if (arg2 == NULL) SWIG_fail;
31963 temp2 = true;
31964 }
31965 {
31966 PyThreadState* __tstate = wxPyBeginAllowThreads();
31967 (arg1)->SetId((wxString const &)*arg2);
31968 wxPyEndAllowThreads(__tstate);
31969 if (PyErr_Occurred()) SWIG_fail;
31970 }
31971 resultobj = SWIG_Py_Void();
31972 {
31973 if (temp2)
31974 delete arg2;
31975 }
31976 return resultobj;
31977 fail:
31978 {
31979 if (temp2)
31980 delete arg2;
31981 }
31982 return NULL;
31983 }
31984
31985
31986 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31987 PyObject *obj;
31988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31989 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31990 return SWIG_Py_Void();
31991 }
31992
31993 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31994 return SWIG_Python_InitShadowInstance(args);
31995 }
31996
31997 SWIGINTERN int FormatInvalid_set(PyObject *) {
31998 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31999 return 1;
32000 }
32001
32002
32003 SWIGINTERN PyObject *FormatInvalid_get(void) {
32004 PyObject *pyobj = 0;
32005
32006 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
32007 return pyobj;
32008 }
32009
32010
32011 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32012 PyObject *resultobj = 0;
32013 wxDataObject *arg1 = (wxDataObject *) 0 ;
32014 void *argp1 = 0 ;
32015 int res1 = 0 ;
32016 PyObject *swig_obj[1] ;
32017
32018 if (!args) SWIG_fail;
32019 swig_obj[0] = args;
32020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32021 if (!SWIG_IsOK(res1)) {
32022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
32023 }
32024 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32025 {
32026 PyThreadState* __tstate = wxPyBeginAllowThreads();
32027 delete arg1;
32028
32029 wxPyEndAllowThreads(__tstate);
32030 if (PyErr_Occurred()) SWIG_fail;
32031 }
32032 resultobj = SWIG_Py_Void();
32033 return resultobj;
32034 fail:
32035 return NULL;
32036 }
32037
32038
32039 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32040 PyObject *resultobj = 0;
32041 wxDataObject *arg1 = (wxDataObject *) 0 ;
32042 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32043 SwigValueWrapper<wxDataFormat > result;
32044 void *argp1 = 0 ;
32045 int res1 = 0 ;
32046 int val2 ;
32047 int ecode2 = 0 ;
32048 PyObject * obj0 = 0 ;
32049 PyObject * obj1 = 0 ;
32050 char * kwnames[] = {
32051 (char *) "self",(char *) "dir", NULL
32052 };
32053
32054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32056 if (!SWIG_IsOK(res1)) {
32057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32058 }
32059 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32060 if (obj1) {
32061 ecode2 = SWIG_AsVal_int(obj1, &val2);
32062 if (!SWIG_IsOK(ecode2)) {
32063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32064 }
32065 arg2 = static_cast< wxDataObject::Direction >(val2);
32066 }
32067 {
32068 PyThreadState* __tstate = wxPyBeginAllowThreads();
32069 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32070 wxPyEndAllowThreads(__tstate);
32071 if (PyErr_Occurred()) SWIG_fail;
32072 }
32073 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32074 return resultobj;
32075 fail:
32076 return NULL;
32077 }
32078
32079
32080 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32081 PyObject *resultobj = 0;
32082 wxDataObject *arg1 = (wxDataObject *) 0 ;
32083 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32084 size_t result;
32085 void *argp1 = 0 ;
32086 int res1 = 0 ;
32087 int val2 ;
32088 int ecode2 = 0 ;
32089 PyObject * obj0 = 0 ;
32090 PyObject * obj1 = 0 ;
32091 char * kwnames[] = {
32092 (char *) "self",(char *) "dir", NULL
32093 };
32094
32095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",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_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32099 }
32100 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32101 if (obj1) {
32102 ecode2 = SWIG_AsVal_int(obj1, &val2);
32103 if (!SWIG_IsOK(ecode2)) {
32104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32105 }
32106 arg2 = static_cast< wxDataObject::Direction >(val2);
32107 }
32108 {
32109 PyThreadState* __tstate = wxPyBeginAllowThreads();
32110 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32111 wxPyEndAllowThreads(__tstate);
32112 if (PyErr_Occurred()) SWIG_fail;
32113 }
32114 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32115 return resultobj;
32116 fail:
32117 return NULL;
32118 }
32119
32120
32121 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32122 PyObject *resultobj = 0;
32123 wxDataObject *arg1 = (wxDataObject *) 0 ;
32124 wxDataFormat *arg2 = 0 ;
32125 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32126 bool result;
32127 void *argp1 = 0 ;
32128 int res1 = 0 ;
32129 void *argp2 = 0 ;
32130 int res2 = 0 ;
32131 int val3 ;
32132 int ecode3 = 0 ;
32133 PyObject * obj0 = 0 ;
32134 PyObject * obj1 = 0 ;
32135 PyObject * obj2 = 0 ;
32136 char * kwnames[] = {
32137 (char *) "self",(char *) "format",(char *) "dir", NULL
32138 };
32139
32140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32142 if (!SWIG_IsOK(res1)) {
32143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32144 }
32145 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32146 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32147 if (!SWIG_IsOK(res2)) {
32148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32149 }
32150 if (!argp2) {
32151 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32152 }
32153 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32154 if (obj2) {
32155 ecode3 = SWIG_AsVal_int(obj2, &val3);
32156 if (!SWIG_IsOK(ecode3)) {
32157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32158 }
32159 arg3 = static_cast< wxDataObject::Direction >(val3);
32160 }
32161 {
32162 PyThreadState* __tstate = wxPyBeginAllowThreads();
32163 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32164 wxPyEndAllowThreads(__tstate);
32165 if (PyErr_Occurred()) SWIG_fail;
32166 }
32167 {
32168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32169 }
32170 return resultobj;
32171 fail:
32172 return NULL;
32173 }
32174
32175
32176 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32177 PyObject *resultobj = 0;
32178 wxDataObject *arg1 = (wxDataObject *) 0 ;
32179 wxDataFormat *arg2 = 0 ;
32180 size_t result;
32181 void *argp1 = 0 ;
32182 int res1 = 0 ;
32183 void *argp2 = 0 ;
32184 int res2 = 0 ;
32185 PyObject * obj0 = 0 ;
32186 PyObject * obj1 = 0 ;
32187 char * kwnames[] = {
32188 (char *) "self",(char *) "format", NULL
32189 };
32190
32191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32193 if (!SWIG_IsOK(res1)) {
32194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32195 }
32196 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32197 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32198 if (!SWIG_IsOK(res2)) {
32199 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32200 }
32201 if (!argp2) {
32202 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32203 }
32204 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32205 {
32206 PyThreadState* __tstate = wxPyBeginAllowThreads();
32207 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32208 wxPyEndAllowThreads(__tstate);
32209 if (PyErr_Occurred()) SWIG_fail;
32210 }
32211 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32212 return resultobj;
32213 fail:
32214 return NULL;
32215 }
32216
32217
32218 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32219 PyObject *resultobj = 0;
32220 wxDataObject *arg1 = (wxDataObject *) 0 ;
32221 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32222 PyObject *result = 0 ;
32223 void *argp1 = 0 ;
32224 int res1 = 0 ;
32225 int val2 ;
32226 int ecode2 = 0 ;
32227 PyObject * obj0 = 0 ;
32228 PyObject * obj1 = 0 ;
32229 char * kwnames[] = {
32230 (char *) "self",(char *) "dir", NULL
32231 };
32232
32233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32235 if (!SWIG_IsOK(res1)) {
32236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32237 }
32238 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32239 if (obj1) {
32240 ecode2 = SWIG_AsVal_int(obj1, &val2);
32241 if (!SWIG_IsOK(ecode2)) {
32242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32243 }
32244 arg2 = static_cast< wxDataObject::Direction >(val2);
32245 }
32246 {
32247 PyThreadState* __tstate = wxPyBeginAllowThreads();
32248 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32249 wxPyEndAllowThreads(__tstate);
32250 if (PyErr_Occurred()) SWIG_fail;
32251 }
32252 resultobj = result;
32253 return resultobj;
32254 fail:
32255 return NULL;
32256 }
32257
32258
32259 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32260 PyObject *resultobj = 0;
32261 wxDataObject *arg1 = (wxDataObject *) 0 ;
32262 wxDataFormat *arg2 = 0 ;
32263 PyObject *result = 0 ;
32264 void *argp1 = 0 ;
32265 int res1 = 0 ;
32266 void *argp2 = 0 ;
32267 int res2 = 0 ;
32268 PyObject * obj0 = 0 ;
32269 PyObject * obj1 = 0 ;
32270 char * kwnames[] = {
32271 (char *) "self",(char *) "format", NULL
32272 };
32273
32274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32276 if (!SWIG_IsOK(res1)) {
32277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32278 }
32279 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32280 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32281 if (!SWIG_IsOK(res2)) {
32282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32283 }
32284 if (!argp2) {
32285 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32286 }
32287 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32288 {
32289 PyThreadState* __tstate = wxPyBeginAllowThreads();
32290 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32291 wxPyEndAllowThreads(__tstate);
32292 if (PyErr_Occurred()) SWIG_fail;
32293 }
32294 resultobj = result;
32295 return resultobj;
32296 fail:
32297 return NULL;
32298 }
32299
32300
32301 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32302 PyObject *resultobj = 0;
32303 wxDataObject *arg1 = (wxDataObject *) 0 ;
32304 wxDataFormat *arg2 = 0 ;
32305 PyObject *arg3 = (PyObject *) 0 ;
32306 bool result;
32307 void *argp1 = 0 ;
32308 int res1 = 0 ;
32309 void *argp2 = 0 ;
32310 int res2 = 0 ;
32311 PyObject * obj0 = 0 ;
32312 PyObject * obj1 = 0 ;
32313 PyObject * obj2 = 0 ;
32314 char * kwnames[] = {
32315 (char *) "self",(char *) "format",(char *) "data", NULL
32316 };
32317
32318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32320 if (!SWIG_IsOK(res1)) {
32321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32322 }
32323 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32324 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32325 if (!SWIG_IsOK(res2)) {
32326 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32327 }
32328 if (!argp2) {
32329 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32330 }
32331 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32332 arg3 = obj2;
32333 {
32334 PyThreadState* __tstate = wxPyBeginAllowThreads();
32335 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32336 wxPyEndAllowThreads(__tstate);
32337 if (PyErr_Occurred()) SWIG_fail;
32338 }
32339 {
32340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32341 }
32342 return resultobj;
32343 fail:
32344 return NULL;
32345 }
32346
32347
32348 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32349 PyObject *obj;
32350 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32351 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32352 return SWIG_Py_Void();
32353 }
32354
32355 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32356 PyObject *resultobj = 0;
32357 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32358 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32359 wxDataObjectSimple *result = 0 ;
32360 void *argp1 = 0 ;
32361 int res1 = 0 ;
32362 PyObject * obj0 = 0 ;
32363 char * kwnames[] = {
32364 (char *) "format", NULL
32365 };
32366
32367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32368 if (obj0) {
32369 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32370 if (!SWIG_IsOK(res1)) {
32371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32372 }
32373 if (!argp1) {
32374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32375 }
32376 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32377 }
32378 {
32379 PyThreadState* __tstate = wxPyBeginAllowThreads();
32380 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32381 wxPyEndAllowThreads(__tstate);
32382 if (PyErr_Occurred()) SWIG_fail;
32383 }
32384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32385 return resultobj;
32386 fail:
32387 return NULL;
32388 }
32389
32390
32391 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32392 PyObject *resultobj = 0;
32393 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32394 wxDataFormat *result = 0 ;
32395 void *argp1 = 0 ;
32396 int res1 = 0 ;
32397 PyObject *swig_obj[1] ;
32398
32399 if (!args) SWIG_fail;
32400 swig_obj[0] = args;
32401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32402 if (!SWIG_IsOK(res1)) {
32403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32404 }
32405 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32406 {
32407 PyThreadState* __tstate = wxPyBeginAllowThreads();
32408 {
32409 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32410 result = (wxDataFormat *) &_result_ref;
32411 }
32412 wxPyEndAllowThreads(__tstate);
32413 if (PyErr_Occurred()) SWIG_fail;
32414 }
32415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32416 return resultobj;
32417 fail:
32418 return NULL;
32419 }
32420
32421
32422 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32423 PyObject *resultobj = 0;
32424 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32425 wxDataFormat *arg2 = 0 ;
32426 void *argp1 = 0 ;
32427 int res1 = 0 ;
32428 void *argp2 = 0 ;
32429 int res2 = 0 ;
32430 PyObject * obj0 = 0 ;
32431 PyObject * obj1 = 0 ;
32432 char * kwnames[] = {
32433 (char *) "self",(char *) "format", NULL
32434 };
32435
32436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",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_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32440 }
32441 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32442 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32443 if (!SWIG_IsOK(res2)) {
32444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32445 }
32446 if (!argp2) {
32447 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32448 }
32449 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32450 {
32451 PyThreadState* __tstate = wxPyBeginAllowThreads();
32452 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32453 wxPyEndAllowThreads(__tstate);
32454 if (PyErr_Occurred()) SWIG_fail;
32455 }
32456 resultobj = SWIG_Py_Void();
32457 return resultobj;
32458 fail:
32459 return NULL;
32460 }
32461
32462
32463 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32464 PyObject *resultobj = 0;
32465 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32466 size_t result;
32467 void *argp1 = 0 ;
32468 int res1 = 0 ;
32469 PyObject *swig_obj[1] ;
32470
32471 if (!args) SWIG_fail;
32472 swig_obj[0] = args;
32473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32474 if (!SWIG_IsOK(res1)) {
32475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32476 }
32477 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32478 {
32479 PyThreadState* __tstate = wxPyBeginAllowThreads();
32480 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32481 wxPyEndAllowThreads(__tstate);
32482 if (PyErr_Occurred()) SWIG_fail;
32483 }
32484 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32485 return resultobj;
32486 fail:
32487 return NULL;
32488 }
32489
32490
32491 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32492 PyObject *resultobj = 0;
32493 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32494 PyObject *result = 0 ;
32495 void *argp1 = 0 ;
32496 int res1 = 0 ;
32497 PyObject *swig_obj[1] ;
32498
32499 if (!args) SWIG_fail;
32500 swig_obj[0] = args;
32501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32502 if (!SWIG_IsOK(res1)) {
32503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32504 }
32505 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32506 {
32507 PyThreadState* __tstate = wxPyBeginAllowThreads();
32508 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32509 wxPyEndAllowThreads(__tstate);
32510 if (PyErr_Occurred()) SWIG_fail;
32511 }
32512 resultobj = result;
32513 return resultobj;
32514 fail:
32515 return NULL;
32516 }
32517
32518
32519 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32520 PyObject *resultobj = 0;
32521 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32522 PyObject *arg2 = (PyObject *) 0 ;
32523 bool result;
32524 void *argp1 = 0 ;
32525 int res1 = 0 ;
32526 PyObject * obj0 = 0 ;
32527 PyObject * obj1 = 0 ;
32528 char * kwnames[] = {
32529 (char *) "self",(char *) "data", NULL
32530 };
32531
32532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32534 if (!SWIG_IsOK(res1)) {
32535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32536 }
32537 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32538 arg2 = obj1;
32539 {
32540 PyThreadState* __tstate = wxPyBeginAllowThreads();
32541 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32542 wxPyEndAllowThreads(__tstate);
32543 if (PyErr_Occurred()) SWIG_fail;
32544 }
32545 {
32546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32547 }
32548 return resultobj;
32549 fail:
32550 return NULL;
32551 }
32552
32553
32554 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32555 PyObject *obj;
32556 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32557 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32558 return SWIG_Py_Void();
32559 }
32560
32561 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32562 return SWIG_Python_InitShadowInstance(args);
32563 }
32564
32565 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32566 PyObject *resultobj = 0;
32567 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32568 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32569 wxPyDataObjectSimple *result = 0 ;
32570 void *argp1 = 0 ;
32571 int res1 = 0 ;
32572 PyObject * obj0 = 0 ;
32573 char * kwnames[] = {
32574 (char *) "format", NULL
32575 };
32576
32577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32578 if (obj0) {
32579 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32580 if (!SWIG_IsOK(res1)) {
32581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32582 }
32583 if (!argp1) {
32584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32585 }
32586 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32587 }
32588 {
32589 PyThreadState* __tstate = wxPyBeginAllowThreads();
32590 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32591 wxPyEndAllowThreads(__tstate);
32592 if (PyErr_Occurred()) SWIG_fail;
32593 }
32594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32595 return resultobj;
32596 fail:
32597 return NULL;
32598 }
32599
32600
32601 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32602 PyObject *resultobj = 0;
32603 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32604 PyObject *arg2 = (PyObject *) 0 ;
32605 PyObject *arg3 = (PyObject *) 0 ;
32606 void *argp1 = 0 ;
32607 int res1 = 0 ;
32608 PyObject * obj0 = 0 ;
32609 PyObject * obj1 = 0 ;
32610 PyObject * obj2 = 0 ;
32611 char * kwnames[] = {
32612 (char *) "self",(char *) "self",(char *) "_class", NULL
32613 };
32614
32615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32617 if (!SWIG_IsOK(res1)) {
32618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32619 }
32620 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32621 arg2 = obj1;
32622 arg3 = obj2;
32623 {
32624 PyThreadState* __tstate = wxPyBeginAllowThreads();
32625 (arg1)->_setCallbackInfo(arg2,arg3);
32626 wxPyEndAllowThreads(__tstate);
32627 if (PyErr_Occurred()) SWIG_fail;
32628 }
32629 resultobj = SWIG_Py_Void();
32630 return resultobj;
32631 fail:
32632 return NULL;
32633 }
32634
32635
32636 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32637 PyObject *obj;
32638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32639 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32640 return SWIG_Py_Void();
32641 }
32642
32643 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32644 return SWIG_Python_InitShadowInstance(args);
32645 }
32646
32647 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32648 PyObject *resultobj = 0;
32649 wxDataObjectComposite *result = 0 ;
32650
32651 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32652 {
32653 PyThreadState* __tstate = wxPyBeginAllowThreads();
32654 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32655 wxPyEndAllowThreads(__tstate);
32656 if (PyErr_Occurred()) SWIG_fail;
32657 }
32658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32659 return resultobj;
32660 fail:
32661 return NULL;
32662 }
32663
32664
32665 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32666 PyObject *resultobj = 0;
32667 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32668 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32669 bool arg3 = (bool) false ;
32670 void *argp1 = 0 ;
32671 int res1 = 0 ;
32672 int res2 = 0 ;
32673 bool val3 ;
32674 int ecode3 = 0 ;
32675 PyObject * obj0 = 0 ;
32676 PyObject * obj1 = 0 ;
32677 PyObject * obj2 = 0 ;
32678 char * kwnames[] = {
32679 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32680 };
32681
32682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32684 if (!SWIG_IsOK(res1)) {
32685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32686 }
32687 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32688 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32689 if (!SWIG_IsOK(res2)) {
32690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32691 }
32692 if (obj2) {
32693 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32694 if (!SWIG_IsOK(ecode3)) {
32695 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32696 }
32697 arg3 = static_cast< bool >(val3);
32698 }
32699 {
32700 PyThreadState* __tstate = wxPyBeginAllowThreads();
32701 (arg1)->Add(arg2,arg3);
32702 wxPyEndAllowThreads(__tstate);
32703 if (PyErr_Occurred()) SWIG_fail;
32704 }
32705 resultobj = SWIG_Py_Void();
32706 return resultobj;
32707 fail:
32708 return NULL;
32709 }
32710
32711
32712 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32713 PyObject *resultobj = 0;
32714 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32715 SwigValueWrapper<wxDataFormat > result;
32716 void *argp1 = 0 ;
32717 int res1 = 0 ;
32718 PyObject *swig_obj[1] ;
32719
32720 if (!args) SWIG_fail;
32721 swig_obj[0] = args;
32722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32723 if (!SWIG_IsOK(res1)) {
32724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32725 }
32726 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32727 {
32728 PyThreadState* __tstate = wxPyBeginAllowThreads();
32729 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32730 wxPyEndAllowThreads(__tstate);
32731 if (PyErr_Occurred()) SWIG_fail;
32732 }
32733 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32734 return resultobj;
32735 fail:
32736 return NULL;
32737 }
32738
32739
32740 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32741 PyObject *obj;
32742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32743 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32744 return SWIG_Py_Void();
32745 }
32746
32747 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32748 return SWIG_Python_InitShadowInstance(args);
32749 }
32750
32751 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32752 PyObject *resultobj = 0;
32753 wxString const &arg1_defvalue = wxPyEmptyString ;
32754 wxString *arg1 = (wxString *) &arg1_defvalue ;
32755 wxTextDataObject *result = 0 ;
32756 bool temp1 = false ;
32757 PyObject * obj0 = 0 ;
32758 char * kwnames[] = {
32759 (char *) "text", NULL
32760 };
32761
32762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32763 if (obj0) {
32764 {
32765 arg1 = wxString_in_helper(obj0);
32766 if (arg1 == NULL) SWIG_fail;
32767 temp1 = true;
32768 }
32769 }
32770 {
32771 PyThreadState* __tstate = wxPyBeginAllowThreads();
32772 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32773 wxPyEndAllowThreads(__tstate);
32774 if (PyErr_Occurred()) SWIG_fail;
32775 }
32776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32777 {
32778 if (temp1)
32779 delete arg1;
32780 }
32781 return resultobj;
32782 fail:
32783 {
32784 if (temp1)
32785 delete arg1;
32786 }
32787 return NULL;
32788 }
32789
32790
32791 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32792 PyObject *resultobj = 0;
32793 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32794 size_t result;
32795 void *argp1 = 0 ;
32796 int res1 = 0 ;
32797 PyObject *swig_obj[1] ;
32798
32799 if (!args) SWIG_fail;
32800 swig_obj[0] = args;
32801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32802 if (!SWIG_IsOK(res1)) {
32803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32804 }
32805 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32806 {
32807 PyThreadState* __tstate = wxPyBeginAllowThreads();
32808 result = (size_t)(arg1)->GetTextLength();
32809 wxPyEndAllowThreads(__tstate);
32810 if (PyErr_Occurred()) SWIG_fail;
32811 }
32812 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32813 return resultobj;
32814 fail:
32815 return NULL;
32816 }
32817
32818
32819 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32820 PyObject *resultobj = 0;
32821 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32822 wxString result;
32823 void *argp1 = 0 ;
32824 int res1 = 0 ;
32825 PyObject *swig_obj[1] ;
32826
32827 if (!args) SWIG_fail;
32828 swig_obj[0] = args;
32829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32830 if (!SWIG_IsOK(res1)) {
32831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32832 }
32833 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32834 {
32835 PyThreadState* __tstate = wxPyBeginAllowThreads();
32836 result = (arg1)->GetText();
32837 wxPyEndAllowThreads(__tstate);
32838 if (PyErr_Occurred()) SWIG_fail;
32839 }
32840 {
32841 #if wxUSE_UNICODE
32842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32843 #else
32844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32845 #endif
32846 }
32847 return resultobj;
32848 fail:
32849 return NULL;
32850 }
32851
32852
32853 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32854 PyObject *resultobj = 0;
32855 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32856 wxString *arg2 = 0 ;
32857 void *argp1 = 0 ;
32858 int res1 = 0 ;
32859 bool temp2 = false ;
32860 PyObject * obj0 = 0 ;
32861 PyObject * obj1 = 0 ;
32862 char * kwnames[] = {
32863 (char *) "self",(char *) "text", NULL
32864 };
32865
32866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32868 if (!SWIG_IsOK(res1)) {
32869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32870 }
32871 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32872 {
32873 arg2 = wxString_in_helper(obj1);
32874 if (arg2 == NULL) SWIG_fail;
32875 temp2 = true;
32876 }
32877 {
32878 PyThreadState* __tstate = wxPyBeginAllowThreads();
32879 (arg1)->SetText((wxString const &)*arg2);
32880 wxPyEndAllowThreads(__tstate);
32881 if (PyErr_Occurred()) SWIG_fail;
32882 }
32883 resultobj = SWIG_Py_Void();
32884 {
32885 if (temp2)
32886 delete arg2;
32887 }
32888 return resultobj;
32889 fail:
32890 {
32891 if (temp2)
32892 delete arg2;
32893 }
32894 return NULL;
32895 }
32896
32897
32898 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32899 PyObject *obj;
32900 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32901 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32902 return SWIG_Py_Void();
32903 }
32904
32905 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32906 return SWIG_Python_InitShadowInstance(args);
32907 }
32908
32909 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32910 PyObject *resultobj = 0;
32911 wxString const &arg1_defvalue = wxPyEmptyString ;
32912 wxString *arg1 = (wxString *) &arg1_defvalue ;
32913 wxPyTextDataObject *result = 0 ;
32914 bool temp1 = false ;
32915 PyObject * obj0 = 0 ;
32916 char * kwnames[] = {
32917 (char *) "text", NULL
32918 };
32919
32920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32921 if (obj0) {
32922 {
32923 arg1 = wxString_in_helper(obj0);
32924 if (arg1 == NULL) SWIG_fail;
32925 temp1 = true;
32926 }
32927 }
32928 {
32929 PyThreadState* __tstate = wxPyBeginAllowThreads();
32930 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32931 wxPyEndAllowThreads(__tstate);
32932 if (PyErr_Occurred()) SWIG_fail;
32933 }
32934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32935 {
32936 if (temp1)
32937 delete arg1;
32938 }
32939 return resultobj;
32940 fail:
32941 {
32942 if (temp1)
32943 delete arg1;
32944 }
32945 return NULL;
32946 }
32947
32948
32949 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32950 PyObject *resultobj = 0;
32951 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32952 PyObject *arg2 = (PyObject *) 0 ;
32953 PyObject *arg3 = (PyObject *) 0 ;
32954 void *argp1 = 0 ;
32955 int res1 = 0 ;
32956 PyObject * obj0 = 0 ;
32957 PyObject * obj1 = 0 ;
32958 PyObject * obj2 = 0 ;
32959 char * kwnames[] = {
32960 (char *) "self",(char *) "self",(char *) "_class", NULL
32961 };
32962
32963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32965 if (!SWIG_IsOK(res1)) {
32966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32967 }
32968 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32969 arg2 = obj1;
32970 arg3 = obj2;
32971 {
32972 PyThreadState* __tstate = wxPyBeginAllowThreads();
32973 (arg1)->_setCallbackInfo(arg2,arg3);
32974 wxPyEndAllowThreads(__tstate);
32975 if (PyErr_Occurred()) SWIG_fail;
32976 }
32977 resultobj = SWIG_Py_Void();
32978 return resultobj;
32979 fail:
32980 return NULL;
32981 }
32982
32983
32984 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32985 PyObject *obj;
32986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32987 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32988 return SWIG_Py_Void();
32989 }
32990
32991 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32992 return SWIG_Python_InitShadowInstance(args);
32993 }
32994
32995 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32996 PyObject *resultobj = 0;
32997 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32998 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32999 wxBitmapDataObject *result = 0 ;
33000 void *argp1 = 0 ;
33001 int res1 = 0 ;
33002 PyObject * obj0 = 0 ;
33003 char * kwnames[] = {
33004 (char *) "bitmap", NULL
33005 };
33006
33007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
33008 if (obj0) {
33009 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33010 if (!SWIG_IsOK(res1)) {
33011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33012 }
33013 if (!argp1) {
33014 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33015 }
33016 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33017 }
33018 {
33019 PyThreadState* __tstate = wxPyBeginAllowThreads();
33020 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
33021 wxPyEndAllowThreads(__tstate);
33022 if (PyErr_Occurred()) SWIG_fail;
33023 }
33024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
33025 return resultobj;
33026 fail:
33027 return NULL;
33028 }
33029
33030
33031 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33032 PyObject *resultobj = 0;
33033 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33034 wxBitmap result;
33035 void *argp1 = 0 ;
33036 int res1 = 0 ;
33037 PyObject *swig_obj[1] ;
33038
33039 if (!args) SWIG_fail;
33040 swig_obj[0] = args;
33041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33042 if (!SWIG_IsOK(res1)) {
33043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33044 }
33045 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33046 {
33047 PyThreadState* __tstate = wxPyBeginAllowThreads();
33048 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33049 wxPyEndAllowThreads(__tstate);
33050 if (PyErr_Occurred()) SWIG_fail;
33051 }
33052 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33053 return resultobj;
33054 fail:
33055 return NULL;
33056 }
33057
33058
33059 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33060 PyObject *resultobj = 0;
33061 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33062 wxBitmap *arg2 = 0 ;
33063 void *argp1 = 0 ;
33064 int res1 = 0 ;
33065 void *argp2 = 0 ;
33066 int res2 = 0 ;
33067 PyObject * obj0 = 0 ;
33068 PyObject * obj1 = 0 ;
33069 char * kwnames[] = {
33070 (char *) "self",(char *) "bitmap", NULL
33071 };
33072
33073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33075 if (!SWIG_IsOK(res1)) {
33076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33077 }
33078 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33079 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33080 if (!SWIG_IsOK(res2)) {
33081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33082 }
33083 if (!argp2) {
33084 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33085 }
33086 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33087 {
33088 PyThreadState* __tstate = wxPyBeginAllowThreads();
33089 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33090 wxPyEndAllowThreads(__tstate);
33091 if (PyErr_Occurred()) SWIG_fail;
33092 }
33093 resultobj = SWIG_Py_Void();
33094 return resultobj;
33095 fail:
33096 return NULL;
33097 }
33098
33099
33100 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33101 PyObject *obj;
33102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33103 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33104 return SWIG_Py_Void();
33105 }
33106
33107 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33108 return SWIG_Python_InitShadowInstance(args);
33109 }
33110
33111 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33112 PyObject *resultobj = 0;
33113 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33114 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33115 wxPyBitmapDataObject *result = 0 ;
33116 void *argp1 = 0 ;
33117 int res1 = 0 ;
33118 PyObject * obj0 = 0 ;
33119 char * kwnames[] = {
33120 (char *) "bitmap", NULL
33121 };
33122
33123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33124 if (obj0) {
33125 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33126 if (!SWIG_IsOK(res1)) {
33127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33128 }
33129 if (!argp1) {
33130 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33131 }
33132 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33133 }
33134 {
33135 PyThreadState* __tstate = wxPyBeginAllowThreads();
33136 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33137 wxPyEndAllowThreads(__tstate);
33138 if (PyErr_Occurred()) SWIG_fail;
33139 }
33140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33141 return resultobj;
33142 fail:
33143 return NULL;
33144 }
33145
33146
33147 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33148 PyObject *resultobj = 0;
33149 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33150 PyObject *arg2 = (PyObject *) 0 ;
33151 PyObject *arg3 = (PyObject *) 0 ;
33152 void *argp1 = 0 ;
33153 int res1 = 0 ;
33154 PyObject * obj0 = 0 ;
33155 PyObject * obj1 = 0 ;
33156 PyObject * obj2 = 0 ;
33157 char * kwnames[] = {
33158 (char *) "self",(char *) "self",(char *) "_class", NULL
33159 };
33160
33161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33163 if (!SWIG_IsOK(res1)) {
33164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33165 }
33166 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33167 arg2 = obj1;
33168 arg3 = obj2;
33169 {
33170 PyThreadState* __tstate = wxPyBeginAllowThreads();
33171 (arg1)->_setCallbackInfo(arg2,arg3);
33172 wxPyEndAllowThreads(__tstate);
33173 if (PyErr_Occurred()) SWIG_fail;
33174 }
33175 resultobj = SWIG_Py_Void();
33176 return resultobj;
33177 fail:
33178 return NULL;
33179 }
33180
33181
33182 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33183 PyObject *obj;
33184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33185 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33186 return SWIG_Py_Void();
33187 }
33188
33189 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33190 return SWIG_Python_InitShadowInstance(args);
33191 }
33192
33193 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33194 PyObject *resultobj = 0;
33195 wxFileDataObject *result = 0 ;
33196
33197 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33198 {
33199 PyThreadState* __tstate = wxPyBeginAllowThreads();
33200 result = (wxFileDataObject *)new wxFileDataObject();
33201 wxPyEndAllowThreads(__tstate);
33202 if (PyErr_Occurred()) SWIG_fail;
33203 }
33204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33205 return resultobj;
33206 fail:
33207 return NULL;
33208 }
33209
33210
33211 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33212 PyObject *resultobj = 0;
33213 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33214 wxArrayString *result = 0 ;
33215 void *argp1 = 0 ;
33216 int res1 = 0 ;
33217 PyObject *swig_obj[1] ;
33218
33219 if (!args) SWIG_fail;
33220 swig_obj[0] = args;
33221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33222 if (!SWIG_IsOK(res1)) {
33223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33224 }
33225 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33226 {
33227 PyThreadState* __tstate = wxPyBeginAllowThreads();
33228 {
33229 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33230 result = (wxArrayString *) &_result_ref;
33231 }
33232 wxPyEndAllowThreads(__tstate);
33233 if (PyErr_Occurred()) SWIG_fail;
33234 }
33235 {
33236 resultobj = wxArrayString2PyList_helper(*result);
33237 }
33238 return resultobj;
33239 fail:
33240 return NULL;
33241 }
33242
33243
33244 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33245 PyObject *resultobj = 0;
33246 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33247 wxString *arg2 = 0 ;
33248 void *argp1 = 0 ;
33249 int res1 = 0 ;
33250 bool temp2 = false ;
33251 PyObject * obj0 = 0 ;
33252 PyObject * obj1 = 0 ;
33253 char * kwnames[] = {
33254 (char *) "self",(char *) "filename", NULL
33255 };
33256
33257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33259 if (!SWIG_IsOK(res1)) {
33260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33261 }
33262 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33263 {
33264 arg2 = wxString_in_helper(obj1);
33265 if (arg2 == NULL) SWIG_fail;
33266 temp2 = true;
33267 }
33268 {
33269 PyThreadState* __tstate = wxPyBeginAllowThreads();
33270 (arg1)->AddFile((wxString const &)*arg2);
33271 wxPyEndAllowThreads(__tstate);
33272 if (PyErr_Occurred()) SWIG_fail;
33273 }
33274 resultobj = SWIG_Py_Void();
33275 {
33276 if (temp2)
33277 delete arg2;
33278 }
33279 return resultobj;
33280 fail:
33281 {
33282 if (temp2)
33283 delete arg2;
33284 }
33285 return NULL;
33286 }
33287
33288
33289 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33290 PyObject *obj;
33291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33292 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33293 return SWIG_Py_Void();
33294 }
33295
33296 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33297 return SWIG_Python_InitShadowInstance(args);
33298 }
33299
33300 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33301 PyObject *resultobj = 0;
33302 wxDataFormat *arg1 = 0 ;
33303 wxCustomDataObject *result = 0 ;
33304 void *argp1 = 0 ;
33305 int res1 = 0 ;
33306
33307 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33309 if (!SWIG_IsOK(res1)) {
33310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33311 }
33312 if (!argp1) {
33313 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33314 }
33315 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33316 {
33317 PyThreadState* __tstate = wxPyBeginAllowThreads();
33318 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33319 wxPyEndAllowThreads(__tstate);
33320 if (PyErr_Occurred()) SWIG_fail;
33321 }
33322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33323 return resultobj;
33324 fail:
33325 return NULL;
33326 }
33327
33328
33329 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33330 PyObject *resultobj = 0;
33331 wxString *arg1 = 0 ;
33332 wxCustomDataObject *result = 0 ;
33333 bool temp1 = false ;
33334
33335 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33336 {
33337 arg1 = wxString_in_helper(swig_obj[0]);
33338 if (arg1 == NULL) SWIG_fail;
33339 temp1 = true;
33340 }
33341 {
33342 PyThreadState* __tstate = wxPyBeginAllowThreads();
33343 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33344 wxPyEndAllowThreads(__tstate);
33345 if (PyErr_Occurred()) SWIG_fail;
33346 }
33347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33348 {
33349 if (temp1)
33350 delete arg1;
33351 }
33352 return resultobj;
33353 fail:
33354 {
33355 if (temp1)
33356 delete arg1;
33357 }
33358 return NULL;
33359 }
33360
33361
33362 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33363 PyObject *resultobj = 0;
33364 wxCustomDataObject *result = 0 ;
33365
33366 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33367 {
33368 PyThreadState* __tstate = wxPyBeginAllowThreads();
33369 result = (wxCustomDataObject *)new wxCustomDataObject();
33370 wxPyEndAllowThreads(__tstate);
33371 if (PyErr_Occurred()) SWIG_fail;
33372 }
33373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33374 return resultobj;
33375 fail:
33376 return NULL;
33377 }
33378
33379
33380 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33381 int argc;
33382 PyObject *argv[2];
33383
33384 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33385 --argc;
33386 if (argc == 0) {
33387 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33388 }
33389 if (argc == 1) {
33390 int _v = 0;
33391 {
33392 {
33393 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33394 }
33395 }
33396 if (!_v) goto check_2;
33397 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33398 }
33399 check_2:
33400
33401 if (argc == 1) {
33402 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33403 }
33404
33405 fail:
33406 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33407 return NULL;
33408 }
33409
33410
33411 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33412 PyObject *resultobj = 0;
33413 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33414 PyObject *arg2 = (PyObject *) 0 ;
33415 bool result;
33416 void *argp1 = 0 ;
33417 int res1 = 0 ;
33418 PyObject * obj0 = 0 ;
33419 PyObject * obj1 = 0 ;
33420 char * kwnames[] = {
33421 (char *) "self",(char *) "data", NULL
33422 };
33423
33424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33426 if (!SWIG_IsOK(res1)) {
33427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33428 }
33429 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33430 arg2 = obj1;
33431 {
33432 PyThreadState* __tstate = wxPyBeginAllowThreads();
33433 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33434 wxPyEndAllowThreads(__tstate);
33435 if (PyErr_Occurred()) SWIG_fail;
33436 }
33437 {
33438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33439 }
33440 return resultobj;
33441 fail:
33442 return NULL;
33443 }
33444
33445
33446 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33447 PyObject *resultobj = 0;
33448 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33449 size_t result;
33450 void *argp1 = 0 ;
33451 int res1 = 0 ;
33452 PyObject *swig_obj[1] ;
33453
33454 if (!args) SWIG_fail;
33455 swig_obj[0] = args;
33456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33457 if (!SWIG_IsOK(res1)) {
33458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33459 }
33460 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33461 {
33462 PyThreadState* __tstate = wxPyBeginAllowThreads();
33463 result = (size_t)(arg1)->GetSize();
33464 wxPyEndAllowThreads(__tstate);
33465 if (PyErr_Occurred()) SWIG_fail;
33466 }
33467 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33468 return resultobj;
33469 fail:
33470 return NULL;
33471 }
33472
33473
33474 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33475 PyObject *resultobj = 0;
33476 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33477 PyObject *result = 0 ;
33478 void *argp1 = 0 ;
33479 int res1 = 0 ;
33480 PyObject *swig_obj[1] ;
33481
33482 if (!args) SWIG_fail;
33483 swig_obj[0] = args;
33484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33485 if (!SWIG_IsOK(res1)) {
33486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33487 }
33488 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33489 {
33490 PyThreadState* __tstate = wxPyBeginAllowThreads();
33491 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33492 wxPyEndAllowThreads(__tstate);
33493 if (PyErr_Occurred()) SWIG_fail;
33494 }
33495 resultobj = result;
33496 return resultobj;
33497 fail:
33498 return NULL;
33499 }
33500
33501
33502 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33503 PyObject *obj;
33504 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33505 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33506 return SWIG_Py_Void();
33507 }
33508
33509 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33510 return SWIG_Python_InitShadowInstance(args);
33511 }
33512
33513 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33514 PyObject *resultobj = 0;
33515 wxString const &arg1_defvalue = wxPyEmptyString ;
33516 wxString *arg1 = (wxString *) &arg1_defvalue ;
33517 wxURLDataObject *result = 0 ;
33518 bool temp1 = false ;
33519 PyObject * obj0 = 0 ;
33520 char * kwnames[] = {
33521 (char *) "url", NULL
33522 };
33523
33524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33525 if (obj0) {
33526 {
33527 arg1 = wxString_in_helper(obj0);
33528 if (arg1 == NULL) SWIG_fail;
33529 temp1 = true;
33530 }
33531 }
33532 {
33533 PyThreadState* __tstate = wxPyBeginAllowThreads();
33534 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33535 wxPyEndAllowThreads(__tstate);
33536 if (PyErr_Occurred()) SWIG_fail;
33537 }
33538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33539 {
33540 if (temp1)
33541 delete arg1;
33542 }
33543 return resultobj;
33544 fail:
33545 {
33546 if (temp1)
33547 delete arg1;
33548 }
33549 return NULL;
33550 }
33551
33552
33553 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33554 PyObject *resultobj = 0;
33555 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33556 wxString result;
33557 void *argp1 = 0 ;
33558 int res1 = 0 ;
33559 PyObject *swig_obj[1] ;
33560
33561 if (!args) SWIG_fail;
33562 swig_obj[0] = args;
33563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33564 if (!SWIG_IsOK(res1)) {
33565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33566 }
33567 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33568 {
33569 PyThreadState* __tstate = wxPyBeginAllowThreads();
33570 result = (arg1)->GetURL();
33571 wxPyEndAllowThreads(__tstate);
33572 if (PyErr_Occurred()) SWIG_fail;
33573 }
33574 {
33575 #if wxUSE_UNICODE
33576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33577 #else
33578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33579 #endif
33580 }
33581 return resultobj;
33582 fail:
33583 return NULL;
33584 }
33585
33586
33587 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33588 PyObject *resultobj = 0;
33589 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33590 wxString *arg2 = 0 ;
33591 void *argp1 = 0 ;
33592 int res1 = 0 ;
33593 bool temp2 = false ;
33594 PyObject * obj0 = 0 ;
33595 PyObject * obj1 = 0 ;
33596 char * kwnames[] = {
33597 (char *) "self",(char *) "url", NULL
33598 };
33599
33600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33602 if (!SWIG_IsOK(res1)) {
33603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33604 }
33605 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33606 {
33607 arg2 = wxString_in_helper(obj1);
33608 if (arg2 == NULL) SWIG_fail;
33609 temp2 = true;
33610 }
33611 {
33612 PyThreadState* __tstate = wxPyBeginAllowThreads();
33613 (arg1)->SetURL((wxString const &)*arg2);
33614 wxPyEndAllowThreads(__tstate);
33615 if (PyErr_Occurred()) SWIG_fail;
33616 }
33617 resultobj = SWIG_Py_Void();
33618 {
33619 if (temp2)
33620 delete arg2;
33621 }
33622 return resultobj;
33623 fail:
33624 {
33625 if (temp2)
33626 delete arg2;
33627 }
33628 return NULL;
33629 }
33630
33631
33632 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33633 PyObject *obj;
33634 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33635 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33636 return SWIG_Py_Void();
33637 }
33638
33639 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33640 return SWIG_Python_InitShadowInstance(args);
33641 }
33642
33643 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33644 PyObject *resultobj = 0;
33645 wxMetafileDataObject *result = 0 ;
33646
33647 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33648 {
33649 PyThreadState* __tstate = wxPyBeginAllowThreads();
33650 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33651 wxPyEndAllowThreads(__tstate);
33652 if (PyErr_Occurred()) SWIG_fail;
33653 }
33654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33655 return resultobj;
33656 fail:
33657 return NULL;
33658 }
33659
33660
33661 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33662 PyObject *resultobj = 0;
33663 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33664 wxMetafile *arg2 = 0 ;
33665 void *argp1 = 0 ;
33666 int res1 = 0 ;
33667 void *argp2 = 0 ;
33668 int res2 = 0 ;
33669 PyObject * obj0 = 0 ;
33670 PyObject * obj1 = 0 ;
33671 char * kwnames[] = {
33672 (char *) "self",(char *) "metafile", NULL
33673 };
33674
33675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
33676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33677 if (!SWIG_IsOK(res1)) {
33678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
33679 }
33680 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33681 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
33682 if (!SWIG_IsOK(res2)) {
33683 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33684 }
33685 if (!argp2) {
33686 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33687 }
33688 arg2 = reinterpret_cast< wxMetafile * >(argp2);
33689 {
33690 PyThreadState* __tstate = wxPyBeginAllowThreads();
33691 (arg1)->SetMetafile((wxMetafile const &)*arg2);
33692 wxPyEndAllowThreads(__tstate);
33693 if (PyErr_Occurred()) SWIG_fail;
33694 }
33695 resultobj = SWIG_Py_Void();
33696 return resultobj;
33697 fail:
33698 return NULL;
33699 }
33700
33701
33702 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33703 PyObject *resultobj = 0;
33704 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33705 wxMetafile result;
33706 void *argp1 = 0 ;
33707 int res1 = 0 ;
33708 PyObject *swig_obj[1] ;
33709
33710 if (!args) SWIG_fail;
33711 swig_obj[0] = args;
33712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33713 if (!SWIG_IsOK(res1)) {
33714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
33715 }
33716 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33717 {
33718 PyThreadState* __tstate = wxPyBeginAllowThreads();
33719 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
33720 wxPyEndAllowThreads(__tstate);
33721 if (PyErr_Occurred()) SWIG_fail;
33722 }
33723 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
33724 return resultobj;
33725 fail:
33726 return NULL;
33727 }
33728
33729
33730 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33731 PyObject *obj;
33732 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33733 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33734 return SWIG_Py_Void();
33735 }
33736
33737 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33738 return SWIG_Python_InitShadowInstance(args);
33739 }
33740
33741 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33742 PyObject *resultobj = 0;
33743 wxDragResult arg1 ;
33744 bool result;
33745 int val1 ;
33746 int ecode1 = 0 ;
33747 PyObject * obj0 = 0 ;
33748 char * kwnames[] = {
33749 (char *) "res", NULL
33750 };
33751
33752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33753 ecode1 = SWIG_AsVal_int(obj0, &val1);
33754 if (!SWIG_IsOK(ecode1)) {
33755 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33756 }
33757 arg1 = static_cast< wxDragResult >(val1);
33758 {
33759 PyThreadState* __tstate = wxPyBeginAllowThreads();
33760 result = (bool)wxIsDragResultOk(arg1);
33761 wxPyEndAllowThreads(__tstate);
33762 if (PyErr_Occurred()) SWIG_fail;
33763 }
33764 {
33765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33766 }
33767 return resultobj;
33768 fail:
33769 return NULL;
33770 }
33771
33772
33773 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33774 PyObject *resultobj = 0;
33775 wxWindow *arg1 = (wxWindow *) 0 ;
33776 wxCursor const &arg2_defvalue = wxNullCursor ;
33777 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
33778 wxCursor const &arg3_defvalue = wxNullCursor ;
33779 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
33780 wxCursor const &arg4_defvalue = wxNullCursor ;
33781 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
33782 wxPyDropSource *result = 0 ;
33783 void *argp1 = 0 ;
33784 int res1 = 0 ;
33785 void *argp2 = 0 ;
33786 int res2 = 0 ;
33787 void *argp3 = 0 ;
33788 int res3 = 0 ;
33789 void *argp4 = 0 ;
33790 int res4 = 0 ;
33791 PyObject * obj0 = 0 ;
33792 PyObject * obj1 = 0 ;
33793 PyObject * obj2 = 0 ;
33794 PyObject * obj3 = 0 ;
33795 char * kwnames[] = {
33796 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33797 };
33798
33799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33801 if (!SWIG_IsOK(res1)) {
33802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33803 }
33804 arg1 = reinterpret_cast< wxWindow * >(argp1);
33805 if (obj1) {
33806 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
33807 if (!SWIG_IsOK(res2)) {
33808 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33809 }
33810 if (!argp2) {
33811 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33812 }
33813 arg2 = reinterpret_cast< wxCursor * >(argp2);
33814 }
33815 if (obj2) {
33816 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33817 if (!SWIG_IsOK(res3)) {
33818 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33819 }
33820 if (!argp3) {
33821 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33822 }
33823 arg3 = reinterpret_cast< wxCursor * >(argp3);
33824 }
33825 if (obj3) {
33826 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
33827 if (!SWIG_IsOK(res4)) {
33828 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33829 }
33830 if (!argp4) {
33831 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33832 }
33833 arg4 = reinterpret_cast< wxCursor * >(argp4);
33834 }
33835 {
33836 PyThreadState* __tstate = wxPyBeginAllowThreads();
33837 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
33838 wxPyEndAllowThreads(__tstate);
33839 if (PyErr_Occurred()) SWIG_fail;
33840 }
33841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33842 return resultobj;
33843 fail:
33844 return NULL;
33845 }
33846
33847
33848 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33849 PyObject *resultobj = 0;
33850 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33851 PyObject *arg2 = (PyObject *) 0 ;
33852 PyObject *arg3 = (PyObject *) 0 ;
33853 int arg4 = (int) 0 ;
33854 void *argp1 = 0 ;
33855 int res1 = 0 ;
33856 int val4 ;
33857 int ecode4 = 0 ;
33858 PyObject * obj0 = 0 ;
33859 PyObject * obj1 = 0 ;
33860 PyObject * obj2 = 0 ;
33861 PyObject * obj3 = 0 ;
33862 char * kwnames[] = {
33863 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33864 };
33865
33866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33868 if (!SWIG_IsOK(res1)) {
33869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33870 }
33871 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33872 arg2 = obj1;
33873 arg3 = obj2;
33874 if (obj3) {
33875 ecode4 = SWIG_AsVal_int(obj3, &val4);
33876 if (!SWIG_IsOK(ecode4)) {
33877 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33878 }
33879 arg4 = static_cast< int >(val4);
33880 }
33881 {
33882 PyThreadState* __tstate = wxPyBeginAllowThreads();
33883 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33884 wxPyEndAllowThreads(__tstate);
33885 if (PyErr_Occurred()) SWIG_fail;
33886 }
33887 resultobj = SWIG_Py_Void();
33888 return resultobj;
33889 fail:
33890 return NULL;
33891 }
33892
33893
33894 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33895 PyObject *resultobj = 0;
33896 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33897 void *argp1 = 0 ;
33898 int res1 = 0 ;
33899 PyObject *swig_obj[1] ;
33900
33901 if (!args) SWIG_fail;
33902 swig_obj[0] = args;
33903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33904 if (!SWIG_IsOK(res1)) {
33905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33906 }
33907 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33908 {
33909 PyThreadState* __tstate = wxPyBeginAllowThreads();
33910 delete arg1;
33911
33912 wxPyEndAllowThreads(__tstate);
33913 if (PyErr_Occurred()) SWIG_fail;
33914 }
33915 resultobj = SWIG_Py_Void();
33916 return resultobj;
33917 fail:
33918 return NULL;
33919 }
33920
33921
33922 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33923 PyObject *resultobj = 0;
33924 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33925 wxDataObject *arg2 = 0 ;
33926 void *argp1 = 0 ;
33927 int res1 = 0 ;
33928 void *argp2 = 0 ;
33929 int res2 = 0 ;
33930 PyObject * obj0 = 0 ;
33931 PyObject * obj1 = 0 ;
33932 char * kwnames[] = {
33933 (char *) "self",(char *) "data", NULL
33934 };
33935
33936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33938 if (!SWIG_IsOK(res1)) {
33939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33940 }
33941 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33942 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33943 if (!SWIG_IsOK(res2)) {
33944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33945 }
33946 if (!argp2) {
33947 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33948 }
33949 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33950 {
33951 PyThreadState* __tstate = wxPyBeginAllowThreads();
33952 (arg1)->SetData(*arg2);
33953 wxPyEndAllowThreads(__tstate);
33954 if (PyErr_Occurred()) SWIG_fail;
33955 }
33956 resultobj = SWIG_Py_Void();
33957 return resultobj;
33958 fail:
33959 return NULL;
33960 }
33961
33962
33963 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33964 PyObject *resultobj = 0;
33965 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33966 wxDataObject *result = 0 ;
33967 void *argp1 = 0 ;
33968 int res1 = 0 ;
33969 PyObject *swig_obj[1] ;
33970
33971 if (!args) SWIG_fail;
33972 swig_obj[0] = args;
33973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33974 if (!SWIG_IsOK(res1)) {
33975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33976 }
33977 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33978 {
33979 PyThreadState* __tstate = wxPyBeginAllowThreads();
33980 result = (wxDataObject *)(arg1)->GetDataObject();
33981 wxPyEndAllowThreads(__tstate);
33982 if (PyErr_Occurred()) SWIG_fail;
33983 }
33984 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33985 return resultobj;
33986 fail:
33987 return NULL;
33988 }
33989
33990
33991 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33992 PyObject *resultobj = 0;
33993 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33994 wxDragResult arg2 ;
33995 wxCursor *arg3 = 0 ;
33996 void *argp1 = 0 ;
33997 int res1 = 0 ;
33998 int val2 ;
33999 int ecode2 = 0 ;
34000 void *argp3 = 0 ;
34001 int res3 = 0 ;
34002 PyObject * obj0 = 0 ;
34003 PyObject * obj1 = 0 ;
34004 PyObject * obj2 = 0 ;
34005 char * kwnames[] = {
34006 (char *) "self",(char *) "res",(char *) "cursor", NULL
34007 };
34008
34009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34011 if (!SWIG_IsOK(res1)) {
34012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34013 }
34014 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34015 ecode2 = SWIG_AsVal_int(obj1, &val2);
34016 if (!SWIG_IsOK(ecode2)) {
34017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
34018 }
34019 arg2 = static_cast< wxDragResult >(val2);
34020 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
34021 if (!SWIG_IsOK(res3)) {
34022 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34023 }
34024 if (!argp3) {
34025 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34026 }
34027 arg3 = reinterpret_cast< wxCursor * >(argp3);
34028 {
34029 PyThreadState* __tstate = wxPyBeginAllowThreads();
34030 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
34031 wxPyEndAllowThreads(__tstate);
34032 if (PyErr_Occurred()) SWIG_fail;
34033 }
34034 resultobj = SWIG_Py_Void();
34035 return resultobj;
34036 fail:
34037 return NULL;
34038 }
34039
34040
34041 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34042 PyObject *resultobj = 0;
34043 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34044 int arg2 = (int) wxDrag_CopyOnly ;
34045 wxDragResult result;
34046 void *argp1 = 0 ;
34047 int res1 = 0 ;
34048 int val2 ;
34049 int ecode2 = 0 ;
34050 PyObject * obj0 = 0 ;
34051 PyObject * obj1 = 0 ;
34052 char * kwnames[] = {
34053 (char *) "self",(char *) "flags", NULL
34054 };
34055
34056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
34057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34058 if (!SWIG_IsOK(res1)) {
34059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34060 }
34061 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34062 if (obj1) {
34063 ecode2 = SWIG_AsVal_int(obj1, &val2);
34064 if (!SWIG_IsOK(ecode2)) {
34065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
34066 }
34067 arg2 = static_cast< int >(val2);
34068 }
34069 {
34070 PyThreadState* __tstate = wxPyBeginAllowThreads();
34071 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34072 wxPyEndAllowThreads(__tstate);
34073 if (PyErr_Occurred()) SWIG_fail;
34074 }
34075 resultobj = SWIG_From_int(static_cast< int >(result));
34076 return resultobj;
34077 fail:
34078 return NULL;
34079 }
34080
34081
34082 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34083 PyObject *resultobj = 0;
34084 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34085 wxDragResult arg2 ;
34086 bool result;
34087 void *argp1 = 0 ;
34088 int res1 = 0 ;
34089 int val2 ;
34090 int ecode2 = 0 ;
34091 PyObject * obj0 = 0 ;
34092 PyObject * obj1 = 0 ;
34093 char * kwnames[] = {
34094 (char *) "self",(char *) "effect", NULL
34095 };
34096
34097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34099 if (!SWIG_IsOK(res1)) {
34100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34101 }
34102 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34103 ecode2 = SWIG_AsVal_int(obj1, &val2);
34104 if (!SWIG_IsOK(ecode2)) {
34105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34106 }
34107 arg2 = static_cast< wxDragResult >(val2);
34108 {
34109 PyThreadState* __tstate = wxPyBeginAllowThreads();
34110 result = (bool)(arg1)->GiveFeedback(arg2);
34111 wxPyEndAllowThreads(__tstate);
34112 if (PyErr_Occurred()) SWIG_fail;
34113 }
34114 {
34115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34116 }
34117 return resultobj;
34118 fail:
34119 return NULL;
34120 }
34121
34122
34123 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34124 PyObject *obj;
34125 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34126 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34127 return SWIG_Py_Void();
34128 }
34129
34130 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34131 return SWIG_Python_InitShadowInstance(args);
34132 }
34133
34134 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34135 PyObject *resultobj = 0;
34136 wxDataObject *arg1 = (wxDataObject *) NULL ;
34137 wxPyDropTarget *result = 0 ;
34138 int res1 = 0 ;
34139 PyObject * obj0 = 0 ;
34140 char * kwnames[] = {
34141 (char *) "dataObject", NULL
34142 };
34143
34144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34145 if (obj0) {
34146 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34147 if (!SWIG_IsOK(res1)) {
34148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34149 }
34150 }
34151 {
34152 PyThreadState* __tstate = wxPyBeginAllowThreads();
34153 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34154 wxPyEndAllowThreads(__tstate);
34155 if (PyErr_Occurred()) SWIG_fail;
34156 }
34157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34158 return resultobj;
34159 fail:
34160 return NULL;
34161 }
34162
34163
34164 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34165 PyObject *resultobj = 0;
34166 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34167 PyObject *arg2 = (PyObject *) 0 ;
34168 PyObject *arg3 = (PyObject *) 0 ;
34169 void *argp1 = 0 ;
34170 int res1 = 0 ;
34171 PyObject * obj0 = 0 ;
34172 PyObject * obj1 = 0 ;
34173 PyObject * obj2 = 0 ;
34174 char * kwnames[] = {
34175 (char *) "self",(char *) "self",(char *) "_class", NULL
34176 };
34177
34178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34180 if (!SWIG_IsOK(res1)) {
34181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34182 }
34183 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34184 arg2 = obj1;
34185 arg3 = obj2;
34186 {
34187 PyThreadState* __tstate = wxPyBeginAllowThreads();
34188 (arg1)->_setCallbackInfo(arg2,arg3);
34189 wxPyEndAllowThreads(__tstate);
34190 if (PyErr_Occurred()) SWIG_fail;
34191 }
34192 resultobj = SWIG_Py_Void();
34193 return resultobj;
34194 fail:
34195 return NULL;
34196 }
34197
34198
34199 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34200 PyObject *resultobj = 0;
34201 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34202 void *argp1 = 0 ;
34203 int res1 = 0 ;
34204 PyObject *swig_obj[1] ;
34205
34206 if (!args) SWIG_fail;
34207 swig_obj[0] = args;
34208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34209 if (!SWIG_IsOK(res1)) {
34210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34211 }
34212 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34213 {
34214 PyThreadState* __tstate = wxPyBeginAllowThreads();
34215 delete arg1;
34216
34217 wxPyEndAllowThreads(__tstate);
34218 if (PyErr_Occurred()) SWIG_fail;
34219 }
34220 resultobj = SWIG_Py_Void();
34221 return resultobj;
34222 fail:
34223 return NULL;
34224 }
34225
34226
34227 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34228 PyObject *resultobj = 0;
34229 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34230 wxDataObject *result = 0 ;
34231 void *argp1 = 0 ;
34232 int res1 = 0 ;
34233 PyObject *swig_obj[1] ;
34234
34235 if (!args) SWIG_fail;
34236 swig_obj[0] = args;
34237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34238 if (!SWIG_IsOK(res1)) {
34239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34240 }
34241 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34242 {
34243 PyThreadState* __tstate = wxPyBeginAllowThreads();
34244 result = (wxDataObject *)(arg1)->GetDataObject();
34245 wxPyEndAllowThreads(__tstate);
34246 if (PyErr_Occurred()) SWIG_fail;
34247 }
34248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34249 return resultobj;
34250 fail:
34251 return NULL;
34252 }
34253
34254
34255 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34256 PyObject *resultobj = 0;
34257 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34258 wxDataObject *arg2 = (wxDataObject *) 0 ;
34259 void *argp1 = 0 ;
34260 int res1 = 0 ;
34261 int res2 = 0 ;
34262 PyObject * obj0 = 0 ;
34263 PyObject * obj1 = 0 ;
34264 char * kwnames[] = {
34265 (char *) "self",(char *) "dataObject", NULL
34266 };
34267
34268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34270 if (!SWIG_IsOK(res1)) {
34271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34272 }
34273 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34274 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34275 if (!SWIG_IsOK(res2)) {
34276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34277 }
34278 {
34279 PyThreadState* __tstate = wxPyBeginAllowThreads();
34280 (arg1)->SetDataObject(arg2);
34281 wxPyEndAllowThreads(__tstate);
34282 if (PyErr_Occurred()) SWIG_fail;
34283 }
34284 resultobj = SWIG_Py_Void();
34285 return resultobj;
34286 fail:
34287 return NULL;
34288 }
34289
34290
34291 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34292 PyObject *resultobj = 0;
34293 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34294 int arg2 ;
34295 int arg3 ;
34296 wxDragResult arg4 ;
34297 wxDragResult result;
34298 void *argp1 = 0 ;
34299 int res1 = 0 ;
34300 int val2 ;
34301 int ecode2 = 0 ;
34302 int val3 ;
34303 int ecode3 = 0 ;
34304 int val4 ;
34305 int ecode4 = 0 ;
34306 PyObject * obj0 = 0 ;
34307 PyObject * obj1 = 0 ;
34308 PyObject * obj2 = 0 ;
34309 PyObject * obj3 = 0 ;
34310 char * kwnames[] = {
34311 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34312 };
34313
34314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34316 if (!SWIG_IsOK(res1)) {
34317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34318 }
34319 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34320 ecode2 = SWIG_AsVal_int(obj1, &val2);
34321 if (!SWIG_IsOK(ecode2)) {
34322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34323 }
34324 arg2 = static_cast< int >(val2);
34325 ecode3 = SWIG_AsVal_int(obj2, &val3);
34326 if (!SWIG_IsOK(ecode3)) {
34327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34328 }
34329 arg3 = static_cast< int >(val3);
34330 ecode4 = SWIG_AsVal_int(obj3, &val4);
34331 if (!SWIG_IsOK(ecode4)) {
34332 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34333 }
34334 arg4 = static_cast< wxDragResult >(val4);
34335 {
34336 PyThreadState* __tstate = wxPyBeginAllowThreads();
34337 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34338 wxPyEndAllowThreads(__tstate);
34339 if (PyErr_Occurred()) SWIG_fail;
34340 }
34341 resultobj = SWIG_From_int(static_cast< int >(result));
34342 return resultobj;
34343 fail:
34344 return NULL;
34345 }
34346
34347
34348 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34349 PyObject *resultobj = 0;
34350 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34351 int arg2 ;
34352 int arg3 ;
34353 wxDragResult arg4 ;
34354 wxDragResult result;
34355 void *argp1 = 0 ;
34356 int res1 = 0 ;
34357 int val2 ;
34358 int ecode2 = 0 ;
34359 int val3 ;
34360 int ecode3 = 0 ;
34361 int val4 ;
34362 int ecode4 = 0 ;
34363 PyObject * obj0 = 0 ;
34364 PyObject * obj1 = 0 ;
34365 PyObject * obj2 = 0 ;
34366 PyObject * obj3 = 0 ;
34367 char * kwnames[] = {
34368 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34369 };
34370
34371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34373 if (!SWIG_IsOK(res1)) {
34374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34375 }
34376 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34377 ecode2 = SWIG_AsVal_int(obj1, &val2);
34378 if (!SWIG_IsOK(ecode2)) {
34379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34380 }
34381 arg2 = static_cast< int >(val2);
34382 ecode3 = SWIG_AsVal_int(obj2, &val3);
34383 if (!SWIG_IsOK(ecode3)) {
34384 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34385 }
34386 arg3 = static_cast< int >(val3);
34387 ecode4 = SWIG_AsVal_int(obj3, &val4);
34388 if (!SWIG_IsOK(ecode4)) {
34389 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34390 }
34391 arg4 = static_cast< wxDragResult >(val4);
34392 {
34393 PyThreadState* __tstate = wxPyBeginAllowThreads();
34394 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34395 wxPyEndAllowThreads(__tstate);
34396 if (PyErr_Occurred()) SWIG_fail;
34397 }
34398 resultobj = SWIG_From_int(static_cast< int >(result));
34399 return resultobj;
34400 fail:
34401 return NULL;
34402 }
34403
34404
34405 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34406 PyObject *resultobj = 0;
34407 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34408 void *argp1 = 0 ;
34409 int res1 = 0 ;
34410 PyObject *swig_obj[1] ;
34411
34412 if (!args) SWIG_fail;
34413 swig_obj[0] = args;
34414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34415 if (!SWIG_IsOK(res1)) {
34416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34417 }
34418 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34419 {
34420 PyThreadState* __tstate = wxPyBeginAllowThreads();
34421 (arg1)->OnLeave();
34422 wxPyEndAllowThreads(__tstate);
34423 if (PyErr_Occurred()) SWIG_fail;
34424 }
34425 resultobj = SWIG_Py_Void();
34426 return resultobj;
34427 fail:
34428 return NULL;
34429 }
34430
34431
34432 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34433 PyObject *resultobj = 0;
34434 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34435 int arg2 ;
34436 int arg3 ;
34437 bool result;
34438 void *argp1 = 0 ;
34439 int res1 = 0 ;
34440 int val2 ;
34441 int ecode2 = 0 ;
34442 int val3 ;
34443 int ecode3 = 0 ;
34444 PyObject * obj0 = 0 ;
34445 PyObject * obj1 = 0 ;
34446 PyObject * obj2 = 0 ;
34447 char * kwnames[] = {
34448 (char *) "self",(char *) "x",(char *) "y", NULL
34449 };
34450
34451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34453 if (!SWIG_IsOK(res1)) {
34454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34455 }
34456 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34457 ecode2 = SWIG_AsVal_int(obj1, &val2);
34458 if (!SWIG_IsOK(ecode2)) {
34459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34460 }
34461 arg2 = static_cast< int >(val2);
34462 ecode3 = SWIG_AsVal_int(obj2, &val3);
34463 if (!SWIG_IsOK(ecode3)) {
34464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34465 }
34466 arg3 = static_cast< int >(val3);
34467 {
34468 PyThreadState* __tstate = wxPyBeginAllowThreads();
34469 result = (bool)(arg1)->OnDrop(arg2,arg3);
34470 wxPyEndAllowThreads(__tstate);
34471 if (PyErr_Occurred()) SWIG_fail;
34472 }
34473 {
34474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34475 }
34476 return resultobj;
34477 fail:
34478 return NULL;
34479 }
34480
34481
34482 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34483 PyObject *resultobj = 0;
34484 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34485 bool result;
34486 void *argp1 = 0 ;
34487 int res1 = 0 ;
34488 PyObject *swig_obj[1] ;
34489
34490 if (!args) SWIG_fail;
34491 swig_obj[0] = args;
34492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34493 if (!SWIG_IsOK(res1)) {
34494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34495 }
34496 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34497 {
34498 PyThreadState* __tstate = wxPyBeginAllowThreads();
34499 result = (bool)(arg1)->GetData();
34500 wxPyEndAllowThreads(__tstate);
34501 if (PyErr_Occurred()) SWIG_fail;
34502 }
34503 {
34504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34505 }
34506 return resultobj;
34507 fail:
34508 return NULL;
34509 }
34510
34511
34512 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34513 PyObject *resultobj = 0;
34514 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34515 wxDragResult arg2 ;
34516 void *argp1 = 0 ;
34517 int res1 = 0 ;
34518 int val2 ;
34519 int ecode2 = 0 ;
34520 PyObject * obj0 = 0 ;
34521 PyObject * obj1 = 0 ;
34522 char * kwnames[] = {
34523 (char *) "self",(char *) "action", NULL
34524 };
34525
34526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34528 if (!SWIG_IsOK(res1)) {
34529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34530 }
34531 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34532 ecode2 = SWIG_AsVal_int(obj1, &val2);
34533 if (!SWIG_IsOK(ecode2)) {
34534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34535 }
34536 arg2 = static_cast< wxDragResult >(val2);
34537 {
34538 PyThreadState* __tstate = wxPyBeginAllowThreads();
34539 (arg1)->SetDefaultAction(arg2);
34540 wxPyEndAllowThreads(__tstate);
34541 if (PyErr_Occurred()) SWIG_fail;
34542 }
34543 resultobj = SWIG_Py_Void();
34544 return resultobj;
34545 fail:
34546 return NULL;
34547 }
34548
34549
34550 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34551 PyObject *resultobj = 0;
34552 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34553 wxDragResult result;
34554 void *argp1 = 0 ;
34555 int res1 = 0 ;
34556 PyObject *swig_obj[1] ;
34557
34558 if (!args) SWIG_fail;
34559 swig_obj[0] = args;
34560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34561 if (!SWIG_IsOK(res1)) {
34562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34563 }
34564 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34565 {
34566 PyThreadState* __tstate = wxPyBeginAllowThreads();
34567 result = (wxDragResult)(arg1)->GetDefaultAction();
34568 wxPyEndAllowThreads(__tstate);
34569 if (PyErr_Occurred()) SWIG_fail;
34570 }
34571 resultobj = SWIG_From_int(static_cast< int >(result));
34572 return resultobj;
34573 fail:
34574 return NULL;
34575 }
34576
34577
34578 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34579 PyObject *obj;
34580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34581 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34582 return SWIG_Py_Void();
34583 }
34584
34585 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34586 return SWIG_Python_InitShadowInstance(args);
34587 }
34588
34589 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34590 PyObject *resultobj = 0;
34591 wxPyTextDropTarget *result = 0 ;
34592
34593 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34594 {
34595 PyThreadState* __tstate = wxPyBeginAllowThreads();
34596 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34597 wxPyEndAllowThreads(__tstate);
34598 if (PyErr_Occurred()) SWIG_fail;
34599 }
34600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34601 return resultobj;
34602 fail:
34603 return NULL;
34604 }
34605
34606
34607 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34608 PyObject *resultobj = 0;
34609 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34610 PyObject *arg2 = (PyObject *) 0 ;
34611 PyObject *arg3 = (PyObject *) 0 ;
34612 void *argp1 = 0 ;
34613 int res1 = 0 ;
34614 PyObject * obj0 = 0 ;
34615 PyObject * obj1 = 0 ;
34616 PyObject * obj2 = 0 ;
34617 char * kwnames[] = {
34618 (char *) "self",(char *) "self",(char *) "_class", NULL
34619 };
34620
34621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34623 if (!SWIG_IsOK(res1)) {
34624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34625 }
34626 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34627 arg2 = obj1;
34628 arg3 = obj2;
34629 {
34630 PyThreadState* __tstate = wxPyBeginAllowThreads();
34631 (arg1)->_setCallbackInfo(arg2,arg3);
34632 wxPyEndAllowThreads(__tstate);
34633 if (PyErr_Occurred()) SWIG_fail;
34634 }
34635 resultobj = SWIG_Py_Void();
34636 return resultobj;
34637 fail:
34638 return NULL;
34639 }
34640
34641
34642 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34643 PyObject *resultobj = 0;
34644 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34645 int arg2 ;
34646 int arg3 ;
34647 wxString *arg4 = 0 ;
34648 bool result;
34649 void *argp1 = 0 ;
34650 int res1 = 0 ;
34651 int val2 ;
34652 int ecode2 = 0 ;
34653 int val3 ;
34654 int ecode3 = 0 ;
34655 bool temp4 = false ;
34656 PyObject * obj0 = 0 ;
34657 PyObject * obj1 = 0 ;
34658 PyObject * obj2 = 0 ;
34659 PyObject * obj3 = 0 ;
34660 char * kwnames[] = {
34661 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34662 };
34663
34664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34666 if (!SWIG_IsOK(res1)) {
34667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34668 }
34669 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34670 ecode2 = SWIG_AsVal_int(obj1, &val2);
34671 if (!SWIG_IsOK(ecode2)) {
34672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34673 }
34674 arg2 = static_cast< int >(val2);
34675 ecode3 = SWIG_AsVal_int(obj2, &val3);
34676 if (!SWIG_IsOK(ecode3)) {
34677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34678 }
34679 arg3 = static_cast< int >(val3);
34680 {
34681 arg4 = wxString_in_helper(obj3);
34682 if (arg4 == NULL) SWIG_fail;
34683 temp4 = true;
34684 }
34685 {
34686 PyThreadState* __tstate = wxPyBeginAllowThreads();
34687 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34688 wxPyEndAllowThreads(__tstate);
34689 if (PyErr_Occurred()) SWIG_fail;
34690 }
34691 {
34692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34693 }
34694 {
34695 if (temp4)
34696 delete arg4;
34697 }
34698 return resultobj;
34699 fail:
34700 {
34701 if (temp4)
34702 delete arg4;
34703 }
34704 return NULL;
34705 }
34706
34707
34708 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34709 PyObject *resultobj = 0;
34710 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34711 int arg2 ;
34712 int arg3 ;
34713 wxDragResult arg4 ;
34714 wxDragResult result;
34715 void *argp1 = 0 ;
34716 int res1 = 0 ;
34717 int val2 ;
34718 int ecode2 = 0 ;
34719 int val3 ;
34720 int ecode3 = 0 ;
34721 int val4 ;
34722 int ecode4 = 0 ;
34723 PyObject * obj0 = 0 ;
34724 PyObject * obj1 = 0 ;
34725 PyObject * obj2 = 0 ;
34726 PyObject * obj3 = 0 ;
34727 char * kwnames[] = {
34728 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34729 };
34730
34731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34733 if (!SWIG_IsOK(res1)) {
34734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34735 }
34736 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34737 ecode2 = SWIG_AsVal_int(obj1, &val2);
34738 if (!SWIG_IsOK(ecode2)) {
34739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34740 }
34741 arg2 = static_cast< int >(val2);
34742 ecode3 = SWIG_AsVal_int(obj2, &val3);
34743 if (!SWIG_IsOK(ecode3)) {
34744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34745 }
34746 arg3 = static_cast< int >(val3);
34747 ecode4 = SWIG_AsVal_int(obj3, &val4);
34748 if (!SWIG_IsOK(ecode4)) {
34749 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34750 }
34751 arg4 = static_cast< wxDragResult >(val4);
34752 {
34753 PyThreadState* __tstate = wxPyBeginAllowThreads();
34754 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34755 wxPyEndAllowThreads(__tstate);
34756 if (PyErr_Occurred()) SWIG_fail;
34757 }
34758 resultobj = SWIG_From_int(static_cast< int >(result));
34759 return resultobj;
34760 fail:
34761 return NULL;
34762 }
34763
34764
34765 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34766 PyObject *resultobj = 0;
34767 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34768 int arg2 ;
34769 int arg3 ;
34770 wxDragResult arg4 ;
34771 wxDragResult result;
34772 void *argp1 = 0 ;
34773 int res1 = 0 ;
34774 int val2 ;
34775 int ecode2 = 0 ;
34776 int val3 ;
34777 int ecode3 = 0 ;
34778 int val4 ;
34779 int ecode4 = 0 ;
34780 PyObject * obj0 = 0 ;
34781 PyObject * obj1 = 0 ;
34782 PyObject * obj2 = 0 ;
34783 PyObject * obj3 = 0 ;
34784 char * kwnames[] = {
34785 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34786 };
34787
34788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34790 if (!SWIG_IsOK(res1)) {
34791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34792 }
34793 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34794 ecode2 = SWIG_AsVal_int(obj1, &val2);
34795 if (!SWIG_IsOK(ecode2)) {
34796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34797 }
34798 arg2 = static_cast< int >(val2);
34799 ecode3 = SWIG_AsVal_int(obj2, &val3);
34800 if (!SWIG_IsOK(ecode3)) {
34801 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34802 }
34803 arg3 = static_cast< int >(val3);
34804 ecode4 = SWIG_AsVal_int(obj3, &val4);
34805 if (!SWIG_IsOK(ecode4)) {
34806 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34807 }
34808 arg4 = static_cast< wxDragResult >(val4);
34809 {
34810 PyThreadState* __tstate = wxPyBeginAllowThreads();
34811 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34812 wxPyEndAllowThreads(__tstate);
34813 if (PyErr_Occurred()) SWIG_fail;
34814 }
34815 resultobj = SWIG_From_int(static_cast< int >(result));
34816 return resultobj;
34817 fail:
34818 return NULL;
34819 }
34820
34821
34822 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34823 PyObject *resultobj = 0;
34824 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34825 void *argp1 = 0 ;
34826 int res1 = 0 ;
34827 PyObject *swig_obj[1] ;
34828
34829 if (!args) SWIG_fail;
34830 swig_obj[0] = args;
34831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34832 if (!SWIG_IsOK(res1)) {
34833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34834 }
34835 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34836 {
34837 PyThreadState* __tstate = wxPyBeginAllowThreads();
34838 (arg1)->OnLeave();
34839 wxPyEndAllowThreads(__tstate);
34840 if (PyErr_Occurred()) SWIG_fail;
34841 }
34842 resultobj = SWIG_Py_Void();
34843 return resultobj;
34844 fail:
34845 return NULL;
34846 }
34847
34848
34849 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34850 PyObject *resultobj = 0;
34851 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34852 int arg2 ;
34853 int arg3 ;
34854 bool result;
34855 void *argp1 = 0 ;
34856 int res1 = 0 ;
34857 int val2 ;
34858 int ecode2 = 0 ;
34859 int val3 ;
34860 int ecode3 = 0 ;
34861 PyObject * obj0 = 0 ;
34862 PyObject * obj1 = 0 ;
34863 PyObject * obj2 = 0 ;
34864 char * kwnames[] = {
34865 (char *) "self",(char *) "x",(char *) "y", NULL
34866 };
34867
34868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34870 if (!SWIG_IsOK(res1)) {
34871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34872 }
34873 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34874 ecode2 = SWIG_AsVal_int(obj1, &val2);
34875 if (!SWIG_IsOK(ecode2)) {
34876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34877 }
34878 arg2 = static_cast< int >(val2);
34879 ecode3 = SWIG_AsVal_int(obj2, &val3);
34880 if (!SWIG_IsOK(ecode3)) {
34881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34882 }
34883 arg3 = static_cast< int >(val3);
34884 {
34885 PyThreadState* __tstate = wxPyBeginAllowThreads();
34886 result = (bool)(arg1)->OnDrop(arg2,arg3);
34887 wxPyEndAllowThreads(__tstate);
34888 if (PyErr_Occurred()) SWIG_fail;
34889 }
34890 {
34891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34892 }
34893 return resultobj;
34894 fail:
34895 return NULL;
34896 }
34897
34898
34899 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34900 PyObject *resultobj = 0;
34901 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34902 int arg2 ;
34903 int arg3 ;
34904 wxDragResult arg4 ;
34905 wxDragResult result;
34906 void *argp1 = 0 ;
34907 int res1 = 0 ;
34908 int val2 ;
34909 int ecode2 = 0 ;
34910 int val3 ;
34911 int ecode3 = 0 ;
34912 int val4 ;
34913 int ecode4 = 0 ;
34914 PyObject * obj0 = 0 ;
34915 PyObject * obj1 = 0 ;
34916 PyObject * obj2 = 0 ;
34917 PyObject * obj3 = 0 ;
34918 char * kwnames[] = {
34919 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34920 };
34921
34922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34924 if (!SWIG_IsOK(res1)) {
34925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34926 }
34927 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34928 ecode2 = SWIG_AsVal_int(obj1, &val2);
34929 if (!SWIG_IsOK(ecode2)) {
34930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34931 }
34932 arg2 = static_cast< int >(val2);
34933 ecode3 = SWIG_AsVal_int(obj2, &val3);
34934 if (!SWIG_IsOK(ecode3)) {
34935 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34936 }
34937 arg3 = static_cast< int >(val3);
34938 ecode4 = SWIG_AsVal_int(obj3, &val4);
34939 if (!SWIG_IsOK(ecode4)) {
34940 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34941 }
34942 arg4 = static_cast< wxDragResult >(val4);
34943 {
34944 PyThreadState* __tstate = wxPyBeginAllowThreads();
34945 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34946 wxPyEndAllowThreads(__tstate);
34947 if (PyErr_Occurred()) SWIG_fail;
34948 }
34949 resultobj = SWIG_From_int(static_cast< int >(result));
34950 return resultobj;
34951 fail:
34952 return NULL;
34953 }
34954
34955
34956 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34957 PyObject *obj;
34958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34959 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34960 return SWIG_Py_Void();
34961 }
34962
34963 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34964 return SWIG_Python_InitShadowInstance(args);
34965 }
34966
34967 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34968 PyObject *resultobj = 0;
34969 wxPyFileDropTarget *result = 0 ;
34970
34971 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34972 {
34973 PyThreadState* __tstate = wxPyBeginAllowThreads();
34974 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34975 wxPyEndAllowThreads(__tstate);
34976 if (PyErr_Occurred()) SWIG_fail;
34977 }
34978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34979 return resultobj;
34980 fail:
34981 return NULL;
34982 }
34983
34984
34985 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34986 PyObject *resultobj = 0;
34987 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34988 PyObject *arg2 = (PyObject *) 0 ;
34989 PyObject *arg3 = (PyObject *) 0 ;
34990 void *argp1 = 0 ;
34991 int res1 = 0 ;
34992 PyObject * obj0 = 0 ;
34993 PyObject * obj1 = 0 ;
34994 PyObject * obj2 = 0 ;
34995 char * kwnames[] = {
34996 (char *) "self",(char *) "self",(char *) "_class", NULL
34997 };
34998
34999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35001 if (!SWIG_IsOK(res1)) {
35002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35003 }
35004 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35005 arg2 = obj1;
35006 arg3 = obj2;
35007 {
35008 PyThreadState* __tstate = wxPyBeginAllowThreads();
35009 (arg1)->_setCallbackInfo(arg2,arg3);
35010 wxPyEndAllowThreads(__tstate);
35011 if (PyErr_Occurred()) SWIG_fail;
35012 }
35013 resultobj = SWIG_Py_Void();
35014 return resultobj;
35015 fail:
35016 return NULL;
35017 }
35018
35019
35020 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35021 PyObject *resultobj = 0;
35022 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35023 int arg2 ;
35024 int arg3 ;
35025 wxArrayString *arg4 = 0 ;
35026 bool result;
35027 void *argp1 = 0 ;
35028 int res1 = 0 ;
35029 int val2 ;
35030 int ecode2 = 0 ;
35031 int val3 ;
35032 int ecode3 = 0 ;
35033 bool temp4 = false ;
35034 PyObject * obj0 = 0 ;
35035 PyObject * obj1 = 0 ;
35036 PyObject * obj2 = 0 ;
35037 PyObject * obj3 = 0 ;
35038 char * kwnames[] = {
35039 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
35040 };
35041
35042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35044 if (!SWIG_IsOK(res1)) {
35045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35046 }
35047 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35048 ecode2 = SWIG_AsVal_int(obj1, &val2);
35049 if (!SWIG_IsOK(ecode2)) {
35050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
35051 }
35052 arg2 = static_cast< int >(val2);
35053 ecode3 = SWIG_AsVal_int(obj2, &val3);
35054 if (!SWIG_IsOK(ecode3)) {
35055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
35056 }
35057 arg3 = static_cast< int >(val3);
35058 {
35059 if (! PySequence_Check(obj3)) {
35060 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
35061 SWIG_fail;
35062 }
35063 arg4 = new wxArrayString;
35064 temp4 = true;
35065 int i, len=PySequence_Length(obj3);
35066 for (i=0; i<len; i++) {
35067 PyObject* item = PySequence_GetItem(obj3, i);
35068 wxString* s = wxString_in_helper(item);
35069 if (PyErr_Occurred()) SWIG_fail;
35070 arg4->Add(*s);
35071 delete s;
35072 Py_DECREF(item);
35073 }
35074 }
35075 {
35076 PyThreadState* __tstate = wxPyBeginAllowThreads();
35077 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35078 wxPyEndAllowThreads(__tstate);
35079 if (PyErr_Occurred()) SWIG_fail;
35080 }
35081 {
35082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35083 }
35084 {
35085 if (temp4) delete arg4;
35086 }
35087 return resultobj;
35088 fail:
35089 {
35090 if (temp4) delete arg4;
35091 }
35092 return NULL;
35093 }
35094
35095
35096 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35097 PyObject *resultobj = 0;
35098 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35099 int arg2 ;
35100 int arg3 ;
35101 wxDragResult arg4 ;
35102 wxDragResult result;
35103 void *argp1 = 0 ;
35104 int res1 = 0 ;
35105 int val2 ;
35106 int ecode2 = 0 ;
35107 int val3 ;
35108 int ecode3 = 0 ;
35109 int val4 ;
35110 int ecode4 = 0 ;
35111 PyObject * obj0 = 0 ;
35112 PyObject * obj1 = 0 ;
35113 PyObject * obj2 = 0 ;
35114 PyObject * obj3 = 0 ;
35115 char * kwnames[] = {
35116 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35117 };
35118
35119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35121 if (!SWIG_IsOK(res1)) {
35122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35123 }
35124 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35125 ecode2 = SWIG_AsVal_int(obj1, &val2);
35126 if (!SWIG_IsOK(ecode2)) {
35127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35128 }
35129 arg2 = static_cast< int >(val2);
35130 ecode3 = SWIG_AsVal_int(obj2, &val3);
35131 if (!SWIG_IsOK(ecode3)) {
35132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35133 }
35134 arg3 = static_cast< int >(val3);
35135 ecode4 = SWIG_AsVal_int(obj3, &val4);
35136 if (!SWIG_IsOK(ecode4)) {
35137 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35138 }
35139 arg4 = static_cast< wxDragResult >(val4);
35140 {
35141 PyThreadState* __tstate = wxPyBeginAllowThreads();
35142 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35143 wxPyEndAllowThreads(__tstate);
35144 if (PyErr_Occurred()) SWIG_fail;
35145 }
35146 resultobj = SWIG_From_int(static_cast< int >(result));
35147 return resultobj;
35148 fail:
35149 return NULL;
35150 }
35151
35152
35153 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35154 PyObject *resultobj = 0;
35155 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35156 int arg2 ;
35157 int arg3 ;
35158 wxDragResult arg4 ;
35159 wxDragResult result;
35160 void *argp1 = 0 ;
35161 int res1 = 0 ;
35162 int val2 ;
35163 int ecode2 = 0 ;
35164 int val3 ;
35165 int ecode3 = 0 ;
35166 int val4 ;
35167 int ecode4 = 0 ;
35168 PyObject * obj0 = 0 ;
35169 PyObject * obj1 = 0 ;
35170 PyObject * obj2 = 0 ;
35171 PyObject * obj3 = 0 ;
35172 char * kwnames[] = {
35173 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35174 };
35175
35176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35178 if (!SWIG_IsOK(res1)) {
35179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35180 }
35181 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35182 ecode2 = SWIG_AsVal_int(obj1, &val2);
35183 if (!SWIG_IsOK(ecode2)) {
35184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35185 }
35186 arg2 = static_cast< int >(val2);
35187 ecode3 = SWIG_AsVal_int(obj2, &val3);
35188 if (!SWIG_IsOK(ecode3)) {
35189 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35190 }
35191 arg3 = static_cast< int >(val3);
35192 ecode4 = SWIG_AsVal_int(obj3, &val4);
35193 if (!SWIG_IsOK(ecode4)) {
35194 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35195 }
35196 arg4 = static_cast< wxDragResult >(val4);
35197 {
35198 PyThreadState* __tstate = wxPyBeginAllowThreads();
35199 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35200 wxPyEndAllowThreads(__tstate);
35201 if (PyErr_Occurred()) SWIG_fail;
35202 }
35203 resultobj = SWIG_From_int(static_cast< int >(result));
35204 return resultobj;
35205 fail:
35206 return NULL;
35207 }
35208
35209
35210 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35211 PyObject *resultobj = 0;
35212 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35213 void *argp1 = 0 ;
35214 int res1 = 0 ;
35215 PyObject *swig_obj[1] ;
35216
35217 if (!args) SWIG_fail;
35218 swig_obj[0] = args;
35219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35220 if (!SWIG_IsOK(res1)) {
35221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35222 }
35223 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35224 {
35225 PyThreadState* __tstate = wxPyBeginAllowThreads();
35226 (arg1)->OnLeave();
35227 wxPyEndAllowThreads(__tstate);
35228 if (PyErr_Occurred()) SWIG_fail;
35229 }
35230 resultobj = SWIG_Py_Void();
35231 return resultobj;
35232 fail:
35233 return NULL;
35234 }
35235
35236
35237 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35238 PyObject *resultobj = 0;
35239 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35240 int arg2 ;
35241 int arg3 ;
35242 bool result;
35243 void *argp1 = 0 ;
35244 int res1 = 0 ;
35245 int val2 ;
35246 int ecode2 = 0 ;
35247 int val3 ;
35248 int ecode3 = 0 ;
35249 PyObject * obj0 = 0 ;
35250 PyObject * obj1 = 0 ;
35251 PyObject * obj2 = 0 ;
35252 char * kwnames[] = {
35253 (char *) "self",(char *) "x",(char *) "y", NULL
35254 };
35255
35256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35258 if (!SWIG_IsOK(res1)) {
35259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35260 }
35261 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35262 ecode2 = SWIG_AsVal_int(obj1, &val2);
35263 if (!SWIG_IsOK(ecode2)) {
35264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35265 }
35266 arg2 = static_cast< int >(val2);
35267 ecode3 = SWIG_AsVal_int(obj2, &val3);
35268 if (!SWIG_IsOK(ecode3)) {
35269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35270 }
35271 arg3 = static_cast< int >(val3);
35272 {
35273 PyThreadState* __tstate = wxPyBeginAllowThreads();
35274 result = (bool)(arg1)->OnDrop(arg2,arg3);
35275 wxPyEndAllowThreads(__tstate);
35276 if (PyErr_Occurred()) SWIG_fail;
35277 }
35278 {
35279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35280 }
35281 return resultobj;
35282 fail:
35283 return NULL;
35284 }
35285
35286
35287 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35288 PyObject *resultobj = 0;
35289 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35290 int arg2 ;
35291 int arg3 ;
35292 wxDragResult arg4 ;
35293 wxDragResult result;
35294 void *argp1 = 0 ;
35295 int res1 = 0 ;
35296 int val2 ;
35297 int ecode2 = 0 ;
35298 int val3 ;
35299 int ecode3 = 0 ;
35300 int val4 ;
35301 int ecode4 = 0 ;
35302 PyObject * obj0 = 0 ;
35303 PyObject * obj1 = 0 ;
35304 PyObject * obj2 = 0 ;
35305 PyObject * obj3 = 0 ;
35306 char * kwnames[] = {
35307 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35308 };
35309
35310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35312 if (!SWIG_IsOK(res1)) {
35313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35314 }
35315 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35316 ecode2 = SWIG_AsVal_int(obj1, &val2);
35317 if (!SWIG_IsOK(ecode2)) {
35318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35319 }
35320 arg2 = static_cast< int >(val2);
35321 ecode3 = SWIG_AsVal_int(obj2, &val3);
35322 if (!SWIG_IsOK(ecode3)) {
35323 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35324 }
35325 arg3 = static_cast< int >(val3);
35326 ecode4 = SWIG_AsVal_int(obj3, &val4);
35327 if (!SWIG_IsOK(ecode4)) {
35328 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35329 }
35330 arg4 = static_cast< wxDragResult >(val4);
35331 {
35332 PyThreadState* __tstate = wxPyBeginAllowThreads();
35333 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35334 wxPyEndAllowThreads(__tstate);
35335 if (PyErr_Occurred()) SWIG_fail;
35336 }
35337 resultobj = SWIG_From_int(static_cast< int >(result));
35338 return resultobj;
35339 fail:
35340 return NULL;
35341 }
35342
35343
35344 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35345 PyObject *obj;
35346 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35347 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35348 return SWIG_Py_Void();
35349 }
35350
35351 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35352 return SWIG_Python_InitShadowInstance(args);
35353 }
35354
35355 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35356 PyObject *resultobj = 0;
35357 wxClipboard *result = 0 ;
35358
35359 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35360 {
35361 PyThreadState* __tstate = wxPyBeginAllowThreads();
35362 result = (wxClipboard *)new wxClipboard();
35363 wxPyEndAllowThreads(__tstate);
35364 if (PyErr_Occurred()) SWIG_fail;
35365 }
35366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35367 return resultobj;
35368 fail:
35369 return NULL;
35370 }
35371
35372
35373 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35374 PyObject *resultobj = 0;
35375 wxClipboard *arg1 = (wxClipboard *) 0 ;
35376 void *argp1 = 0 ;
35377 int res1 = 0 ;
35378 PyObject *swig_obj[1] ;
35379
35380 if (!args) SWIG_fail;
35381 swig_obj[0] = args;
35382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35383 if (!SWIG_IsOK(res1)) {
35384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35385 }
35386 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35387 {
35388 PyThreadState* __tstate = wxPyBeginAllowThreads();
35389 delete arg1;
35390
35391 wxPyEndAllowThreads(__tstate);
35392 if (PyErr_Occurred()) SWIG_fail;
35393 }
35394 resultobj = SWIG_Py_Void();
35395 return resultobj;
35396 fail:
35397 return NULL;
35398 }
35399
35400
35401 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35402 PyObject *resultobj = 0;
35403 wxClipboard *arg1 = (wxClipboard *) 0 ;
35404 bool result;
35405 void *argp1 = 0 ;
35406 int res1 = 0 ;
35407 PyObject *swig_obj[1] ;
35408
35409 if (!args) SWIG_fail;
35410 swig_obj[0] = args;
35411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35412 if (!SWIG_IsOK(res1)) {
35413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35414 }
35415 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35416 {
35417 PyThreadState* __tstate = wxPyBeginAllowThreads();
35418 result = (bool)(arg1)->Open();
35419 wxPyEndAllowThreads(__tstate);
35420 if (PyErr_Occurred()) SWIG_fail;
35421 }
35422 {
35423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35424 }
35425 return resultobj;
35426 fail:
35427 return NULL;
35428 }
35429
35430
35431 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35432 PyObject *resultobj = 0;
35433 wxClipboard *arg1 = (wxClipboard *) 0 ;
35434 void *argp1 = 0 ;
35435 int res1 = 0 ;
35436 PyObject *swig_obj[1] ;
35437
35438 if (!args) SWIG_fail;
35439 swig_obj[0] = args;
35440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35441 if (!SWIG_IsOK(res1)) {
35442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35443 }
35444 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35445 {
35446 PyThreadState* __tstate = wxPyBeginAllowThreads();
35447 (arg1)->Close();
35448 wxPyEndAllowThreads(__tstate);
35449 if (PyErr_Occurred()) SWIG_fail;
35450 }
35451 resultobj = SWIG_Py_Void();
35452 return resultobj;
35453 fail:
35454 return NULL;
35455 }
35456
35457
35458 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35459 PyObject *resultobj = 0;
35460 wxClipboard *arg1 = (wxClipboard *) 0 ;
35461 bool result;
35462 void *argp1 = 0 ;
35463 int res1 = 0 ;
35464 PyObject *swig_obj[1] ;
35465
35466 if (!args) SWIG_fail;
35467 swig_obj[0] = args;
35468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35469 if (!SWIG_IsOK(res1)) {
35470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35471 }
35472 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35473 {
35474 PyThreadState* __tstate = wxPyBeginAllowThreads();
35475 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35476 wxPyEndAllowThreads(__tstate);
35477 if (PyErr_Occurred()) SWIG_fail;
35478 }
35479 {
35480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35481 }
35482 return resultobj;
35483 fail:
35484 return NULL;
35485 }
35486
35487
35488 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35489 PyObject *resultobj = 0;
35490 wxClipboard *arg1 = (wxClipboard *) 0 ;
35491 wxDataObject *arg2 = (wxDataObject *) 0 ;
35492 bool result;
35493 void *argp1 = 0 ;
35494 int res1 = 0 ;
35495 int res2 = 0 ;
35496 PyObject * obj0 = 0 ;
35497 PyObject * obj1 = 0 ;
35498 char * kwnames[] = {
35499 (char *) "self",(char *) "data", NULL
35500 };
35501
35502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35504 if (!SWIG_IsOK(res1)) {
35505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35506 }
35507 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35508 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35509 if (!SWIG_IsOK(res2)) {
35510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35511 }
35512 {
35513 PyThreadState* __tstate = wxPyBeginAllowThreads();
35514 result = (bool)(arg1)->AddData(arg2);
35515 wxPyEndAllowThreads(__tstate);
35516 if (PyErr_Occurred()) SWIG_fail;
35517 }
35518 {
35519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35520 }
35521 return resultobj;
35522 fail:
35523 return NULL;
35524 }
35525
35526
35527 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35528 PyObject *resultobj = 0;
35529 wxClipboard *arg1 = (wxClipboard *) 0 ;
35530 wxDataObject *arg2 = (wxDataObject *) 0 ;
35531 bool result;
35532 void *argp1 = 0 ;
35533 int res1 = 0 ;
35534 int res2 = 0 ;
35535 PyObject * obj0 = 0 ;
35536 PyObject * obj1 = 0 ;
35537 char * kwnames[] = {
35538 (char *) "self",(char *) "data", NULL
35539 };
35540
35541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35543 if (!SWIG_IsOK(res1)) {
35544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35545 }
35546 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35547 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35548 if (!SWIG_IsOK(res2)) {
35549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35550 }
35551 {
35552 PyThreadState* __tstate = wxPyBeginAllowThreads();
35553 result = (bool)(arg1)->SetData(arg2);
35554 wxPyEndAllowThreads(__tstate);
35555 if (PyErr_Occurred()) SWIG_fail;
35556 }
35557 {
35558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35559 }
35560 return resultobj;
35561 fail:
35562 return NULL;
35563 }
35564
35565
35566 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35567 PyObject *resultobj = 0;
35568 wxClipboard *arg1 = (wxClipboard *) 0 ;
35569 wxDataFormat *arg2 = 0 ;
35570 bool result;
35571 void *argp1 = 0 ;
35572 int res1 = 0 ;
35573 void *argp2 = 0 ;
35574 int res2 = 0 ;
35575 PyObject * obj0 = 0 ;
35576 PyObject * obj1 = 0 ;
35577 char * kwnames[] = {
35578 (char *) "self",(char *) "format", NULL
35579 };
35580
35581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35583 if (!SWIG_IsOK(res1)) {
35584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35585 }
35586 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35587 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35588 if (!SWIG_IsOK(res2)) {
35589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35590 }
35591 if (!argp2) {
35592 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35593 }
35594 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35595 {
35596 PyThreadState* __tstate = wxPyBeginAllowThreads();
35597 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35598 wxPyEndAllowThreads(__tstate);
35599 if (PyErr_Occurred()) SWIG_fail;
35600 }
35601 {
35602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35603 }
35604 return resultobj;
35605 fail:
35606 return NULL;
35607 }
35608
35609
35610 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35611 PyObject *resultobj = 0;
35612 wxClipboard *arg1 = (wxClipboard *) 0 ;
35613 wxDataObject *arg2 = 0 ;
35614 bool result;
35615 void *argp1 = 0 ;
35616 int res1 = 0 ;
35617 void *argp2 = 0 ;
35618 int res2 = 0 ;
35619 PyObject * obj0 = 0 ;
35620 PyObject * obj1 = 0 ;
35621 char * kwnames[] = {
35622 (char *) "self",(char *) "data", NULL
35623 };
35624
35625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35627 if (!SWIG_IsOK(res1)) {
35628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35629 }
35630 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35631 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35632 if (!SWIG_IsOK(res2)) {
35633 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35634 }
35635 if (!argp2) {
35636 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35637 }
35638 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35639 {
35640 PyThreadState* __tstate = wxPyBeginAllowThreads();
35641 result = (bool)(arg1)->GetData(*arg2);
35642 wxPyEndAllowThreads(__tstate);
35643 if (PyErr_Occurred()) SWIG_fail;
35644 }
35645 {
35646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35647 }
35648 return resultobj;
35649 fail:
35650 return NULL;
35651 }
35652
35653
35654 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35655 PyObject *resultobj = 0;
35656 wxClipboard *arg1 = (wxClipboard *) 0 ;
35657 void *argp1 = 0 ;
35658 int res1 = 0 ;
35659 PyObject *swig_obj[1] ;
35660
35661 if (!args) SWIG_fail;
35662 swig_obj[0] = args;
35663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35664 if (!SWIG_IsOK(res1)) {
35665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35666 }
35667 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35668 {
35669 PyThreadState* __tstate = wxPyBeginAllowThreads();
35670 (arg1)->Clear();
35671 wxPyEndAllowThreads(__tstate);
35672 if (PyErr_Occurred()) SWIG_fail;
35673 }
35674 resultobj = SWIG_Py_Void();
35675 return resultobj;
35676 fail:
35677 return NULL;
35678 }
35679
35680
35681 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35682 PyObject *resultobj = 0;
35683 wxClipboard *arg1 = (wxClipboard *) 0 ;
35684 bool result;
35685 void *argp1 = 0 ;
35686 int res1 = 0 ;
35687 PyObject *swig_obj[1] ;
35688
35689 if (!args) SWIG_fail;
35690 swig_obj[0] = args;
35691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35692 if (!SWIG_IsOK(res1)) {
35693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35694 }
35695 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35696 {
35697 PyThreadState* __tstate = wxPyBeginAllowThreads();
35698 result = (bool)(arg1)->Flush();
35699 wxPyEndAllowThreads(__tstate);
35700 if (PyErr_Occurred()) SWIG_fail;
35701 }
35702 {
35703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35704 }
35705 return resultobj;
35706 fail:
35707 return NULL;
35708 }
35709
35710
35711 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35712 PyObject *resultobj = 0;
35713 wxClipboard *arg1 = (wxClipboard *) 0 ;
35714 bool arg2 = (bool) true ;
35715 void *argp1 = 0 ;
35716 int res1 = 0 ;
35717 bool val2 ;
35718 int ecode2 = 0 ;
35719 PyObject * obj0 = 0 ;
35720 PyObject * obj1 = 0 ;
35721 char * kwnames[] = {
35722 (char *) "self",(char *) "primary", NULL
35723 };
35724
35725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35727 if (!SWIG_IsOK(res1)) {
35728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35729 }
35730 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35731 if (obj1) {
35732 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35733 if (!SWIG_IsOK(ecode2)) {
35734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35735 }
35736 arg2 = static_cast< bool >(val2);
35737 }
35738 {
35739 PyThreadState* __tstate = wxPyBeginAllowThreads();
35740 (arg1)->UsePrimarySelection(arg2);
35741 wxPyEndAllowThreads(__tstate);
35742 if (PyErr_Occurred()) SWIG_fail;
35743 }
35744 resultobj = SWIG_Py_Void();
35745 return resultobj;
35746 fail:
35747 return NULL;
35748 }
35749
35750
35751 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35752 PyObject *resultobj = 0;
35753 wxClipboard *result = 0 ;
35754
35755 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35756 {
35757 PyThreadState* __tstate = wxPyBeginAllowThreads();
35758 result = (wxClipboard *)wxClipboard::Get();
35759 wxPyEndAllowThreads(__tstate);
35760 if (PyErr_Occurred()) SWIG_fail;
35761 }
35762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35763 return resultobj;
35764 fail:
35765 return NULL;
35766 }
35767
35768
35769 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35770 PyObject *obj;
35771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35772 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35773 return SWIG_Py_Void();
35774 }
35775
35776 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35777 return SWIG_Python_InitShadowInstance(args);
35778 }
35779
35780 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35781 PyObject *resultobj = 0;
35782 wxClipboard *arg1 = (wxClipboard *) NULL ;
35783 wxClipboardLocker *result = 0 ;
35784 void *argp1 = 0 ;
35785 int res1 = 0 ;
35786 PyObject * obj0 = 0 ;
35787 char * kwnames[] = {
35788 (char *) "clipboard", NULL
35789 };
35790
35791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35792 if (obj0) {
35793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35794 if (!SWIG_IsOK(res1)) {
35795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35796 }
35797 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35798 }
35799 {
35800 PyThreadState* __tstate = wxPyBeginAllowThreads();
35801 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35802 wxPyEndAllowThreads(__tstate);
35803 if (PyErr_Occurred()) SWIG_fail;
35804 }
35805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35806 return resultobj;
35807 fail:
35808 return NULL;
35809 }
35810
35811
35812 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35813 PyObject *resultobj = 0;
35814 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35815 void *argp1 = 0 ;
35816 int res1 = 0 ;
35817 PyObject *swig_obj[1] ;
35818
35819 if (!args) SWIG_fail;
35820 swig_obj[0] = args;
35821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35822 if (!SWIG_IsOK(res1)) {
35823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35824 }
35825 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35826 {
35827 PyThreadState* __tstate = wxPyBeginAllowThreads();
35828 delete arg1;
35829
35830 wxPyEndAllowThreads(__tstate);
35831 if (PyErr_Occurred()) SWIG_fail;
35832 }
35833 resultobj = SWIG_Py_Void();
35834 return resultobj;
35835 fail:
35836 return NULL;
35837 }
35838
35839
35840 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35841 PyObject *resultobj = 0;
35842 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35843 bool result;
35844 void *argp1 = 0 ;
35845 int res1 = 0 ;
35846 PyObject *swig_obj[1] ;
35847
35848 if (!args) SWIG_fail;
35849 swig_obj[0] = args;
35850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35851 if (!SWIG_IsOK(res1)) {
35852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35853 }
35854 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35855 {
35856 PyThreadState* __tstate = wxPyBeginAllowThreads();
35857 result = (bool)wxClipboardLocker___nonzero__(arg1);
35858 wxPyEndAllowThreads(__tstate);
35859 if (PyErr_Occurred()) SWIG_fail;
35860 }
35861 {
35862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35863 }
35864 return resultobj;
35865 fail:
35866 return NULL;
35867 }
35868
35869
35870 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35871 PyObject *obj;
35872 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35873 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35874 return SWIG_Py_Void();
35875 }
35876
35877 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35878 return SWIG_Python_InitShadowInstance(args);
35879 }
35880
35881 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35882 PyObject *resultobj = 0;
35883 int arg1 = (int) 0 ;
35884 int arg2 = (int) 0 ;
35885 int arg3 = (int) 0 ;
35886 int arg4 = (int) 0 ;
35887 wxVideoMode *result = 0 ;
35888 int val1 ;
35889 int ecode1 = 0 ;
35890 int val2 ;
35891 int ecode2 = 0 ;
35892 int val3 ;
35893 int ecode3 = 0 ;
35894 int val4 ;
35895 int ecode4 = 0 ;
35896 PyObject * obj0 = 0 ;
35897 PyObject * obj1 = 0 ;
35898 PyObject * obj2 = 0 ;
35899 PyObject * obj3 = 0 ;
35900 char * kwnames[] = {
35901 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35902 };
35903
35904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35905 if (obj0) {
35906 ecode1 = SWIG_AsVal_int(obj0, &val1);
35907 if (!SWIG_IsOK(ecode1)) {
35908 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35909 }
35910 arg1 = static_cast< int >(val1);
35911 }
35912 if (obj1) {
35913 ecode2 = SWIG_AsVal_int(obj1, &val2);
35914 if (!SWIG_IsOK(ecode2)) {
35915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35916 }
35917 arg2 = static_cast< int >(val2);
35918 }
35919 if (obj2) {
35920 ecode3 = SWIG_AsVal_int(obj2, &val3);
35921 if (!SWIG_IsOK(ecode3)) {
35922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35923 }
35924 arg3 = static_cast< int >(val3);
35925 }
35926 if (obj3) {
35927 ecode4 = SWIG_AsVal_int(obj3, &val4);
35928 if (!SWIG_IsOK(ecode4)) {
35929 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35930 }
35931 arg4 = static_cast< int >(val4);
35932 }
35933 {
35934 PyThreadState* __tstate = wxPyBeginAllowThreads();
35935 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35936 wxPyEndAllowThreads(__tstate);
35937 if (PyErr_Occurred()) SWIG_fail;
35938 }
35939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35940 return resultobj;
35941 fail:
35942 return NULL;
35943 }
35944
35945
35946 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35947 PyObject *resultobj = 0;
35948 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35949 void *argp1 = 0 ;
35950 int res1 = 0 ;
35951 PyObject *swig_obj[1] ;
35952
35953 if (!args) SWIG_fail;
35954 swig_obj[0] = args;
35955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35956 if (!SWIG_IsOK(res1)) {
35957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35958 }
35959 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35960 {
35961 PyThreadState* __tstate = wxPyBeginAllowThreads();
35962 delete arg1;
35963
35964 wxPyEndAllowThreads(__tstate);
35965 if (PyErr_Occurred()) SWIG_fail;
35966 }
35967 resultobj = SWIG_Py_Void();
35968 return resultobj;
35969 fail:
35970 return NULL;
35971 }
35972
35973
35974 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35975 PyObject *resultobj = 0;
35976 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35977 wxVideoMode *arg2 = 0 ;
35978 bool result;
35979 void *argp1 = 0 ;
35980 int res1 = 0 ;
35981 void *argp2 = 0 ;
35982 int res2 = 0 ;
35983 PyObject * obj0 = 0 ;
35984 PyObject * obj1 = 0 ;
35985 char * kwnames[] = {
35986 (char *) "self",(char *) "other", NULL
35987 };
35988
35989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35991 if (!SWIG_IsOK(res1)) {
35992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35993 }
35994 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35995 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35996 if (!SWIG_IsOK(res2)) {
35997 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35998 }
35999 if (!argp2) {
36000 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36001 }
36002 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36003 {
36004 PyThreadState* __tstate = wxPyBeginAllowThreads();
36005 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
36006 wxPyEndAllowThreads(__tstate);
36007 if (PyErr_Occurred()) SWIG_fail;
36008 }
36009 {
36010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36011 }
36012 return resultobj;
36013 fail:
36014 return NULL;
36015 }
36016
36017
36018 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36019 PyObject *resultobj = 0;
36020 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36021 int result;
36022 void *argp1 = 0 ;
36023 int res1 = 0 ;
36024 PyObject *swig_obj[1] ;
36025
36026 if (!args) SWIG_fail;
36027 swig_obj[0] = args;
36028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36029 if (!SWIG_IsOK(res1)) {
36030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36031 }
36032 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36033 {
36034 PyThreadState* __tstate = wxPyBeginAllowThreads();
36035 result = (int)((wxVideoMode const *)arg1)->GetWidth();
36036 wxPyEndAllowThreads(__tstate);
36037 if (PyErr_Occurred()) SWIG_fail;
36038 }
36039 resultobj = SWIG_From_int(static_cast< int >(result));
36040 return resultobj;
36041 fail:
36042 return NULL;
36043 }
36044
36045
36046 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36047 PyObject *resultobj = 0;
36048 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36049 int result;
36050 void *argp1 = 0 ;
36051 int res1 = 0 ;
36052 PyObject *swig_obj[1] ;
36053
36054 if (!args) SWIG_fail;
36055 swig_obj[0] = args;
36056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36057 if (!SWIG_IsOK(res1)) {
36058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36059 }
36060 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36061 {
36062 PyThreadState* __tstate = wxPyBeginAllowThreads();
36063 result = (int)((wxVideoMode const *)arg1)->GetHeight();
36064 wxPyEndAllowThreads(__tstate);
36065 if (PyErr_Occurred()) SWIG_fail;
36066 }
36067 resultobj = SWIG_From_int(static_cast< int >(result));
36068 return resultobj;
36069 fail:
36070 return NULL;
36071 }
36072
36073
36074 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36075 PyObject *resultobj = 0;
36076 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36077 int result;
36078 void *argp1 = 0 ;
36079 int res1 = 0 ;
36080 PyObject *swig_obj[1] ;
36081
36082 if (!args) SWIG_fail;
36083 swig_obj[0] = args;
36084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36085 if (!SWIG_IsOK(res1)) {
36086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36087 }
36088 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36089 {
36090 PyThreadState* __tstate = wxPyBeginAllowThreads();
36091 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36092 wxPyEndAllowThreads(__tstate);
36093 if (PyErr_Occurred()) SWIG_fail;
36094 }
36095 resultobj = SWIG_From_int(static_cast< int >(result));
36096 return resultobj;
36097 fail:
36098 return NULL;
36099 }
36100
36101
36102 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36103 PyObject *resultobj = 0;
36104 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36105 bool result;
36106 void *argp1 = 0 ;
36107 int res1 = 0 ;
36108 PyObject *swig_obj[1] ;
36109
36110 if (!args) SWIG_fail;
36111 swig_obj[0] = args;
36112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36113 if (!SWIG_IsOK(res1)) {
36114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36115 }
36116 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36117 {
36118 PyThreadState* __tstate = wxPyBeginAllowThreads();
36119 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36120 wxPyEndAllowThreads(__tstate);
36121 if (PyErr_Occurred()) SWIG_fail;
36122 }
36123 {
36124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36125 }
36126 return resultobj;
36127 fail:
36128 return NULL;
36129 }
36130
36131
36132 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36133 PyObject *resultobj = 0;
36134 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36135 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36136 bool result;
36137 void *argp1 = 0 ;
36138 int res1 = 0 ;
36139 void *argp2 = 0 ;
36140 int res2 = 0 ;
36141 PyObject * obj0 = 0 ;
36142 PyObject * obj1 = 0 ;
36143 char * kwnames[] = {
36144 (char *) "self",(char *) "other", NULL
36145 };
36146
36147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36149 if (!SWIG_IsOK(res1)) {
36150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36151 }
36152 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36154 if (!SWIG_IsOK(res2)) {
36155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36156 }
36157 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36158 {
36159 PyThreadState* __tstate = wxPyBeginAllowThreads();
36160 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36161 wxPyEndAllowThreads(__tstate);
36162 if (PyErr_Occurred()) SWIG_fail;
36163 }
36164 {
36165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36166 }
36167 return resultobj;
36168 fail:
36169 return NULL;
36170 }
36171
36172
36173 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36174 PyObject *resultobj = 0;
36175 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36176 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36177 bool result;
36178 void *argp1 = 0 ;
36179 int res1 = 0 ;
36180 void *argp2 = 0 ;
36181 int res2 = 0 ;
36182 PyObject * obj0 = 0 ;
36183 PyObject * obj1 = 0 ;
36184 char * kwnames[] = {
36185 (char *) "self",(char *) "other", NULL
36186 };
36187
36188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36190 if (!SWIG_IsOK(res1)) {
36191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36192 }
36193 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36194 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36195 if (!SWIG_IsOK(res2)) {
36196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36197 }
36198 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36199 {
36200 PyThreadState* __tstate = wxPyBeginAllowThreads();
36201 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36202 wxPyEndAllowThreads(__tstate);
36203 if (PyErr_Occurred()) SWIG_fail;
36204 }
36205 {
36206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36207 }
36208 return resultobj;
36209 fail:
36210 return NULL;
36211 }
36212
36213
36214 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36215 PyObject *resultobj = 0;
36216 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36217 int arg2 ;
36218 void *argp1 = 0 ;
36219 int res1 = 0 ;
36220 int val2 ;
36221 int ecode2 = 0 ;
36222 PyObject *swig_obj[2] ;
36223
36224 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36226 if (!SWIG_IsOK(res1)) {
36227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36228 }
36229 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36230 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36231 if (!SWIG_IsOK(ecode2)) {
36232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36233 }
36234 arg2 = static_cast< int >(val2);
36235 if (arg1) (arg1)->w = arg2;
36236
36237 resultobj = SWIG_Py_Void();
36238 return resultobj;
36239 fail:
36240 return NULL;
36241 }
36242
36243
36244 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36245 PyObject *resultobj = 0;
36246 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36247 int result;
36248 void *argp1 = 0 ;
36249 int res1 = 0 ;
36250 PyObject *swig_obj[1] ;
36251
36252 if (!args) SWIG_fail;
36253 swig_obj[0] = args;
36254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36255 if (!SWIG_IsOK(res1)) {
36256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36257 }
36258 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36259 result = (int) ((arg1)->w);
36260 resultobj = SWIG_From_int(static_cast< int >(result));
36261 return resultobj;
36262 fail:
36263 return NULL;
36264 }
36265
36266
36267 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36268 PyObject *resultobj = 0;
36269 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36270 int arg2 ;
36271 void *argp1 = 0 ;
36272 int res1 = 0 ;
36273 int val2 ;
36274 int ecode2 = 0 ;
36275 PyObject *swig_obj[2] ;
36276
36277 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36279 if (!SWIG_IsOK(res1)) {
36280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36281 }
36282 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36283 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36284 if (!SWIG_IsOK(ecode2)) {
36285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36286 }
36287 arg2 = static_cast< int >(val2);
36288 if (arg1) (arg1)->h = arg2;
36289
36290 resultobj = SWIG_Py_Void();
36291 return resultobj;
36292 fail:
36293 return NULL;
36294 }
36295
36296
36297 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36298 PyObject *resultobj = 0;
36299 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36300 int result;
36301 void *argp1 = 0 ;
36302 int res1 = 0 ;
36303 PyObject *swig_obj[1] ;
36304
36305 if (!args) SWIG_fail;
36306 swig_obj[0] = args;
36307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36308 if (!SWIG_IsOK(res1)) {
36309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36310 }
36311 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36312 result = (int) ((arg1)->h);
36313 resultobj = SWIG_From_int(static_cast< int >(result));
36314 return resultobj;
36315 fail:
36316 return NULL;
36317 }
36318
36319
36320 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36321 PyObject *resultobj = 0;
36322 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36323 int arg2 ;
36324 void *argp1 = 0 ;
36325 int res1 = 0 ;
36326 int val2 ;
36327 int ecode2 = 0 ;
36328 PyObject *swig_obj[2] ;
36329
36330 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36332 if (!SWIG_IsOK(res1)) {
36333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36334 }
36335 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36336 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36337 if (!SWIG_IsOK(ecode2)) {
36338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36339 }
36340 arg2 = static_cast< int >(val2);
36341 if (arg1) (arg1)->bpp = arg2;
36342
36343 resultobj = SWIG_Py_Void();
36344 return resultobj;
36345 fail:
36346 return NULL;
36347 }
36348
36349
36350 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36351 PyObject *resultobj = 0;
36352 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36353 int result;
36354 void *argp1 = 0 ;
36355 int res1 = 0 ;
36356 PyObject *swig_obj[1] ;
36357
36358 if (!args) SWIG_fail;
36359 swig_obj[0] = args;
36360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36361 if (!SWIG_IsOK(res1)) {
36362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36363 }
36364 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36365 result = (int) ((arg1)->bpp);
36366 resultobj = SWIG_From_int(static_cast< int >(result));
36367 return resultobj;
36368 fail:
36369 return NULL;
36370 }
36371
36372
36373 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36374 PyObject *resultobj = 0;
36375 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36376 int arg2 ;
36377 void *argp1 = 0 ;
36378 int res1 = 0 ;
36379 int val2 ;
36380 int ecode2 = 0 ;
36381 PyObject *swig_obj[2] ;
36382
36383 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36385 if (!SWIG_IsOK(res1)) {
36386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36387 }
36388 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36389 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36390 if (!SWIG_IsOK(ecode2)) {
36391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36392 }
36393 arg2 = static_cast< int >(val2);
36394 if (arg1) (arg1)->refresh = arg2;
36395
36396 resultobj = SWIG_Py_Void();
36397 return resultobj;
36398 fail:
36399 return NULL;
36400 }
36401
36402
36403 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36404 PyObject *resultobj = 0;
36405 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36406 int result;
36407 void *argp1 = 0 ;
36408 int res1 = 0 ;
36409 PyObject *swig_obj[1] ;
36410
36411 if (!args) SWIG_fail;
36412 swig_obj[0] = args;
36413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36414 if (!SWIG_IsOK(res1)) {
36415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36416 }
36417 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36418 result = (int) ((arg1)->refresh);
36419 resultobj = SWIG_From_int(static_cast< int >(result));
36420 return resultobj;
36421 fail:
36422 return NULL;
36423 }
36424
36425
36426 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36427 PyObject *obj;
36428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36429 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36430 return SWIG_Py_Void();
36431 }
36432
36433 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36434 return SWIG_Python_InitShadowInstance(args);
36435 }
36436
36437 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36438 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36439 return 1;
36440 }
36441
36442
36443 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36444 PyObject *pyobj = 0;
36445
36446 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36447 return pyobj;
36448 }
36449
36450
36451 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36452 PyObject *resultobj = 0;
36453 unsigned int arg1 = (unsigned int) 0 ;
36454 wxDisplay *result = 0 ;
36455 unsigned int val1 ;
36456 int ecode1 = 0 ;
36457 PyObject * obj0 = 0 ;
36458 char * kwnames[] = {
36459 (char *) "index", NULL
36460 };
36461
36462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36463 if (obj0) {
36464 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36465 if (!SWIG_IsOK(ecode1)) {
36466 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36467 }
36468 arg1 = static_cast< unsigned int >(val1);
36469 }
36470 {
36471 PyThreadState* __tstate = wxPyBeginAllowThreads();
36472 result = (wxDisplay *)new wxDisplay(arg1);
36473 wxPyEndAllowThreads(__tstate);
36474 if (PyErr_Occurred()) SWIG_fail;
36475 }
36476 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36477 return resultobj;
36478 fail:
36479 return NULL;
36480 }
36481
36482
36483 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36484 PyObject *resultobj = 0;
36485 wxDisplay *arg1 = (wxDisplay *) 0 ;
36486 void *argp1 = 0 ;
36487 int res1 = 0 ;
36488 PyObject *swig_obj[1] ;
36489
36490 if (!args) SWIG_fail;
36491 swig_obj[0] = args;
36492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36493 if (!SWIG_IsOK(res1)) {
36494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36495 }
36496 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36497 {
36498 PyThreadState* __tstate = wxPyBeginAllowThreads();
36499 delete arg1;
36500
36501 wxPyEndAllowThreads(__tstate);
36502 if (PyErr_Occurred()) SWIG_fail;
36503 }
36504 resultobj = SWIG_Py_Void();
36505 return resultobj;
36506 fail:
36507 return NULL;
36508 }
36509
36510
36511 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36512 PyObject *resultobj = 0;
36513 unsigned int result;
36514
36515 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36516 {
36517 PyThreadState* __tstate = wxPyBeginAllowThreads();
36518 result = (unsigned int)wxDisplay::GetCount();
36519 wxPyEndAllowThreads(__tstate);
36520 if (PyErr_Occurred()) SWIG_fail;
36521 }
36522 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36523 return resultobj;
36524 fail:
36525 return NULL;
36526 }
36527
36528
36529 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36530 PyObject *resultobj = 0;
36531 wxPoint *arg1 = 0 ;
36532 int result;
36533 wxPoint temp1 ;
36534 PyObject * obj0 = 0 ;
36535 char * kwnames[] = {
36536 (char *) "pt", NULL
36537 };
36538
36539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36540 {
36541 arg1 = &temp1;
36542 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36543 }
36544 {
36545 PyThreadState* __tstate = wxPyBeginAllowThreads();
36546 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36547 wxPyEndAllowThreads(__tstate);
36548 if (PyErr_Occurred()) SWIG_fail;
36549 }
36550 resultobj = SWIG_From_int(static_cast< int >(result));
36551 return resultobj;
36552 fail:
36553 return NULL;
36554 }
36555
36556
36557 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36558 PyObject *resultobj = 0;
36559 wxWindow *arg1 = (wxWindow *) 0 ;
36560 int result;
36561 void *argp1 = 0 ;
36562 int res1 = 0 ;
36563 PyObject * obj0 = 0 ;
36564 char * kwnames[] = {
36565 (char *) "window", NULL
36566 };
36567
36568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36570 if (!SWIG_IsOK(res1)) {
36571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36572 }
36573 arg1 = reinterpret_cast< wxWindow * >(argp1);
36574 {
36575 PyThreadState* __tstate = wxPyBeginAllowThreads();
36576 result = (int)wxDisplay::GetFromWindow(arg1);
36577 wxPyEndAllowThreads(__tstate);
36578 if (PyErr_Occurred()) SWIG_fail;
36579 }
36580 resultobj = SWIG_From_int(static_cast< int >(result));
36581 return resultobj;
36582 fail:
36583 return NULL;
36584 }
36585
36586
36587 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36588 PyObject *resultobj = 0;
36589 wxDisplay *arg1 = (wxDisplay *) 0 ;
36590 bool result;
36591 void *argp1 = 0 ;
36592 int res1 = 0 ;
36593 PyObject *swig_obj[1] ;
36594
36595 if (!args) SWIG_fail;
36596 swig_obj[0] = args;
36597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36598 if (!SWIG_IsOK(res1)) {
36599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36600 }
36601 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36602 {
36603 PyThreadState* __tstate = wxPyBeginAllowThreads();
36604 result = (bool)((wxDisplay const *)arg1)->IsOk();
36605 wxPyEndAllowThreads(__tstate);
36606 if (PyErr_Occurred()) SWIG_fail;
36607 }
36608 {
36609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36610 }
36611 return resultobj;
36612 fail:
36613 return NULL;
36614 }
36615
36616
36617 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36618 PyObject *resultobj = 0;
36619 wxDisplay *arg1 = (wxDisplay *) 0 ;
36620 wxRect result;
36621 void *argp1 = 0 ;
36622 int res1 = 0 ;
36623 PyObject *swig_obj[1] ;
36624
36625 if (!args) SWIG_fail;
36626 swig_obj[0] = args;
36627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36628 if (!SWIG_IsOK(res1)) {
36629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36630 }
36631 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36632 {
36633 PyThreadState* __tstate = wxPyBeginAllowThreads();
36634 result = ((wxDisplay const *)arg1)->GetGeometry();
36635 wxPyEndAllowThreads(__tstate);
36636 if (PyErr_Occurred()) SWIG_fail;
36637 }
36638 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36639 return resultobj;
36640 fail:
36641 return NULL;
36642 }
36643
36644
36645 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36646 PyObject *resultobj = 0;
36647 wxDisplay *arg1 = (wxDisplay *) 0 ;
36648 wxRect result;
36649 void *argp1 = 0 ;
36650 int res1 = 0 ;
36651 PyObject *swig_obj[1] ;
36652
36653 if (!args) SWIG_fail;
36654 swig_obj[0] = args;
36655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36656 if (!SWIG_IsOK(res1)) {
36657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36658 }
36659 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36660 {
36661 PyThreadState* __tstate = wxPyBeginAllowThreads();
36662 result = ((wxDisplay const *)arg1)->GetClientArea();
36663 wxPyEndAllowThreads(__tstate);
36664 if (PyErr_Occurred()) SWIG_fail;
36665 }
36666 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36667 return resultobj;
36668 fail:
36669 return NULL;
36670 }
36671
36672
36673 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36674 PyObject *resultobj = 0;
36675 wxDisplay *arg1 = (wxDisplay *) 0 ;
36676 wxString result;
36677 void *argp1 = 0 ;
36678 int res1 = 0 ;
36679 PyObject *swig_obj[1] ;
36680
36681 if (!args) SWIG_fail;
36682 swig_obj[0] = args;
36683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36684 if (!SWIG_IsOK(res1)) {
36685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36686 }
36687 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36688 {
36689 PyThreadState* __tstate = wxPyBeginAllowThreads();
36690 result = ((wxDisplay const *)arg1)->GetName();
36691 wxPyEndAllowThreads(__tstate);
36692 if (PyErr_Occurred()) SWIG_fail;
36693 }
36694 {
36695 #if wxUSE_UNICODE
36696 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36697 #else
36698 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36699 #endif
36700 }
36701 return resultobj;
36702 fail:
36703 return NULL;
36704 }
36705
36706
36707 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36708 PyObject *resultobj = 0;
36709 wxDisplay *arg1 = (wxDisplay *) 0 ;
36710 bool result;
36711 void *argp1 = 0 ;
36712 int res1 = 0 ;
36713 PyObject *swig_obj[1] ;
36714
36715 if (!args) SWIG_fail;
36716 swig_obj[0] = args;
36717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36718 if (!SWIG_IsOK(res1)) {
36719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36720 }
36721 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36722 {
36723 PyThreadState* __tstate = wxPyBeginAllowThreads();
36724 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36725 wxPyEndAllowThreads(__tstate);
36726 if (PyErr_Occurred()) SWIG_fail;
36727 }
36728 {
36729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36730 }
36731 return resultobj;
36732 fail:
36733 return NULL;
36734 }
36735
36736
36737 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36738 PyObject *resultobj = 0;
36739 wxDisplay *arg1 = (wxDisplay *) 0 ;
36740 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36741 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36742 PyObject *result = 0 ;
36743 void *argp1 = 0 ;
36744 int res1 = 0 ;
36745 void *argp2 = 0 ;
36746 int res2 = 0 ;
36747 PyObject * obj0 = 0 ;
36748 PyObject * obj1 = 0 ;
36749 char * kwnames[] = {
36750 (char *) "self",(char *) "mode", NULL
36751 };
36752
36753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36755 if (!SWIG_IsOK(res1)) {
36756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36757 }
36758 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36759 if (obj1) {
36760 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36761 if (!SWIG_IsOK(res2)) {
36762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36763 }
36764 if (!argp2) {
36765 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36766 }
36767 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36768 }
36769 {
36770 PyThreadState* __tstate = wxPyBeginAllowThreads();
36771 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36772 wxPyEndAllowThreads(__tstate);
36773 if (PyErr_Occurred()) SWIG_fail;
36774 }
36775 resultobj = result;
36776 return resultobj;
36777 fail:
36778 return NULL;
36779 }
36780
36781
36782 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36783 PyObject *resultobj = 0;
36784 wxDisplay *arg1 = (wxDisplay *) 0 ;
36785 wxVideoMode result;
36786 void *argp1 = 0 ;
36787 int res1 = 0 ;
36788 PyObject *swig_obj[1] ;
36789
36790 if (!args) SWIG_fail;
36791 swig_obj[0] = args;
36792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36793 if (!SWIG_IsOK(res1)) {
36794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36795 }
36796 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36797 {
36798 PyThreadState* __tstate = wxPyBeginAllowThreads();
36799 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36800 wxPyEndAllowThreads(__tstate);
36801 if (PyErr_Occurred()) SWIG_fail;
36802 }
36803 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36804 return resultobj;
36805 fail:
36806 return NULL;
36807 }
36808
36809
36810 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36811 PyObject *resultobj = 0;
36812 wxDisplay *arg1 = (wxDisplay *) 0 ;
36813 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36814 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36815 bool result;
36816 void *argp1 = 0 ;
36817 int res1 = 0 ;
36818 void *argp2 = 0 ;
36819 int res2 = 0 ;
36820 PyObject * obj0 = 0 ;
36821 PyObject * obj1 = 0 ;
36822 char * kwnames[] = {
36823 (char *) "self",(char *) "mode", NULL
36824 };
36825
36826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36828 if (!SWIG_IsOK(res1)) {
36829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36830 }
36831 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36832 if (obj1) {
36833 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36834 if (!SWIG_IsOK(res2)) {
36835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36836 }
36837 if (!argp2) {
36838 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36839 }
36840 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36841 }
36842 {
36843 PyThreadState* __tstate = wxPyBeginAllowThreads();
36844 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36845 wxPyEndAllowThreads(__tstate);
36846 if (PyErr_Occurred()) SWIG_fail;
36847 }
36848 {
36849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36850 }
36851 return resultobj;
36852 fail:
36853 return NULL;
36854 }
36855
36856
36857 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36858 PyObject *resultobj = 0;
36859 wxDisplay *arg1 = (wxDisplay *) 0 ;
36860 void *argp1 = 0 ;
36861 int res1 = 0 ;
36862 PyObject *swig_obj[1] ;
36863
36864 if (!args) SWIG_fail;
36865 swig_obj[0] = args;
36866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36867 if (!SWIG_IsOK(res1)) {
36868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36869 }
36870 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36871 {
36872 PyThreadState* __tstate = wxPyBeginAllowThreads();
36873 wxDisplay_ResetMode(arg1);
36874 wxPyEndAllowThreads(__tstate);
36875 if (PyErr_Occurred()) SWIG_fail;
36876 }
36877 resultobj = SWIG_Py_Void();
36878 return resultobj;
36879 fail:
36880 return NULL;
36881 }
36882
36883
36884 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36885 PyObject *obj;
36886 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36887 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36888 return SWIG_Py_Void();
36889 }
36890
36891 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36892 return SWIG_Python_InitShadowInstance(args);
36893 }
36894
36895 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36896 PyObject *resultobj = 0;
36897 wxStandardPaths *result = 0 ;
36898
36899 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36900 {
36901 PyThreadState* __tstate = wxPyBeginAllowThreads();
36902 result = (wxStandardPaths *)wxStandardPaths_Get();
36903 wxPyEndAllowThreads(__tstate);
36904 if (PyErr_Occurred()) SWIG_fail;
36905 }
36906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36907 return resultobj;
36908 fail:
36909 return NULL;
36910 }
36911
36912
36913 SWIGINTERN PyObject *_wrap_StandardPaths_GetExecutablePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36914 PyObject *resultobj = 0;
36915 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36916 wxString result;
36917 void *argp1 = 0 ;
36918 int res1 = 0 ;
36919 PyObject *swig_obj[1] ;
36920
36921 if (!args) SWIG_fail;
36922 swig_obj[0] = args;
36923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36924 if (!SWIG_IsOK(res1)) {
36925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetExecutablePath" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36926 }
36927 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36928 {
36929 PyThreadState* __tstate = wxPyBeginAllowThreads();
36930 result = ((wxStandardPaths const *)arg1)->GetExecutablePath();
36931 wxPyEndAllowThreads(__tstate);
36932 if (PyErr_Occurred()) SWIG_fail;
36933 }
36934 {
36935 #if wxUSE_UNICODE
36936 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36937 #else
36938 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36939 #endif
36940 }
36941 return resultobj;
36942 fail:
36943 return NULL;
36944 }
36945
36946
36947 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36948 PyObject *resultobj = 0;
36949 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36950 wxString result;
36951 void *argp1 = 0 ;
36952 int res1 = 0 ;
36953 PyObject *swig_obj[1] ;
36954
36955 if (!args) SWIG_fail;
36956 swig_obj[0] = args;
36957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36958 if (!SWIG_IsOK(res1)) {
36959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36960 }
36961 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36962 {
36963 PyThreadState* __tstate = wxPyBeginAllowThreads();
36964 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36965 wxPyEndAllowThreads(__tstate);
36966 if (PyErr_Occurred()) SWIG_fail;
36967 }
36968 {
36969 #if wxUSE_UNICODE
36970 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36971 #else
36972 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36973 #endif
36974 }
36975 return resultobj;
36976 fail:
36977 return NULL;
36978 }
36979
36980
36981 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36982 PyObject *resultobj = 0;
36983 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36984 wxString result;
36985 void *argp1 = 0 ;
36986 int res1 = 0 ;
36987 PyObject *swig_obj[1] ;
36988
36989 if (!args) SWIG_fail;
36990 swig_obj[0] = args;
36991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36992 if (!SWIG_IsOK(res1)) {
36993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36994 }
36995 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36996 {
36997 PyThreadState* __tstate = wxPyBeginAllowThreads();
36998 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36999 wxPyEndAllowThreads(__tstate);
37000 if (PyErr_Occurred()) SWIG_fail;
37001 }
37002 {
37003 #if wxUSE_UNICODE
37004 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37005 #else
37006 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37007 #endif
37008 }
37009 return resultobj;
37010 fail:
37011 return NULL;
37012 }
37013
37014
37015 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37016 PyObject *resultobj = 0;
37017 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37018 wxString result;
37019 void *argp1 = 0 ;
37020 int res1 = 0 ;
37021 PyObject *swig_obj[1] ;
37022
37023 if (!args) SWIG_fail;
37024 swig_obj[0] = args;
37025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37026 if (!SWIG_IsOK(res1)) {
37027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37028 }
37029 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37030 {
37031 PyThreadState* __tstate = wxPyBeginAllowThreads();
37032 result = ((wxStandardPaths const *)arg1)->GetDataDir();
37033 wxPyEndAllowThreads(__tstate);
37034 if (PyErr_Occurred()) SWIG_fail;
37035 }
37036 {
37037 #if wxUSE_UNICODE
37038 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37039 #else
37040 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37041 #endif
37042 }
37043 return resultobj;
37044 fail:
37045 return NULL;
37046 }
37047
37048
37049 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37050 PyObject *resultobj = 0;
37051 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37052 wxString result;
37053 void *argp1 = 0 ;
37054 int res1 = 0 ;
37055 PyObject *swig_obj[1] ;
37056
37057 if (!args) SWIG_fail;
37058 swig_obj[0] = args;
37059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37060 if (!SWIG_IsOK(res1)) {
37061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37062 }
37063 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37064 {
37065 PyThreadState* __tstate = wxPyBeginAllowThreads();
37066 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
37067 wxPyEndAllowThreads(__tstate);
37068 if (PyErr_Occurred()) SWIG_fail;
37069 }
37070 {
37071 #if wxUSE_UNICODE
37072 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37073 #else
37074 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37075 #endif
37076 }
37077 return resultobj;
37078 fail:
37079 return NULL;
37080 }
37081
37082
37083 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37084 PyObject *resultobj = 0;
37085 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37086 wxString result;
37087 void *argp1 = 0 ;
37088 int res1 = 0 ;
37089 PyObject *swig_obj[1] ;
37090
37091 if (!args) SWIG_fail;
37092 swig_obj[0] = args;
37093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37094 if (!SWIG_IsOK(res1)) {
37095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37096 }
37097 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37098 {
37099 PyThreadState* __tstate = wxPyBeginAllowThreads();
37100 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
37101 wxPyEndAllowThreads(__tstate);
37102 if (PyErr_Occurred()) SWIG_fail;
37103 }
37104 {
37105 #if wxUSE_UNICODE
37106 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37107 #else
37108 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37109 #endif
37110 }
37111 return resultobj;
37112 fail:
37113 return NULL;
37114 }
37115
37116
37117 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37118 PyObject *resultobj = 0;
37119 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37120 wxString result;
37121 void *argp1 = 0 ;
37122 int res1 = 0 ;
37123 PyObject *swig_obj[1] ;
37124
37125 if (!args) SWIG_fail;
37126 swig_obj[0] = args;
37127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37128 if (!SWIG_IsOK(res1)) {
37129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37130 }
37131 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37132 {
37133 PyThreadState* __tstate = wxPyBeginAllowThreads();
37134 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37135 wxPyEndAllowThreads(__tstate);
37136 if (PyErr_Occurred()) SWIG_fail;
37137 }
37138 {
37139 #if wxUSE_UNICODE
37140 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37141 #else
37142 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37143 #endif
37144 }
37145 return resultobj;
37146 fail:
37147 return NULL;
37148 }
37149
37150
37151 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37152 PyObject *resultobj = 0;
37153 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37154 wxString result;
37155 void *argp1 = 0 ;
37156 int res1 = 0 ;
37157 PyObject *swig_obj[1] ;
37158
37159 if (!args) SWIG_fail;
37160 swig_obj[0] = args;
37161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37162 if (!SWIG_IsOK(res1)) {
37163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37164 }
37165 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37166 {
37167 PyThreadState* __tstate = wxPyBeginAllowThreads();
37168 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37169 wxPyEndAllowThreads(__tstate);
37170 if (PyErr_Occurred()) SWIG_fail;
37171 }
37172 {
37173 #if wxUSE_UNICODE
37174 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37175 #else
37176 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37177 #endif
37178 }
37179 return resultobj;
37180 fail:
37181 return NULL;
37182 }
37183
37184
37185 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37186 PyObject *resultobj = 0;
37187 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37188 wxString result;
37189 void *argp1 = 0 ;
37190 int res1 = 0 ;
37191 PyObject *swig_obj[1] ;
37192
37193 if (!args) SWIG_fail;
37194 swig_obj[0] = args;
37195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37196 if (!SWIG_IsOK(res1)) {
37197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37198 }
37199 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37200 {
37201 PyThreadState* __tstate = wxPyBeginAllowThreads();
37202 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37203 wxPyEndAllowThreads(__tstate);
37204 if (PyErr_Occurred()) SWIG_fail;
37205 }
37206 {
37207 #if wxUSE_UNICODE
37208 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37209 #else
37210 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37211 #endif
37212 }
37213 return resultobj;
37214 fail:
37215 return NULL;
37216 }
37217
37218
37219 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37220 PyObject *resultobj = 0;
37221 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37222 wxString *arg2 = 0 ;
37223 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37224 wxString result;
37225 void *argp1 = 0 ;
37226 int res1 = 0 ;
37227 bool temp2 = false ;
37228 int val3 ;
37229 int ecode3 = 0 ;
37230 PyObject * obj0 = 0 ;
37231 PyObject * obj1 = 0 ;
37232 PyObject * obj2 = 0 ;
37233 char * kwnames[] = {
37234 (char *) "self",(char *) "lang",(char *) "category", NULL
37235 };
37236
37237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37239 if (!SWIG_IsOK(res1)) {
37240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37241 }
37242 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37243 {
37244 arg2 = wxString_in_helper(obj1);
37245 if (arg2 == NULL) SWIG_fail;
37246 temp2 = true;
37247 }
37248 if (obj2) {
37249 ecode3 = SWIG_AsVal_int(obj2, &val3);
37250 if (!SWIG_IsOK(ecode3)) {
37251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37252 }
37253 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37254 }
37255 {
37256 PyThreadState* __tstate = wxPyBeginAllowThreads();
37257 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37258 wxPyEndAllowThreads(__tstate);
37259 if (PyErr_Occurred()) SWIG_fail;
37260 }
37261 {
37262 #if wxUSE_UNICODE
37263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37264 #else
37265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37266 #endif
37267 }
37268 {
37269 if (temp2)
37270 delete arg2;
37271 }
37272 return resultobj;
37273 fail:
37274 {
37275 if (temp2)
37276 delete arg2;
37277 }
37278 return NULL;
37279 }
37280
37281
37282 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37283 PyObject *resultobj = 0;
37284 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37285 wxString result;
37286 void *argp1 = 0 ;
37287 int res1 = 0 ;
37288 PyObject *swig_obj[1] ;
37289
37290 if (!args) SWIG_fail;
37291 swig_obj[0] = args;
37292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37293 if (!SWIG_IsOK(res1)) {
37294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37295 }
37296 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37297 {
37298 PyThreadState* __tstate = wxPyBeginAllowThreads();
37299 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37300 wxPyEndAllowThreads(__tstate);
37301 if (PyErr_Occurred()) SWIG_fail;
37302 }
37303 {
37304 #if wxUSE_UNICODE
37305 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37306 #else
37307 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37308 #endif
37309 }
37310 return resultobj;
37311 fail:
37312 return NULL;
37313 }
37314
37315
37316 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37317 PyObject *resultobj = 0;
37318 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37319 wxString result;
37320 void *argp1 = 0 ;
37321 int res1 = 0 ;
37322 PyObject *swig_obj[1] ;
37323
37324 if (!args) SWIG_fail;
37325 swig_obj[0] = args;
37326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37327 if (!SWIG_IsOK(res1)) {
37328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37329 }
37330 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37331 {
37332 PyThreadState* __tstate = wxPyBeginAllowThreads();
37333 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37334 wxPyEndAllowThreads(__tstate);
37335 if (PyErr_Occurred()) SWIG_fail;
37336 }
37337 {
37338 #if wxUSE_UNICODE
37339 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37340 #else
37341 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37342 #endif
37343 }
37344 return resultobj;
37345 fail:
37346 return NULL;
37347 }
37348
37349
37350 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37351 PyObject *resultobj = 0;
37352 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37353 wxString *arg2 = 0 ;
37354 void *argp1 = 0 ;
37355 int res1 = 0 ;
37356 bool temp2 = false ;
37357 PyObject * obj0 = 0 ;
37358 PyObject * obj1 = 0 ;
37359 char * kwnames[] = {
37360 (char *) "self",(char *) "prefix", NULL
37361 };
37362
37363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37365 if (!SWIG_IsOK(res1)) {
37366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37367 }
37368 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37369 {
37370 arg2 = wxString_in_helper(obj1);
37371 if (arg2 == NULL) SWIG_fail;
37372 temp2 = true;
37373 }
37374 {
37375 PyThreadState* __tstate = wxPyBeginAllowThreads();
37376 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
37377 wxPyEndAllowThreads(__tstate);
37378 if (PyErr_Occurred()) SWIG_fail;
37379 }
37380 resultobj = SWIG_Py_Void();
37381 {
37382 if (temp2)
37383 delete arg2;
37384 }
37385 return resultobj;
37386 fail:
37387 {
37388 if (temp2)
37389 delete arg2;
37390 }
37391 return NULL;
37392 }
37393
37394
37395 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37396 PyObject *resultobj = 0;
37397 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37398 wxString result;
37399 void *argp1 = 0 ;
37400 int res1 = 0 ;
37401 PyObject *swig_obj[1] ;
37402
37403 if (!args) SWIG_fail;
37404 swig_obj[0] = args;
37405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37406 if (!SWIG_IsOK(res1)) {
37407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37408 }
37409 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37410 {
37411 PyThreadState* __tstate = wxPyBeginAllowThreads();
37412 result = wxStandardPaths_GetInstallPrefix(arg1);
37413 wxPyEndAllowThreads(__tstate);
37414 if (PyErr_Occurred()) SWIG_fail;
37415 }
37416 {
37417 #if wxUSE_UNICODE
37418 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37419 #else
37420 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37421 #endif
37422 }
37423 return resultobj;
37424 fail:
37425 return NULL;
37426 }
37427
37428
37429 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37430 PyObject *obj;
37431 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37432 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37433 return SWIG_Py_Void();
37434 }
37435
37436 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37437 PyObject *resultobj = 0;
37438 wxEventType arg1 ;
37439 wxPowerEvent *result = 0 ;
37440 int val1 ;
37441 int ecode1 = 0 ;
37442 PyObject * obj0 = 0 ;
37443 char * kwnames[] = {
37444 (char *) "evtType", NULL
37445 };
37446
37447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37448 ecode1 = SWIG_AsVal_int(obj0, &val1);
37449 if (!SWIG_IsOK(ecode1)) {
37450 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37451 }
37452 arg1 = static_cast< wxEventType >(val1);
37453 {
37454 PyThreadState* __tstate = wxPyBeginAllowThreads();
37455 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37456 wxPyEndAllowThreads(__tstate);
37457 if (PyErr_Occurred()) SWIG_fail;
37458 }
37459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37460 return resultobj;
37461 fail:
37462 return NULL;
37463 }
37464
37465
37466 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37467 PyObject *resultobj = 0;
37468 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37469 void *argp1 = 0 ;
37470 int res1 = 0 ;
37471 PyObject *swig_obj[1] ;
37472
37473 if (!args) SWIG_fail;
37474 swig_obj[0] = args;
37475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37476 if (!SWIG_IsOK(res1)) {
37477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37478 }
37479 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37480 {
37481 PyThreadState* __tstate = wxPyBeginAllowThreads();
37482 (arg1)->Veto();
37483 wxPyEndAllowThreads(__tstate);
37484 if (PyErr_Occurred()) SWIG_fail;
37485 }
37486 resultobj = SWIG_Py_Void();
37487 return resultobj;
37488 fail:
37489 return NULL;
37490 }
37491
37492
37493 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37494 PyObject *resultobj = 0;
37495 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37496 bool result;
37497 void *argp1 = 0 ;
37498 int res1 = 0 ;
37499 PyObject *swig_obj[1] ;
37500
37501 if (!args) SWIG_fail;
37502 swig_obj[0] = args;
37503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37504 if (!SWIG_IsOK(res1)) {
37505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37506 }
37507 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37508 {
37509 PyThreadState* __tstate = wxPyBeginAllowThreads();
37510 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37511 wxPyEndAllowThreads(__tstate);
37512 if (PyErr_Occurred()) SWIG_fail;
37513 }
37514 {
37515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37516 }
37517 return resultobj;
37518 fail:
37519 return NULL;
37520 }
37521
37522
37523 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37524 PyObject *obj;
37525 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37526 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37527 return SWIG_Py_Void();
37528 }
37529
37530 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37531 return SWIG_Python_InitShadowInstance(args);
37532 }
37533
37534 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37535 PyObject *resultobj = 0;
37536 wxPowerType result;
37537
37538 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37539 {
37540 PyThreadState* __tstate = wxPyBeginAllowThreads();
37541 result = (wxPowerType)wxGetPowerType();
37542 wxPyEndAllowThreads(__tstate);
37543 if (PyErr_Occurred()) SWIG_fail;
37544 }
37545 resultobj = SWIG_From_int(static_cast< int >(result));
37546 return resultobj;
37547 fail:
37548 return NULL;
37549 }
37550
37551
37552 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37553 PyObject *resultobj = 0;
37554 wxBatteryState result;
37555
37556 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37557 {
37558 PyThreadState* __tstate = wxPyBeginAllowThreads();
37559 result = (wxBatteryState)wxGetBatteryState();
37560 wxPyEndAllowThreads(__tstate);
37561 if (PyErr_Occurred()) SWIG_fail;
37562 }
37563 resultobj = SWIG_From_int(static_cast< int >(result));
37564 return resultobj;
37565 fail:
37566 return NULL;
37567 }
37568
37569
37570 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37571 PyObject *resultobj = 0;
37572 wxAboutDialogInfo *result = 0 ;
37573
37574 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37575 {
37576 PyThreadState* __tstate = wxPyBeginAllowThreads();
37577 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37578 wxPyEndAllowThreads(__tstate);
37579 if (PyErr_Occurred()) SWIG_fail;
37580 }
37581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37582 return resultobj;
37583 fail:
37584 return NULL;
37585 }
37586
37587
37588 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37589 PyObject *resultobj = 0;
37590 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37591 void *argp1 = 0 ;
37592 int res1 = 0 ;
37593 PyObject *swig_obj[1] ;
37594
37595 if (!args) SWIG_fail;
37596 swig_obj[0] = args;
37597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37598 if (!SWIG_IsOK(res1)) {
37599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37600 }
37601 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37602 {
37603 PyThreadState* __tstate = wxPyBeginAllowThreads();
37604 delete arg1;
37605
37606 wxPyEndAllowThreads(__tstate);
37607 if (PyErr_Occurred()) SWIG_fail;
37608 }
37609 resultobj = SWIG_Py_Void();
37610 return resultobj;
37611 fail:
37612 return NULL;
37613 }
37614
37615
37616 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37617 PyObject *resultobj = 0;
37618 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37619 wxString *arg2 = 0 ;
37620 void *argp1 = 0 ;
37621 int res1 = 0 ;
37622 bool temp2 = false ;
37623 PyObject * obj0 = 0 ;
37624 PyObject * obj1 = 0 ;
37625 char * kwnames[] = {
37626 (char *) "self",(char *) "name", NULL
37627 };
37628
37629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37631 if (!SWIG_IsOK(res1)) {
37632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37633 }
37634 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37635 {
37636 arg2 = wxString_in_helper(obj1);
37637 if (arg2 == NULL) SWIG_fail;
37638 temp2 = true;
37639 }
37640 {
37641 PyThreadState* __tstate = wxPyBeginAllowThreads();
37642 (arg1)->SetName((wxString const &)*arg2);
37643 wxPyEndAllowThreads(__tstate);
37644 if (PyErr_Occurred()) SWIG_fail;
37645 }
37646 resultobj = SWIG_Py_Void();
37647 {
37648 if (temp2)
37649 delete arg2;
37650 }
37651 return resultobj;
37652 fail:
37653 {
37654 if (temp2)
37655 delete arg2;
37656 }
37657 return NULL;
37658 }
37659
37660
37661 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37662 PyObject *resultobj = 0;
37663 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37664 wxString result;
37665 void *argp1 = 0 ;
37666 int res1 = 0 ;
37667 PyObject *swig_obj[1] ;
37668
37669 if (!args) SWIG_fail;
37670 swig_obj[0] = args;
37671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37672 if (!SWIG_IsOK(res1)) {
37673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37674 }
37675 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37676 {
37677 PyThreadState* __tstate = wxPyBeginAllowThreads();
37678 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37679 wxPyEndAllowThreads(__tstate);
37680 if (PyErr_Occurred()) SWIG_fail;
37681 }
37682 {
37683 #if wxUSE_UNICODE
37684 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37685 #else
37686 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37687 #endif
37688 }
37689 return resultobj;
37690 fail:
37691 return NULL;
37692 }
37693
37694
37695 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37696 PyObject *resultobj = 0;
37697 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37698 wxString *arg2 = 0 ;
37699 void *argp1 = 0 ;
37700 int res1 = 0 ;
37701 bool temp2 = false ;
37702 PyObject * obj0 = 0 ;
37703 PyObject * obj1 = 0 ;
37704 char * kwnames[] = {
37705 (char *) "self",(char *) "version", NULL
37706 };
37707
37708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37710 if (!SWIG_IsOK(res1)) {
37711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37712 }
37713 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37714 {
37715 arg2 = wxString_in_helper(obj1);
37716 if (arg2 == NULL) SWIG_fail;
37717 temp2 = true;
37718 }
37719 {
37720 PyThreadState* __tstate = wxPyBeginAllowThreads();
37721 (arg1)->SetVersion((wxString const &)*arg2);
37722 wxPyEndAllowThreads(__tstate);
37723 if (PyErr_Occurred()) SWIG_fail;
37724 }
37725 resultobj = SWIG_Py_Void();
37726 {
37727 if (temp2)
37728 delete arg2;
37729 }
37730 return resultobj;
37731 fail:
37732 {
37733 if (temp2)
37734 delete arg2;
37735 }
37736 return NULL;
37737 }
37738
37739
37740 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37741 PyObject *resultobj = 0;
37742 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37743 bool result;
37744 void *argp1 = 0 ;
37745 int res1 = 0 ;
37746 PyObject *swig_obj[1] ;
37747
37748 if (!args) SWIG_fail;
37749 swig_obj[0] = args;
37750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37751 if (!SWIG_IsOK(res1)) {
37752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37753 }
37754 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37755 {
37756 PyThreadState* __tstate = wxPyBeginAllowThreads();
37757 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37758 wxPyEndAllowThreads(__tstate);
37759 if (PyErr_Occurred()) SWIG_fail;
37760 }
37761 {
37762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37763 }
37764 return resultobj;
37765 fail:
37766 return NULL;
37767 }
37768
37769
37770 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37771 PyObject *resultobj = 0;
37772 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37773 wxString result;
37774 void *argp1 = 0 ;
37775 int res1 = 0 ;
37776 PyObject *swig_obj[1] ;
37777
37778 if (!args) SWIG_fail;
37779 swig_obj[0] = args;
37780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37781 if (!SWIG_IsOK(res1)) {
37782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37783 }
37784 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37785 {
37786 PyThreadState* __tstate = wxPyBeginAllowThreads();
37787 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37788 wxPyEndAllowThreads(__tstate);
37789 if (PyErr_Occurred()) SWIG_fail;
37790 }
37791 {
37792 #if wxUSE_UNICODE
37793 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37794 #else
37795 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37796 #endif
37797 }
37798 return resultobj;
37799 fail:
37800 return NULL;
37801 }
37802
37803
37804 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37805 PyObject *resultobj = 0;
37806 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37807 wxString *arg2 = 0 ;
37808 void *argp1 = 0 ;
37809 int res1 = 0 ;
37810 bool temp2 = false ;
37811 PyObject * obj0 = 0 ;
37812 PyObject * obj1 = 0 ;
37813 char * kwnames[] = {
37814 (char *) "self",(char *) "desc", NULL
37815 };
37816
37817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37819 if (!SWIG_IsOK(res1)) {
37820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37821 }
37822 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37823 {
37824 arg2 = wxString_in_helper(obj1);
37825 if (arg2 == NULL) SWIG_fail;
37826 temp2 = true;
37827 }
37828 {
37829 PyThreadState* __tstate = wxPyBeginAllowThreads();
37830 (arg1)->SetDescription((wxString const &)*arg2);
37831 wxPyEndAllowThreads(__tstate);
37832 if (PyErr_Occurred()) SWIG_fail;
37833 }
37834 resultobj = SWIG_Py_Void();
37835 {
37836 if (temp2)
37837 delete arg2;
37838 }
37839 return resultobj;
37840 fail:
37841 {
37842 if (temp2)
37843 delete arg2;
37844 }
37845 return NULL;
37846 }
37847
37848
37849 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37850 PyObject *resultobj = 0;
37851 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37852 bool result;
37853 void *argp1 = 0 ;
37854 int res1 = 0 ;
37855 PyObject *swig_obj[1] ;
37856
37857 if (!args) SWIG_fail;
37858 swig_obj[0] = args;
37859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37860 if (!SWIG_IsOK(res1)) {
37861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37862 }
37863 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37864 {
37865 PyThreadState* __tstate = wxPyBeginAllowThreads();
37866 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37867 wxPyEndAllowThreads(__tstate);
37868 if (PyErr_Occurred()) SWIG_fail;
37869 }
37870 {
37871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37872 }
37873 return resultobj;
37874 fail:
37875 return NULL;
37876 }
37877
37878
37879 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37880 PyObject *resultobj = 0;
37881 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37882 wxString result;
37883 void *argp1 = 0 ;
37884 int res1 = 0 ;
37885 PyObject *swig_obj[1] ;
37886
37887 if (!args) SWIG_fail;
37888 swig_obj[0] = args;
37889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37890 if (!SWIG_IsOK(res1)) {
37891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37892 }
37893 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37894 {
37895 PyThreadState* __tstate = wxPyBeginAllowThreads();
37896 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37897 wxPyEndAllowThreads(__tstate);
37898 if (PyErr_Occurred()) SWIG_fail;
37899 }
37900 {
37901 #if wxUSE_UNICODE
37902 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37903 #else
37904 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37905 #endif
37906 }
37907 return resultobj;
37908 fail:
37909 return NULL;
37910 }
37911
37912
37913 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37914 PyObject *resultobj = 0;
37915 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37916 wxString *arg2 = 0 ;
37917 void *argp1 = 0 ;
37918 int res1 = 0 ;
37919 bool temp2 = false ;
37920 PyObject * obj0 = 0 ;
37921 PyObject * obj1 = 0 ;
37922 char * kwnames[] = {
37923 (char *) "self",(char *) "copyright", NULL
37924 };
37925
37926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37928 if (!SWIG_IsOK(res1)) {
37929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37930 }
37931 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37932 {
37933 arg2 = wxString_in_helper(obj1);
37934 if (arg2 == NULL) SWIG_fail;
37935 temp2 = true;
37936 }
37937 {
37938 PyThreadState* __tstate = wxPyBeginAllowThreads();
37939 (arg1)->SetCopyright((wxString const &)*arg2);
37940 wxPyEndAllowThreads(__tstate);
37941 if (PyErr_Occurred()) SWIG_fail;
37942 }
37943 resultobj = SWIG_Py_Void();
37944 {
37945 if (temp2)
37946 delete arg2;
37947 }
37948 return resultobj;
37949 fail:
37950 {
37951 if (temp2)
37952 delete arg2;
37953 }
37954 return NULL;
37955 }
37956
37957
37958 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37959 PyObject *resultobj = 0;
37960 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37961 bool result;
37962 void *argp1 = 0 ;
37963 int res1 = 0 ;
37964 PyObject *swig_obj[1] ;
37965
37966 if (!args) SWIG_fail;
37967 swig_obj[0] = args;
37968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37969 if (!SWIG_IsOK(res1)) {
37970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37971 }
37972 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37973 {
37974 PyThreadState* __tstate = wxPyBeginAllowThreads();
37975 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
37976 wxPyEndAllowThreads(__tstate);
37977 if (PyErr_Occurred()) SWIG_fail;
37978 }
37979 {
37980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37981 }
37982 return resultobj;
37983 fail:
37984 return NULL;
37985 }
37986
37987
37988 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37989 PyObject *resultobj = 0;
37990 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37991 wxString result;
37992 void *argp1 = 0 ;
37993 int res1 = 0 ;
37994 PyObject *swig_obj[1] ;
37995
37996 if (!args) SWIG_fail;
37997 swig_obj[0] = args;
37998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37999 if (!SWIG_IsOK(res1)) {
38000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38001 }
38002 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38003 {
38004 PyThreadState* __tstate = wxPyBeginAllowThreads();
38005 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
38006 wxPyEndAllowThreads(__tstate);
38007 if (PyErr_Occurred()) SWIG_fail;
38008 }
38009 {
38010 #if wxUSE_UNICODE
38011 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38012 #else
38013 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38014 #endif
38015 }
38016 return resultobj;
38017 fail:
38018 return NULL;
38019 }
38020
38021
38022 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38023 PyObject *resultobj = 0;
38024 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38025 wxString *arg2 = 0 ;
38026 void *argp1 = 0 ;
38027 int res1 = 0 ;
38028 bool temp2 = false ;
38029 PyObject * obj0 = 0 ;
38030 PyObject * obj1 = 0 ;
38031 char * kwnames[] = {
38032 (char *) "self",(char *) "licence", NULL
38033 };
38034
38035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
38036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38037 if (!SWIG_IsOK(res1)) {
38038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38039 }
38040 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38041 {
38042 arg2 = wxString_in_helper(obj1);
38043 if (arg2 == NULL) SWIG_fail;
38044 temp2 = true;
38045 }
38046 {
38047 PyThreadState* __tstate = wxPyBeginAllowThreads();
38048 (arg1)->SetLicence((wxString const &)*arg2);
38049 wxPyEndAllowThreads(__tstate);
38050 if (PyErr_Occurred()) SWIG_fail;
38051 }
38052 resultobj = SWIG_Py_Void();
38053 {
38054 if (temp2)
38055 delete arg2;
38056 }
38057 return resultobj;
38058 fail:
38059 {
38060 if (temp2)
38061 delete arg2;
38062 }
38063 return NULL;
38064 }
38065
38066
38067 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38068 PyObject *resultobj = 0;
38069 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38070 wxString *arg2 = 0 ;
38071 void *argp1 = 0 ;
38072 int res1 = 0 ;
38073 bool temp2 = false ;
38074 PyObject * obj0 = 0 ;
38075 PyObject * obj1 = 0 ;
38076 char * kwnames[] = {
38077 (char *) "self",(char *) "licence", NULL
38078 };
38079
38080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
38081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38082 if (!SWIG_IsOK(res1)) {
38083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38084 }
38085 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38086 {
38087 arg2 = wxString_in_helper(obj1);
38088 if (arg2 == NULL) SWIG_fail;
38089 temp2 = true;
38090 }
38091 {
38092 PyThreadState* __tstate = wxPyBeginAllowThreads();
38093 (arg1)->SetLicense((wxString const &)*arg2);
38094 wxPyEndAllowThreads(__tstate);
38095 if (PyErr_Occurred()) SWIG_fail;
38096 }
38097 resultobj = SWIG_Py_Void();
38098 {
38099 if (temp2)
38100 delete arg2;
38101 }
38102 return resultobj;
38103 fail:
38104 {
38105 if (temp2)
38106 delete arg2;
38107 }
38108 return NULL;
38109 }
38110
38111
38112 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38113 PyObject *resultobj = 0;
38114 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38115 bool result;
38116 void *argp1 = 0 ;
38117 int res1 = 0 ;
38118 PyObject *swig_obj[1] ;
38119
38120 if (!args) SWIG_fail;
38121 swig_obj[0] = args;
38122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38123 if (!SWIG_IsOK(res1)) {
38124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38125 }
38126 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38127 {
38128 PyThreadState* __tstate = wxPyBeginAllowThreads();
38129 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38130 wxPyEndAllowThreads(__tstate);
38131 if (PyErr_Occurred()) SWIG_fail;
38132 }
38133 {
38134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38135 }
38136 return resultobj;
38137 fail:
38138 return NULL;
38139 }
38140
38141
38142 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38143 PyObject *resultobj = 0;
38144 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38145 wxString result;
38146 void *argp1 = 0 ;
38147 int res1 = 0 ;
38148 PyObject *swig_obj[1] ;
38149
38150 if (!args) SWIG_fail;
38151 swig_obj[0] = args;
38152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38153 if (!SWIG_IsOK(res1)) {
38154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38155 }
38156 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38157 {
38158 PyThreadState* __tstate = wxPyBeginAllowThreads();
38159 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38160 wxPyEndAllowThreads(__tstate);
38161 if (PyErr_Occurred()) SWIG_fail;
38162 }
38163 {
38164 #if wxUSE_UNICODE
38165 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38166 #else
38167 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38168 #endif
38169 }
38170 return resultobj;
38171 fail:
38172 return NULL;
38173 }
38174
38175
38176 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38177 PyObject *resultobj = 0;
38178 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38179 wxIcon *arg2 = 0 ;
38180 void *argp1 = 0 ;
38181 int res1 = 0 ;
38182 void *argp2 = 0 ;
38183 int res2 = 0 ;
38184 PyObject * obj0 = 0 ;
38185 PyObject * obj1 = 0 ;
38186 char * kwnames[] = {
38187 (char *) "self",(char *) "icon", NULL
38188 };
38189
38190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38192 if (!SWIG_IsOK(res1)) {
38193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38194 }
38195 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38196 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38197 if (!SWIG_IsOK(res2)) {
38198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38199 }
38200 if (!argp2) {
38201 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38202 }
38203 arg2 = reinterpret_cast< wxIcon * >(argp2);
38204 {
38205 PyThreadState* __tstate = wxPyBeginAllowThreads();
38206 (arg1)->SetIcon((wxIcon const &)*arg2);
38207 wxPyEndAllowThreads(__tstate);
38208 if (PyErr_Occurred()) SWIG_fail;
38209 }
38210 resultobj = SWIG_Py_Void();
38211 return resultobj;
38212 fail:
38213 return NULL;
38214 }
38215
38216
38217 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38218 PyObject *resultobj = 0;
38219 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38220 bool result;
38221 void *argp1 = 0 ;
38222 int res1 = 0 ;
38223 PyObject *swig_obj[1] ;
38224
38225 if (!args) SWIG_fail;
38226 swig_obj[0] = args;
38227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38228 if (!SWIG_IsOK(res1)) {
38229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38230 }
38231 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38232 {
38233 PyThreadState* __tstate = wxPyBeginAllowThreads();
38234 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38235 wxPyEndAllowThreads(__tstate);
38236 if (PyErr_Occurred()) SWIG_fail;
38237 }
38238 {
38239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38240 }
38241 return resultobj;
38242 fail:
38243 return NULL;
38244 }
38245
38246
38247 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38248 PyObject *resultobj = 0;
38249 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38250 wxIcon result;
38251 void *argp1 = 0 ;
38252 int res1 = 0 ;
38253 PyObject *swig_obj[1] ;
38254
38255 if (!args) SWIG_fail;
38256 swig_obj[0] = args;
38257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38258 if (!SWIG_IsOK(res1)) {
38259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38260 }
38261 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38262 {
38263 PyThreadState* __tstate = wxPyBeginAllowThreads();
38264 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38265 wxPyEndAllowThreads(__tstate);
38266 if (PyErr_Occurred()) SWIG_fail;
38267 }
38268 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38269 return resultobj;
38270 fail:
38271 return NULL;
38272 }
38273
38274
38275 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38276 PyObject *resultobj = 0;
38277 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38278 wxString *arg2 = 0 ;
38279 wxString const &arg3_defvalue = wxEmptyString ;
38280 wxString *arg3 = (wxString *) &arg3_defvalue ;
38281 void *argp1 = 0 ;
38282 int res1 = 0 ;
38283 bool temp2 = false ;
38284 bool temp3 = false ;
38285 PyObject * obj0 = 0 ;
38286 PyObject * obj1 = 0 ;
38287 PyObject * obj2 = 0 ;
38288 char * kwnames[] = {
38289 (char *) "self",(char *) "url",(char *) "desc", NULL
38290 };
38291
38292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38294 if (!SWIG_IsOK(res1)) {
38295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38296 }
38297 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38298 {
38299 arg2 = wxString_in_helper(obj1);
38300 if (arg2 == NULL) SWIG_fail;
38301 temp2 = true;
38302 }
38303 if (obj2) {
38304 {
38305 arg3 = wxString_in_helper(obj2);
38306 if (arg3 == NULL) SWIG_fail;
38307 temp3 = true;
38308 }
38309 }
38310 {
38311 PyThreadState* __tstate = wxPyBeginAllowThreads();
38312 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38313 wxPyEndAllowThreads(__tstate);
38314 if (PyErr_Occurred()) SWIG_fail;
38315 }
38316 resultobj = SWIG_Py_Void();
38317 {
38318 if (temp2)
38319 delete arg2;
38320 }
38321 {
38322 if (temp3)
38323 delete arg3;
38324 }
38325 return resultobj;
38326 fail:
38327 {
38328 if (temp2)
38329 delete arg2;
38330 }
38331 {
38332 if (temp3)
38333 delete arg3;
38334 }
38335 return NULL;
38336 }
38337
38338
38339 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38340 PyObject *resultobj = 0;
38341 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38342 wxString result;
38343 void *argp1 = 0 ;
38344 int res1 = 0 ;
38345 PyObject *swig_obj[1] ;
38346
38347 if (!args) SWIG_fail;
38348 swig_obj[0] = args;
38349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38350 if (!SWIG_IsOK(res1)) {
38351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38352 }
38353 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38354 {
38355 PyThreadState* __tstate = wxPyBeginAllowThreads();
38356 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38357 wxPyEndAllowThreads(__tstate);
38358 if (PyErr_Occurred()) SWIG_fail;
38359 }
38360 {
38361 #if wxUSE_UNICODE
38362 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38363 #else
38364 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38365 #endif
38366 }
38367 return resultobj;
38368 fail:
38369 return NULL;
38370 }
38371
38372
38373 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38374 PyObject *resultobj = 0;
38375 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38376 wxString result;
38377 void *argp1 = 0 ;
38378 int res1 = 0 ;
38379 PyObject *swig_obj[1] ;
38380
38381 if (!args) SWIG_fail;
38382 swig_obj[0] = args;
38383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38384 if (!SWIG_IsOK(res1)) {
38385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38386 }
38387 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38388 {
38389 PyThreadState* __tstate = wxPyBeginAllowThreads();
38390 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38391 wxPyEndAllowThreads(__tstate);
38392 if (PyErr_Occurred()) SWIG_fail;
38393 }
38394 {
38395 #if wxUSE_UNICODE
38396 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38397 #else
38398 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38399 #endif
38400 }
38401 return resultobj;
38402 fail:
38403 return NULL;
38404 }
38405
38406
38407 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38408 PyObject *resultobj = 0;
38409 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38410 bool result;
38411 void *argp1 = 0 ;
38412 int res1 = 0 ;
38413 PyObject *swig_obj[1] ;
38414
38415 if (!args) SWIG_fail;
38416 swig_obj[0] = args;
38417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38418 if (!SWIG_IsOK(res1)) {
38419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38420 }
38421 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38422 {
38423 PyThreadState* __tstate = wxPyBeginAllowThreads();
38424 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38425 wxPyEndAllowThreads(__tstate);
38426 if (PyErr_Occurred()) SWIG_fail;
38427 }
38428 {
38429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38430 }
38431 return resultobj;
38432 fail:
38433 return NULL;
38434 }
38435
38436
38437 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38438 PyObject *resultobj = 0;
38439 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38440 wxArrayString *arg2 = 0 ;
38441 void *argp1 = 0 ;
38442 int res1 = 0 ;
38443 bool temp2 = false ;
38444 PyObject * obj0 = 0 ;
38445 PyObject * obj1 = 0 ;
38446 char * kwnames[] = {
38447 (char *) "self",(char *) "developers", NULL
38448 };
38449
38450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38452 if (!SWIG_IsOK(res1)) {
38453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38454 }
38455 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38456 {
38457 if (! PySequence_Check(obj1)) {
38458 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38459 SWIG_fail;
38460 }
38461 arg2 = new wxArrayString;
38462 temp2 = true;
38463 int i, len=PySequence_Length(obj1);
38464 for (i=0; i<len; i++) {
38465 PyObject* item = PySequence_GetItem(obj1, i);
38466 wxString* s = wxString_in_helper(item);
38467 if (PyErr_Occurred()) SWIG_fail;
38468 arg2->Add(*s);
38469 delete s;
38470 Py_DECREF(item);
38471 }
38472 }
38473 {
38474 PyThreadState* __tstate = wxPyBeginAllowThreads();
38475 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38476 wxPyEndAllowThreads(__tstate);
38477 if (PyErr_Occurred()) SWIG_fail;
38478 }
38479 resultobj = SWIG_Py_Void();
38480 {
38481 if (temp2) delete arg2;
38482 }
38483 return resultobj;
38484 fail:
38485 {
38486 if (temp2) delete arg2;
38487 }
38488 return NULL;
38489 }
38490
38491
38492 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38493 PyObject *resultobj = 0;
38494 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38495 wxString *arg2 = 0 ;
38496 void *argp1 = 0 ;
38497 int res1 = 0 ;
38498 bool temp2 = false ;
38499 PyObject * obj0 = 0 ;
38500 PyObject * obj1 = 0 ;
38501 char * kwnames[] = {
38502 (char *) "self",(char *) "developer", NULL
38503 };
38504
38505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38507 if (!SWIG_IsOK(res1)) {
38508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38509 }
38510 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38511 {
38512 arg2 = wxString_in_helper(obj1);
38513 if (arg2 == NULL) SWIG_fail;
38514 temp2 = true;
38515 }
38516 {
38517 PyThreadState* __tstate = wxPyBeginAllowThreads();
38518 (arg1)->AddDeveloper((wxString const &)*arg2);
38519 wxPyEndAllowThreads(__tstate);
38520 if (PyErr_Occurred()) SWIG_fail;
38521 }
38522 resultobj = SWIG_Py_Void();
38523 {
38524 if (temp2)
38525 delete arg2;
38526 }
38527 return resultobj;
38528 fail:
38529 {
38530 if (temp2)
38531 delete arg2;
38532 }
38533 return NULL;
38534 }
38535
38536
38537 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38538 PyObject *resultobj = 0;
38539 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38540 bool result;
38541 void *argp1 = 0 ;
38542 int res1 = 0 ;
38543 PyObject *swig_obj[1] ;
38544
38545 if (!args) SWIG_fail;
38546 swig_obj[0] = args;
38547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38548 if (!SWIG_IsOK(res1)) {
38549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38550 }
38551 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38552 {
38553 PyThreadState* __tstate = wxPyBeginAllowThreads();
38554 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38555 wxPyEndAllowThreads(__tstate);
38556 if (PyErr_Occurred()) SWIG_fail;
38557 }
38558 {
38559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38560 }
38561 return resultobj;
38562 fail:
38563 return NULL;
38564 }
38565
38566
38567 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38568 PyObject *resultobj = 0;
38569 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38570 wxArrayString *result = 0 ;
38571 void *argp1 = 0 ;
38572 int res1 = 0 ;
38573 PyObject *swig_obj[1] ;
38574
38575 if (!args) SWIG_fail;
38576 swig_obj[0] = args;
38577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38578 if (!SWIG_IsOK(res1)) {
38579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38580 }
38581 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38582 {
38583 PyThreadState* __tstate = wxPyBeginAllowThreads();
38584 {
38585 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38586 result = (wxArrayString *) &_result_ref;
38587 }
38588 wxPyEndAllowThreads(__tstate);
38589 if (PyErr_Occurred()) SWIG_fail;
38590 }
38591 {
38592 resultobj = wxArrayString2PyList_helper(*result);
38593 }
38594 return resultobj;
38595 fail:
38596 return NULL;
38597 }
38598
38599
38600 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38601 PyObject *resultobj = 0;
38602 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38603 wxArrayString *arg2 = 0 ;
38604 void *argp1 = 0 ;
38605 int res1 = 0 ;
38606 bool temp2 = false ;
38607 PyObject * obj0 = 0 ;
38608 PyObject * obj1 = 0 ;
38609 char * kwnames[] = {
38610 (char *) "self",(char *) "docwriters", NULL
38611 };
38612
38613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38615 if (!SWIG_IsOK(res1)) {
38616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38617 }
38618 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38619 {
38620 if (! PySequence_Check(obj1)) {
38621 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38622 SWIG_fail;
38623 }
38624 arg2 = new wxArrayString;
38625 temp2 = true;
38626 int i, len=PySequence_Length(obj1);
38627 for (i=0; i<len; i++) {
38628 PyObject* item = PySequence_GetItem(obj1, i);
38629 wxString* s = wxString_in_helper(item);
38630 if (PyErr_Occurred()) SWIG_fail;
38631 arg2->Add(*s);
38632 delete s;
38633 Py_DECREF(item);
38634 }
38635 }
38636 {
38637 PyThreadState* __tstate = wxPyBeginAllowThreads();
38638 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38639 wxPyEndAllowThreads(__tstate);
38640 if (PyErr_Occurred()) SWIG_fail;
38641 }
38642 resultobj = SWIG_Py_Void();
38643 {
38644 if (temp2) delete arg2;
38645 }
38646 return resultobj;
38647 fail:
38648 {
38649 if (temp2) delete arg2;
38650 }
38651 return NULL;
38652 }
38653
38654
38655 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38656 PyObject *resultobj = 0;
38657 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38658 wxString *arg2 = 0 ;
38659 void *argp1 = 0 ;
38660 int res1 = 0 ;
38661 bool temp2 = false ;
38662 PyObject * obj0 = 0 ;
38663 PyObject * obj1 = 0 ;
38664 char * kwnames[] = {
38665 (char *) "self",(char *) "docwriter", NULL
38666 };
38667
38668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38670 if (!SWIG_IsOK(res1)) {
38671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38672 }
38673 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38674 {
38675 arg2 = wxString_in_helper(obj1);
38676 if (arg2 == NULL) SWIG_fail;
38677 temp2 = true;
38678 }
38679 {
38680 PyThreadState* __tstate = wxPyBeginAllowThreads();
38681 (arg1)->AddDocWriter((wxString const &)*arg2);
38682 wxPyEndAllowThreads(__tstate);
38683 if (PyErr_Occurred()) SWIG_fail;
38684 }
38685 resultobj = SWIG_Py_Void();
38686 {
38687 if (temp2)
38688 delete arg2;
38689 }
38690 return resultobj;
38691 fail:
38692 {
38693 if (temp2)
38694 delete arg2;
38695 }
38696 return NULL;
38697 }
38698
38699
38700 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38701 PyObject *resultobj = 0;
38702 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38703 bool result;
38704 void *argp1 = 0 ;
38705 int res1 = 0 ;
38706 PyObject *swig_obj[1] ;
38707
38708 if (!args) SWIG_fail;
38709 swig_obj[0] = args;
38710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38711 if (!SWIG_IsOK(res1)) {
38712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38713 }
38714 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38715 {
38716 PyThreadState* __tstate = wxPyBeginAllowThreads();
38717 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38718 wxPyEndAllowThreads(__tstate);
38719 if (PyErr_Occurred()) SWIG_fail;
38720 }
38721 {
38722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38723 }
38724 return resultobj;
38725 fail:
38726 return NULL;
38727 }
38728
38729
38730 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38731 PyObject *resultobj = 0;
38732 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38733 wxArrayString *result = 0 ;
38734 void *argp1 = 0 ;
38735 int res1 = 0 ;
38736 PyObject *swig_obj[1] ;
38737
38738 if (!args) SWIG_fail;
38739 swig_obj[0] = args;
38740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38741 if (!SWIG_IsOK(res1)) {
38742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38743 }
38744 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38745 {
38746 PyThreadState* __tstate = wxPyBeginAllowThreads();
38747 {
38748 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38749 result = (wxArrayString *) &_result_ref;
38750 }
38751 wxPyEndAllowThreads(__tstate);
38752 if (PyErr_Occurred()) SWIG_fail;
38753 }
38754 {
38755 resultobj = wxArrayString2PyList_helper(*result);
38756 }
38757 return resultobj;
38758 fail:
38759 return NULL;
38760 }
38761
38762
38763 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38764 PyObject *resultobj = 0;
38765 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38766 wxArrayString *arg2 = 0 ;
38767 void *argp1 = 0 ;
38768 int res1 = 0 ;
38769 bool temp2 = false ;
38770 PyObject * obj0 = 0 ;
38771 PyObject * obj1 = 0 ;
38772 char * kwnames[] = {
38773 (char *) "self",(char *) "artists", NULL
38774 };
38775
38776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38778 if (!SWIG_IsOK(res1)) {
38779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38780 }
38781 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38782 {
38783 if (! PySequence_Check(obj1)) {
38784 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38785 SWIG_fail;
38786 }
38787 arg2 = new wxArrayString;
38788 temp2 = true;
38789 int i, len=PySequence_Length(obj1);
38790 for (i=0; i<len; i++) {
38791 PyObject* item = PySequence_GetItem(obj1, i);
38792 wxString* s = wxString_in_helper(item);
38793 if (PyErr_Occurred()) SWIG_fail;
38794 arg2->Add(*s);
38795 delete s;
38796 Py_DECREF(item);
38797 }
38798 }
38799 {
38800 PyThreadState* __tstate = wxPyBeginAllowThreads();
38801 (arg1)->SetArtists((wxArrayString const &)*arg2);
38802 wxPyEndAllowThreads(__tstate);
38803 if (PyErr_Occurred()) SWIG_fail;
38804 }
38805 resultobj = SWIG_Py_Void();
38806 {
38807 if (temp2) delete arg2;
38808 }
38809 return resultobj;
38810 fail:
38811 {
38812 if (temp2) delete arg2;
38813 }
38814 return NULL;
38815 }
38816
38817
38818 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38819 PyObject *resultobj = 0;
38820 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38821 wxString *arg2 = 0 ;
38822 void *argp1 = 0 ;
38823 int res1 = 0 ;
38824 bool temp2 = false ;
38825 PyObject * obj0 = 0 ;
38826 PyObject * obj1 = 0 ;
38827 char * kwnames[] = {
38828 (char *) "self",(char *) "artist", NULL
38829 };
38830
38831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38833 if (!SWIG_IsOK(res1)) {
38834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38835 }
38836 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38837 {
38838 arg2 = wxString_in_helper(obj1);
38839 if (arg2 == NULL) SWIG_fail;
38840 temp2 = true;
38841 }
38842 {
38843 PyThreadState* __tstate = wxPyBeginAllowThreads();
38844 (arg1)->AddArtist((wxString const &)*arg2);
38845 wxPyEndAllowThreads(__tstate);
38846 if (PyErr_Occurred()) SWIG_fail;
38847 }
38848 resultobj = SWIG_Py_Void();
38849 {
38850 if (temp2)
38851 delete arg2;
38852 }
38853 return resultobj;
38854 fail:
38855 {
38856 if (temp2)
38857 delete arg2;
38858 }
38859 return NULL;
38860 }
38861
38862
38863 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38864 PyObject *resultobj = 0;
38865 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38866 bool result;
38867 void *argp1 = 0 ;
38868 int res1 = 0 ;
38869 PyObject *swig_obj[1] ;
38870
38871 if (!args) SWIG_fail;
38872 swig_obj[0] = args;
38873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38874 if (!SWIG_IsOK(res1)) {
38875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38876 }
38877 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38878 {
38879 PyThreadState* __tstate = wxPyBeginAllowThreads();
38880 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38881 wxPyEndAllowThreads(__tstate);
38882 if (PyErr_Occurred()) SWIG_fail;
38883 }
38884 {
38885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38886 }
38887 return resultobj;
38888 fail:
38889 return NULL;
38890 }
38891
38892
38893 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38894 PyObject *resultobj = 0;
38895 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38896 wxArrayString *result = 0 ;
38897 void *argp1 = 0 ;
38898 int res1 = 0 ;
38899 PyObject *swig_obj[1] ;
38900
38901 if (!args) SWIG_fail;
38902 swig_obj[0] = args;
38903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38904 if (!SWIG_IsOK(res1)) {
38905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38906 }
38907 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38908 {
38909 PyThreadState* __tstate = wxPyBeginAllowThreads();
38910 {
38911 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38912 result = (wxArrayString *) &_result_ref;
38913 }
38914 wxPyEndAllowThreads(__tstate);
38915 if (PyErr_Occurred()) SWIG_fail;
38916 }
38917 {
38918 resultobj = wxArrayString2PyList_helper(*result);
38919 }
38920 return resultobj;
38921 fail:
38922 return NULL;
38923 }
38924
38925
38926 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38927 PyObject *resultobj = 0;
38928 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38929 wxArrayString *arg2 = 0 ;
38930 void *argp1 = 0 ;
38931 int res1 = 0 ;
38932 bool temp2 = false ;
38933 PyObject * obj0 = 0 ;
38934 PyObject * obj1 = 0 ;
38935 char * kwnames[] = {
38936 (char *) "self",(char *) "translators", NULL
38937 };
38938
38939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38941 if (!SWIG_IsOK(res1)) {
38942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38943 }
38944 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38945 {
38946 if (! PySequence_Check(obj1)) {
38947 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38948 SWIG_fail;
38949 }
38950 arg2 = new wxArrayString;
38951 temp2 = true;
38952 int i, len=PySequence_Length(obj1);
38953 for (i=0; i<len; i++) {
38954 PyObject* item = PySequence_GetItem(obj1, i);
38955 wxString* s = wxString_in_helper(item);
38956 if (PyErr_Occurred()) SWIG_fail;
38957 arg2->Add(*s);
38958 delete s;
38959 Py_DECREF(item);
38960 }
38961 }
38962 {
38963 PyThreadState* __tstate = wxPyBeginAllowThreads();
38964 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38965 wxPyEndAllowThreads(__tstate);
38966 if (PyErr_Occurred()) SWIG_fail;
38967 }
38968 resultobj = SWIG_Py_Void();
38969 {
38970 if (temp2) delete arg2;
38971 }
38972 return resultobj;
38973 fail:
38974 {
38975 if (temp2) delete arg2;
38976 }
38977 return NULL;
38978 }
38979
38980
38981 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38982 PyObject *resultobj = 0;
38983 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38984 wxString *arg2 = 0 ;
38985 void *argp1 = 0 ;
38986 int res1 = 0 ;
38987 bool temp2 = false ;
38988 PyObject * obj0 = 0 ;
38989 PyObject * obj1 = 0 ;
38990 char * kwnames[] = {
38991 (char *) "self",(char *) "translator", NULL
38992 };
38993
38994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
38995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38996 if (!SWIG_IsOK(res1)) {
38997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38998 }
38999 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39000 {
39001 arg2 = wxString_in_helper(obj1);
39002 if (arg2 == NULL) SWIG_fail;
39003 temp2 = true;
39004 }
39005 {
39006 PyThreadState* __tstate = wxPyBeginAllowThreads();
39007 (arg1)->AddTranslator((wxString const &)*arg2);
39008 wxPyEndAllowThreads(__tstate);
39009 if (PyErr_Occurred()) SWIG_fail;
39010 }
39011 resultobj = SWIG_Py_Void();
39012 {
39013 if (temp2)
39014 delete arg2;
39015 }
39016 return resultobj;
39017 fail:
39018 {
39019 if (temp2)
39020 delete arg2;
39021 }
39022 return NULL;
39023 }
39024
39025
39026 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39027 PyObject *resultobj = 0;
39028 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39029 bool result;
39030 void *argp1 = 0 ;
39031 int res1 = 0 ;
39032 PyObject *swig_obj[1] ;
39033
39034 if (!args) SWIG_fail;
39035 swig_obj[0] = args;
39036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39037 if (!SWIG_IsOK(res1)) {
39038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39039 }
39040 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39041 {
39042 PyThreadState* __tstate = wxPyBeginAllowThreads();
39043 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
39044 wxPyEndAllowThreads(__tstate);
39045 if (PyErr_Occurred()) SWIG_fail;
39046 }
39047 {
39048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39049 }
39050 return resultobj;
39051 fail:
39052 return NULL;
39053 }
39054
39055
39056 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39057 PyObject *resultobj = 0;
39058 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39059 wxArrayString *result = 0 ;
39060 void *argp1 = 0 ;
39061 int res1 = 0 ;
39062 PyObject *swig_obj[1] ;
39063
39064 if (!args) SWIG_fail;
39065 swig_obj[0] = args;
39066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39067 if (!SWIG_IsOK(res1)) {
39068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39069 }
39070 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39071 {
39072 PyThreadState* __tstate = wxPyBeginAllowThreads();
39073 {
39074 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
39075 result = (wxArrayString *) &_result_ref;
39076 }
39077 wxPyEndAllowThreads(__tstate);
39078 if (PyErr_Occurred()) SWIG_fail;
39079 }
39080 {
39081 resultobj = wxArrayString2PyList_helper(*result);
39082 }
39083 return resultobj;
39084 fail:
39085 return NULL;
39086 }
39087
39088
39089 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39090 PyObject *resultobj = 0;
39091 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39092 bool result;
39093 void *argp1 = 0 ;
39094 int res1 = 0 ;
39095 PyObject *swig_obj[1] ;
39096
39097 if (!args) SWIG_fail;
39098 swig_obj[0] = args;
39099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39100 if (!SWIG_IsOK(res1)) {
39101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39102 }
39103 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39104 {
39105 PyThreadState* __tstate = wxPyBeginAllowThreads();
39106 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39107 wxPyEndAllowThreads(__tstate);
39108 if (PyErr_Occurred()) SWIG_fail;
39109 }
39110 {
39111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39112 }
39113 return resultobj;
39114 fail:
39115 return NULL;
39116 }
39117
39118
39119 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39120 PyObject *resultobj = 0;
39121 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39122 wxString result;
39123 void *argp1 = 0 ;
39124 int res1 = 0 ;
39125 PyObject *swig_obj[1] ;
39126
39127 if (!args) SWIG_fail;
39128 swig_obj[0] = args;
39129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39130 if (!SWIG_IsOK(res1)) {
39131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39132 }
39133 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39134 {
39135 PyThreadState* __tstate = wxPyBeginAllowThreads();
39136 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39137 wxPyEndAllowThreads(__tstate);
39138 if (PyErr_Occurred()) SWIG_fail;
39139 }
39140 {
39141 #if wxUSE_UNICODE
39142 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39143 #else
39144 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39145 #endif
39146 }
39147 return resultobj;
39148 fail:
39149 return NULL;
39150 }
39151
39152
39153 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39154 PyObject *obj;
39155 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39156 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39157 return SWIG_Py_Void();
39158 }
39159
39160 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39161 return SWIG_Python_InitShadowInstance(args);
39162 }
39163
39164 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39165 PyObject *resultobj = 0;
39166 wxAboutDialogInfo *arg1 = 0 ;
39167 void *argp1 = 0 ;
39168 int res1 = 0 ;
39169 PyObject * obj0 = 0 ;
39170 char * kwnames[] = {
39171 (char *) "info", NULL
39172 };
39173
39174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39175 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39176 if (!SWIG_IsOK(res1)) {
39177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39178 }
39179 if (!argp1) {
39180 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39181 }
39182 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39183 {
39184 PyThreadState* __tstate = wxPyBeginAllowThreads();
39185 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39186 wxPyEndAllowThreads(__tstate);
39187 if (PyErr_Occurred()) SWIG_fail;
39188 }
39189 resultobj = SWIG_Py_Void();
39190 return resultobj;
39191 fail:
39192 return NULL;
39193 }
39194
39195
39196 static PyMethodDef SwigMethods[] = {
39197 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39198 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39199 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39200 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39201 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39202 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39203 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39204 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39205 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39206 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39207 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39208 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39209 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39210 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39211 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39212 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39213 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39214 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39215 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39216 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39217 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39218 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39219 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39220 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39221 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39222 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
39223 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39224 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39225 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39226 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
39227 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39228 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39229 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39230 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39231 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39232 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39233 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39234 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39235 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39236 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39237 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39238 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39239 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39240 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39241 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39242 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39243 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39244 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39245 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39246 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39247 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39248 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39249 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39250 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39251 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39252 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39253 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39254 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39255 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39256 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39257 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39258 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39259 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39260 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39261 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39262 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39263 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39264 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39265 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39266 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39267 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39268 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39269 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39270 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39271 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39272 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39273 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39274 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39275 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39276 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39277 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39278 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39279 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39280 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39281 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39282 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39283 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39284 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39285 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39286 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39287 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39288 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39289 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39290 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39291 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39292 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39293 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39294 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39295 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39296 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39297 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39298 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39299 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39300 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39301 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39302 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39303 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39304 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39305 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39306 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39307 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39308 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39309 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39310 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39311 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39312 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39313 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39314 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39315 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39316 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39317 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39318 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39319 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39320 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39321 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39322 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39323 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39324 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39325 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39326 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39327 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39328 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39329 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39330 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39331 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39332 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39333 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39334 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39335 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39336 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39337 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39338 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39339 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39340 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39341 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39342 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39343 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39344 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39345 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39346 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39347 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39348 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39349 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39350 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39351 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39352 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39353 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39354 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39355 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39356 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39357 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39358 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39359 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39360 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39361 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39362 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39363 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39364 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39365 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39366 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39367 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39368 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39369 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39370 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39371 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39372 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39373 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39374 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39375 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39376 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39377 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39378 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39379 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39380 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39381 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39382 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39383 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39384 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39385 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39386 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39387 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39388 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39389 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39390 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39391 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39392 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39393 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39394 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39395 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39396 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39397 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39398 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39399 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39400 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39401 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39402 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39403 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39404 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39405 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39406 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39407 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39408 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39409 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39410 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39411 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39412 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39413 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39414 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39415 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39416 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39417 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39418 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39419 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39420 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39421 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39422 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39423 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39424 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39425 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39426 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39427 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39428 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39429 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39430 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39431 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39432 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39433 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39434 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39435 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39436 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39437 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39438 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39439 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39440 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39441 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39442 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39443 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39444 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39445 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39446 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39447 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39448 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39449 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39450 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39451 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39452 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39453 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39454 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39455 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39456 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39457 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39458 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39459 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39460 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39461 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39462 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39463 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39464 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39465 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39466 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39467 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39468 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39469 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39470 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39471 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39472 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39473 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39474 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39475 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39476 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39477 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39478 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39479 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39480 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39481 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39482 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39483 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39484 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39485 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39486 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39487 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39488 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39489 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39490 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39491 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39492 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39493 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39494 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39495 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39496 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39497 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39498 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39499 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39500 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39501 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39502 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39503 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39504 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39505 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39506 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39507 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39508 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39509 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39510 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39511 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39512 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39513 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39514 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39515 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39516 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39517 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39518 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39519 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39520 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39521 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39522 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39523 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39524 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39525 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39526 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39527 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39528 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39529 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39530 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39531 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39532 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39533 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39534 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39535 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39536 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39537 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39538 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39539 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39540 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39541 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39542 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39543 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39544 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39545 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39546 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39547 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39548 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39549 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39550 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39551 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39552 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39553 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39554 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39555 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39556 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39557 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39558 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39559 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39560 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39561 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39562 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39563 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39564 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39565 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39566 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39567 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39568 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39569 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39570 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39571 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39572 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39573 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39574 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39575 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39576 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39577 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39578 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39579 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39580 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39581 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39582 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39583 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39584 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39585 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39586 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39587 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39588 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39589 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39590 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39591 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39592 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39593 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39594 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39595 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39596 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39597 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39598 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39599 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39600 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39601 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39602 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39603 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39604 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39605 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39606 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39607 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39608 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39609 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39610 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39611 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39612 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39613 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39614 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39615 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39616 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39617 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39618 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39619 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39620 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39621 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39622 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39623 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39624 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39625 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39626 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39627 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39628 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39629 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39630 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39631 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39632 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39633 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39634 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39635 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39636 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39637 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39638 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39639 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39640 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39641 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39642 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39643 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39644 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39645 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39646 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39647 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39648 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39649 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39650 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39651 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39652 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39653 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39654 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39655 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39656 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39657 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39658 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39659 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39660 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39661 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39662 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39663 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39664 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39665 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39666 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39667 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39668 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39669 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39671 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39672 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39673 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39674 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39675 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39676 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39677 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39678 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39679 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39680 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39681 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39682 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39683 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39684 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39685 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39686 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39687 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39688 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39689 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39690 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39691 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39692 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39693 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39694 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39695 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39696 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39697 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39698 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39699 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39700 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39702 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39703 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39704 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39705 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39706 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39707 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39708 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39709 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39710 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39711 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39713 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39715 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39716 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39719 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39720 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39721 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39722 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39723 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39724 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39725 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39726 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39727 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39728 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39729 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39730 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39732 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39733 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39734 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39735 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39736 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39737 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39738 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39739 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39740 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39741 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39742 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39743 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39744 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39745 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39746 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39747 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39748 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39749 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39750 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39751 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39754 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39755 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39757 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39759 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39761 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39762 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39763 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39764 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39765 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39766 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39767 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39768 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39769 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39770 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39771 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39772 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39773 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39774 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39775 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39776 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39777 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39778 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39779 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39780 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39781 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39782 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39783 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39784 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39785 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39786 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39787 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39788 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39789 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39790 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39791 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39792 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39793 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39801 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39802 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39803 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39804 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39805 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39807 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39808 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39809 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39810 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39811 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39812 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39814 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39815 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39816 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39817 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39818 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39819 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39821 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39822 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39823 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39824 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39825 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39826 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39827 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39828 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39829 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39830 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39831 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39832 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39833 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39834 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39835 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39836 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39837 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39838 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39839 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39840 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39841 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39842 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39844 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39845 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39846 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39847 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39848 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39849 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39850 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39851 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39852 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39853 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39854 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39855 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39856 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39857 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39858 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39859 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39860 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39861 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39862 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39863 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39864 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39865 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39866 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39867 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39868 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39869 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39870 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39871 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39872 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39873 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39874 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39875 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39876 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39877 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39878 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39879 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39880 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39881 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39882 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39883 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39884 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39885 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39886 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39887 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39888 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39889 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39890 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39891 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39892 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39893 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39894 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39895 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39896 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39897 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39898 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39899 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39900 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39901 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39902 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39903 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39904 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39905 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39906 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39907 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39908 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39909 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39910 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39911 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39912 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39913 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39914 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39915 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39916 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39917 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39918 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39919 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39920 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39921 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39922 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39923 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39924 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39925 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39926 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39927 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39928 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39929 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39930 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39931 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39932 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39933 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39934 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39935 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39936 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39937 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39938 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39939 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39940 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39941 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39942 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39943 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39944 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39945 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39946 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39947 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39948 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39949 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39950 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39951 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39952 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39953 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39954 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39955 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39956 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39957 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39958 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39959 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39960 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39961 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39962 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39963 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39964 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39965 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39966 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
39967 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39968 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39969 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39970 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
39971 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39972 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
39973 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39974 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
39975 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
39976 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
39977 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39978 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
39979 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39980 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
39981 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39982 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
39983 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
39984 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39985 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
39986 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
39987 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39988 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39989 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
39990 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
39991 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
39992 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39993 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
39994 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
39995 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
39996 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39997 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
39998 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
39999 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
40000 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
40001 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
40002 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40003 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40004 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
40005 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
40006 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40007 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
40008 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
40009 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
40010 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
40011 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40012 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40013 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
40014 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
40015 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
40016 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
40017 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
40018 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
40019 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
40020 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
40021 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40022 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
40023 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
40024 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
40025 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
40026 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40027 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
40028 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
40029 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
40030 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
40031 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
40032 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
40033 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
40034 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
40035 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
40036 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
40037 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
40038 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40039 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
40040 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40041 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
40042 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
40043 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40044 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
40045 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
40046 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
40047 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
40048 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40049 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
40050 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
40051 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40052 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40053 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40054 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
40055 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40056 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
40057 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
40058 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
40059 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
40060 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
40061 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
40062 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40063 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
40064 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40065 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40066 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
40067 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40068 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40069 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
40070 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
40071 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
40072 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40073 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
40074 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40075 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40076 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
40077 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40078 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40079 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
40080 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
40081 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
40082 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
40083 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
40084 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
40085 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
40086 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
40087 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40088 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40089 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
40090 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
40091 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
40092 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
40093 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
40094 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
40095 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
40096 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
40097 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
40098 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
40099 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
40100 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
40101 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
40102 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
40103 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
40104 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40105 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40106 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40107 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40108 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40109 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40110 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40111 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40112 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40113 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40114 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40115 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40116 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40117 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40118 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40119 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40120 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40121 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40122 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40123 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40124 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40125 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40126 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40127 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40128 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40129 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40130 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40131 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40132 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40133 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40134 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40135 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40136 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40137 { (char *)"StandardPaths_GetExecutablePath", (PyCFunction)_wrap_StandardPaths_GetExecutablePath, METH_O, NULL},
40138 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40139 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40140 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40141 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40142 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40143 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40144 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40145 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40146 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40147 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40148 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40149 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40150 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40151 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40152 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40153 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40154 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40155 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40156 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40157 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40158 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40159 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40160 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40161 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40162 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40163 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40164 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40165 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40166 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40167 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40168 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40169 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40170 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40171 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40172 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40173 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40174 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40175 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40176 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40177 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40178 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40179 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40180 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40181 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40182 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40183 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40184 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40185 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40186 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40187 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40188 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40189 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40190 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40191 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40192 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40193 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40194 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40195 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40196 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40197 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40198 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40199 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40200 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40201 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40202 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40203 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40204 { NULL, NULL, 0, NULL }
40205 };
40206
40207
40208 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40209
40210 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40211 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40212 }
40213 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40214 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40215 }
40216 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40217 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40218 }
40219 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40220 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40221 }
40222 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40223 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40224 }
40225 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40226 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40227 }
40228 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40229 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40230 }
40231 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40232 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40233 }
40234 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40235 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40236 }
40237 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40238 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40239 }
40240 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40241 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40242 }
40243 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40244 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40245 }
40246 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40247 return (void *)((wxEvent *) ((wxPyEvent *) x));
40248 }
40249 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40250 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40251 }
40252 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40253 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40254 }
40255 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40256 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40257 }
40258 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40259 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40260 }
40261 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40262 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40263 }
40264 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40265 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40266 }
40267 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40268 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40269 }
40270 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40271 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40272 }
40273 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40274 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40275 }
40276 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40277 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40278 }
40279 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40280 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40281 }
40282 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40283 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40284 }
40285 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40286 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40287 }
40288 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40289 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40290 }
40291 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40292 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40293 }
40294 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40295 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40296 }
40297 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40298 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40299 }
40300 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40301 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40302 }
40303 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40304 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40305 }
40306 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40307 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40308 }
40309 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40310 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40311 }
40312 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40313 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40314 }
40315 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40316 return (void *)((wxEvent *) ((wxShowEvent *) x));
40317 }
40318 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40319 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40320 }
40321 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40322 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40323 }
40324 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40325 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40326 }
40327 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40328 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40329 }
40330 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40331 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40332 }
40333 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40334 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40335 }
40336 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40337 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40338 }
40339 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40340 return (void *)((wxConfigBase *) ((wxConfig *) x));
40341 }
40342 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40343 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40344 }
40345 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40346 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40347 }
40348 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40349 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40350 }
40351 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40352 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40353 }
40354 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40355 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40356 }
40357 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40358 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40359 }
40360 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40361 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40362 }
40363 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40364 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40365 }
40366 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40367 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40368 }
40369 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40370 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40371 }
40372 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40373 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40374 }
40375 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40376 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40377 }
40378 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40379 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40380 }
40381 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40382 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40383 }
40384 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40385 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40386 }
40387 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40388 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40389 }
40390 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40391 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40392 }
40393 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40394 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40395 }
40396 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40397 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40398 }
40399 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40400 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40401 }
40402 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40403 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40404 }
40405 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40406 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40407 }
40408 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40409 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40410 }
40411 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40412 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40413 }
40414 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40415 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40416 }
40417 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40418 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40419 }
40420 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40421 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40422 }
40423 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40424 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40425 }
40426 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40427 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40428 }
40429 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40430 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40431 }
40432 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40433 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40434 }
40435 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40436 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40437 }
40438 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40439 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40440 }
40441 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40442 return (void *)((wxObject *) ((wxSizerItem *) x));
40443 }
40444 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40445 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40446 }
40447 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40448 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40449 }
40450 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40451 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40452 }
40453 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40454 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40455 }
40456 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40457 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40458 }
40459 static void *_p_wxSizerTo_p_wxObject(void *x) {
40460 return (void *)((wxObject *) ((wxSizer *) x));
40461 }
40462 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40463 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40464 }
40465 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40466 return (void *)((wxObject *) ((wxFileHistory *) x));
40467 }
40468 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40469 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40470 }
40471 static void *_p_wxEventTo_p_wxObject(void *x) {
40472 return (void *)((wxObject *) ((wxEvent *) x));
40473 }
40474 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40475 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40476 }
40477 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40478 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40479 }
40480 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40481 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40482 }
40483 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40484 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40485 }
40486 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40487 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40488 }
40489 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40490 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40491 }
40492 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40493 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40494 }
40495 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40496 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40497 }
40498 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40499 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40500 }
40501 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40502 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40503 }
40504 static void *_p_wxControlTo_p_wxObject(void *x) {
40505 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40506 }
40507 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40508 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40509 }
40510 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40511 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40512 }
40513 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40514 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40515 }
40516 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40517 return (void *)((wxObject *) ((wxFSFile *) x));
40518 }
40519 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40520 return (void *)((wxObject *) ((wxClipboard *) x));
40521 }
40522 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40523 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40524 }
40525 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40526 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40527 }
40528 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40529 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40530 }
40531 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40532 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40533 }
40534 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40535 return (void *)((wxObject *) ((wxToolTip *) x));
40536 }
40537 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40538 return (void *)((wxObject *) ((wxMenuItem *) x));
40539 }
40540 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40541 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40542 }
40543 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40544 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40545 }
40546 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40547 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40548 }
40549 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40550 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40551 }
40552 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40553 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40554 }
40555 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40556 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40557 }
40558 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40559 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40560 }
40561 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40562 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40563 }
40564 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40565 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40566 }
40567 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40568 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40569 }
40570 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40571 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40572 }
40573 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40574 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40575 }
40576 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40577 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40578 }
40579 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40580 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40581 }
40582 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40583 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40584 }
40585 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40586 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40587 }
40588 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40589 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40590 }
40591 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40592 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40593 }
40594 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40595 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40596 }
40597 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40598 return (void *)((wxObject *) ((wxImageHandler *) x));
40599 }
40600 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40601 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40602 }
40603 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40604 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40605 }
40606 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
40607 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
40608 }
40609 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40610 return (void *)((wxObject *) ((wxEvtHandler *) x));
40611 }
40612 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40613 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40614 }
40615 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40616 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40617 }
40618 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40619 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40620 }
40621 static void *_p_wxImageTo_p_wxObject(void *x) {
40622 return (void *)((wxObject *) ((wxImage *) x));
40623 }
40624 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40625 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40626 }
40627 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40628 return (void *)((wxObject *) ((wxSystemOptions *) x));
40629 }
40630 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40631 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40632 }
40633 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40634 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40635 }
40636 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40637 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40638 }
40639 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40640 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40641 }
40642 static void *_p_wxWindowTo_p_wxObject(void *x) {
40643 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40644 }
40645 static void *_p_wxMenuTo_p_wxObject(void *x) {
40646 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40647 }
40648 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40649 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40650 }
40651 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40652 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40653 }
40654 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40655 return (void *)((wxObject *) ((wxFileSystem *) x));
40656 }
40657 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40658 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40659 }
40660 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40661 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40662 }
40663 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40664 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40665 }
40666 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40667 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40668 }
40669 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40670 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40671 }
40672 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40673 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40674 }
40675 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40676 return (void *)((wxObject *) ((wxBusyInfo *) x));
40677 }
40678 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40679 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40680 }
40681 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40682 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40683 }
40684 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40685 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40686 }
40687 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40688 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40689 }
40690 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40691 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40692 }
40693 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40694 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40695 }
40696 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40697 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40698 }
40699 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40700 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40701 }
40702 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40703 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40704 }
40705 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40706 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40707 }
40708 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40709 return (void *)((wxLog *) ((wxLogBuffer *) x));
40710 }
40711 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40712 return (void *)((wxLog *) ((wxLogStderr *) x));
40713 }
40714 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40715 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40716 }
40717 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40718 return (void *)((wxLog *) ((wxLogWindow *) x));
40719 }
40720 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40721 return (void *)((wxLog *) ((wxLogChain *) x));
40722 }
40723 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40724 return (void *)((wxLog *) ((wxLogGui *) x));
40725 }
40726 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40727 return (void *)((wxLog *) ((wxPyLog *) x));
40728 }
40729 static void *_p_wxControlTo_p_wxWindow(void *x) {
40730 return (void *)((wxWindow *) ((wxControl *) x));
40731 }
40732 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40733 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40734 }
40735 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40736 return (void *)((wxWindow *) ((wxMenuBar *) x));
40737 }
40738 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40739 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40740 }
40741 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40742 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40743 }
40744 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40745 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};
40746 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40747 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40748 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40749 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40750 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40751 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40752 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40753 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40754 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40755 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40756 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40757 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40758 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40759 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40760 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40761 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40762 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40763 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40764 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40765 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40766 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40767 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40768 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40769 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40770 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40771 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40772 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40773 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40774 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40775 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40776 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40777 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40778 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40779 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40780 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40781 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40782 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40783 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40784 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40785 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40786 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40787 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40788 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40789 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40790 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40791 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40792 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40793 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40794 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40795 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40796 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40797 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40798 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40799 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40800 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40801 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40802 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40803 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40804 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40805 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40806 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40807 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40808 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40809 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40810 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40811 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40812 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40813 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40814 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40815 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40816 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40817 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40818 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40819 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40820 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40821 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40822 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40823 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40824 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40825 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40826 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40827 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40828 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40829 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40830 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40831 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40832 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40833 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40834 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40835 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40836 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40837 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40838 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40839 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40840 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40841 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40842 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40843 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
40844 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40845 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40846 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40847 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40848 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40849 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40850 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40851 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40852 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40853 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40854 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40855 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40856 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40857 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40858 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40859 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40860 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40861 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40862 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40863 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40864 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
40865 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40866 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40867 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40868 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40869 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40870 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40871 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40872 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40873 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40874 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40875 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40876 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40877 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40878 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40879 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40880 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40881 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40882 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40883 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40884 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40885 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40886 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40887 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40888 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40889 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40890 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40891 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40892 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40893 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40894 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40895 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40896 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40897 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40898 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40899 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40900 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40901 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40902 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40903 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40904 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40905 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40906 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40907 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40908 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40909 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40910 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40911 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40912 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40913 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40914 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40915 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40916 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40917 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40918 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40919
40920 static swig_type_info *swig_type_initial[] = {
40921 &_swigt__p_char,
40922 &_swigt__p_form_ops_t,
40923 &_swigt__p_int,
40924 &_swigt__p_unsigned_char,
40925 &_swigt__p_unsigned_int,
40926 &_swigt__p_unsigned_long,
40927 &_swigt__p_void,
40928 &_swigt__p_wxANIHandler,
40929 &_swigt__p_wxAboutDialogInfo,
40930 &_swigt__p_wxAcceleratorTable,
40931 &_swigt__p_wxActivateEvent,
40932 &_swigt__p_wxArrayString,
40933 &_swigt__p_wxBMPHandler,
40934 &_swigt__p_wxBitmap,
40935 &_swigt__p_wxBitmapDataObject,
40936 &_swigt__p_wxBoxSizer,
40937 &_swigt__p_wxBusyCursor,
40938 &_swigt__p_wxBusyInfo,
40939 &_swigt__p_wxCURHandler,
40940 &_swigt__p_wxCaret,
40941 &_swigt__p_wxChar,
40942 &_swigt__p_wxChildFocusEvent,
40943 &_swigt__p_wxClipboard,
40944 &_swigt__p_wxClipboardLocker,
40945 &_swigt__p_wxClipboardTextEvent,
40946 &_swigt__p_wxCloseEvent,
40947 &_swigt__p_wxColour,
40948 &_swigt__p_wxCommandEvent,
40949 &_swigt__p_wxConfig,
40950 &_swigt__p_wxConfigBase,
40951 &_swigt__p_wxConfigPathChanger,
40952 &_swigt__p_wxContextMenuEvent,
40953 &_swigt__p_wxControl,
40954 &_swigt__p_wxControlWithItems,
40955 &_swigt__p_wxCursor,
40956 &_swigt__p_wxCustomDataObject,
40957 &_swigt__p_wxDC,
40958 &_swigt__p_wxDataFormat,
40959 &_swigt__p_wxDataObject,
40960 &_swigt__p_wxDataObjectComposite,
40961 &_swigt__p_wxDataObjectSimple,
40962 &_swigt__p_wxDateEvent,
40963 &_swigt__p_wxDateSpan,
40964 &_swigt__p_wxDateTime,
40965 &_swigt__p_wxDateTime__TimeZone,
40966 &_swigt__p_wxDisplay,
40967 &_swigt__p_wxDisplayChangedEvent,
40968 &_swigt__p_wxDropFilesEvent,
40969 &_swigt__p_wxDuplexMode,
40970 &_swigt__p_wxEraseEvent,
40971 &_swigt__p_wxEvent,
40972 &_swigt__p_wxEvtHandler,
40973 &_swigt__p_wxFSFile,
40974 &_swigt__p_wxFileConfig,
40975 &_swigt__p_wxFileDataObject,
40976 &_swigt__p_wxFileHistory,
40977 &_swigt__p_wxFileSystem,
40978 &_swigt__p_wxFileType,
40979 &_swigt__p_wxFileTypeInfo,
40980 &_swigt__p_wxFlexGridSizer,
40981 &_swigt__p_wxFocusEvent,
40982 &_swigt__p_wxFont,
40983 &_swigt__p_wxFrame,
40984 &_swigt__p_wxGBSizerItem,
40985 &_swigt__p_wxGIFHandler,
40986 &_swigt__p_wxGridBagSizer,
40987 &_swigt__p_wxGridSizer,
40988 &_swigt__p_wxICOHandler,
40989 &_swigt__p_wxIcon,
40990 &_swigt__p_wxIconizeEvent,
40991 &_swigt__p_wxIdleEvent,
40992 &_swigt__p_wxImage,
40993 &_swigt__p_wxImageHandler,
40994 &_swigt__p_wxIndividualLayoutConstraint,
40995 &_swigt__p_wxInitDialogEvent,
40996 &_swigt__p_wxJPEGHandler,
40997 &_swigt__p_wxJoystick,
40998 &_swigt__p_wxJoystickEvent,
40999 &_swigt__p_wxKeyEvent,
41000 &_swigt__p_wxKillError,
41001 &_swigt__p_wxLayoutConstraints,
41002 &_swigt__p_wxLog,
41003 &_swigt__p_wxLogBuffer,
41004 &_swigt__p_wxLogChain,
41005 &_swigt__p_wxLogGui,
41006 &_swigt__p_wxLogNull,
41007 &_swigt__p_wxLogStderr,
41008 &_swigt__p_wxLogTextCtrl,
41009 &_swigt__p_wxLogWindow,
41010 &_swigt__p_wxMaximizeEvent,
41011 &_swigt__p_wxMenu,
41012 &_swigt__p_wxMenuBar,
41013 &_swigt__p_wxMenuEvent,
41014 &_swigt__p_wxMenuItem,
41015 &_swigt__p_wxMetafile,
41016 &_swigt__p_wxMetafileDataObject,
41017 &_swigt__p_wxMimeTypesManager,
41018 &_swigt__p_wxMouseCaptureChangedEvent,
41019 &_swigt__p_wxMouseCaptureLostEvent,
41020 &_swigt__p_wxMouseEvent,
41021 &_swigt__p_wxMouseState,
41022 &_swigt__p_wxMoveEvent,
41023 &_swigt__p_wxMutexGuiLocker,
41024 &_swigt__p_wxNavigationKeyEvent,
41025 &_swigt__p_wxNcPaintEvent,
41026 &_swigt__p_wxNotifyEvent,
41027 &_swigt__p_wxObject,
41028 &_swigt__p_wxOutputStream,
41029 &_swigt__p_wxPCXHandler,
41030 &_swigt__p_wxPNGHandler,
41031 &_swigt__p_wxPNMHandler,
41032 &_swigt__p_wxPaintEvent,
41033 &_swigt__p_wxPaletteChangedEvent,
41034 &_swigt__p_wxPaperSize,
41035 &_swigt__p_wxPlatformInfo,
41036 &_swigt__p_wxPoint,
41037 &_swigt__p_wxPowerEvent,
41038 &_swigt__p_wxProcessEvent,
41039 &_swigt__p_wxPyApp,
41040 &_swigt__p_wxPyArtProvider,
41041 &_swigt__p_wxPyBitmapDataObject,
41042 &_swigt__p_wxPyCommandEvent,
41043 &_swigt__p_wxPyDataObjectSimple,
41044 &_swigt__p_wxPyDropSource,
41045 &_swigt__p_wxPyDropTarget,
41046 &_swigt__p_wxPyEvent,
41047 &_swigt__p_wxPyFileDropTarget,
41048 &_swigt__p_wxPyImageHandler,
41049 &_swigt__p_wxPyLog,
41050 &_swigt__p_wxPyProcess,
41051 &_swigt__p_wxPySizer,
41052 &_swigt__p_wxPyTextDataObject,
41053 &_swigt__p_wxPyTextDropTarget,
41054 &_swigt__p_wxPyTimer,
41055 &_swigt__p_wxPyTipProvider,
41056 &_swigt__p_wxPyValidator,
41057 &_swigt__p_wxQueryNewPaletteEvent,
41058 &_swigt__p_wxRect,
41059 &_swigt__p_wxScrollEvent,
41060 &_swigt__p_wxScrollWinEvent,
41061 &_swigt__p_wxSetCursorEvent,
41062 &_swigt__p_wxShowEvent,
41063 &_swigt__p_wxSingleInstanceChecker,
41064 &_swigt__p_wxSize,
41065 &_swigt__p_wxSizeEvent,
41066 &_swigt__p_wxSizer,
41067 &_swigt__p_wxSizerItem,
41068 &_swigt__p_wxSound,
41069 &_swigt__p_wxStandardPaths,
41070 &_swigt__p_wxStaticBoxSizer,
41071 &_swigt__p_wxStdDialogButtonSizer,
41072 &_swigt__p_wxStopWatch,
41073 &_swigt__p_wxString,
41074 &_swigt__p_wxSysColourChangedEvent,
41075 &_swigt__p_wxSystemOptions,
41076 &_swigt__p_wxSystemSettings,
41077 &_swigt__p_wxTGAHandler,
41078 &_swigt__p_wxTIFFHandler,
41079 &_swigt__p_wxTextCtrl,
41080 &_swigt__p_wxTextDataObject,
41081 &_swigt__p_wxTimeSpan,
41082 &_swigt__p_wxTimer,
41083 &_swigt__p_wxTimerEvent,
41084 &_swigt__p_wxTimerRunner,
41085 &_swigt__p_wxTipProvider,
41086 &_swigt__p_wxToolTip,
41087 &_swigt__p_wxURLDataObject,
41088 &_swigt__p_wxUpdateUIEvent,
41089 &_swigt__p_wxValidator,
41090 &_swigt__p_wxVideoMode,
41091 &_swigt__p_wxWindow,
41092 &_swigt__p_wxWindowCreateEvent,
41093 &_swigt__p_wxWindowDestroyEvent,
41094 &_swigt__p_wxWindowDisabler,
41095 &_swigt__p_wxXPMHandler,
41096 };
41097
41098 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
41099 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
41100 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
41101 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
41102 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
41103 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
41104 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
41105 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
41106 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
41107 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41108 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}};
41109 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41110 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41111 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41112 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41113 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41114 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41115 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41116 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41117 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}};
41118 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41119 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41120 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41121 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41122 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41123 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}};
41124 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41125 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}};
41126 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41127 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41128 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41129 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41130 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41131 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41132 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41133 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41134 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41135 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41136 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41137 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41138 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41139 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41140 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41141 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41142 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41143 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41144 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41145 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41146 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41150 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41151 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41152 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41153 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41154 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41157 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41158 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41159 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41160 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41161 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41162 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41163 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41164 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41165 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41166 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41167 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41168 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41169 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}};
41170 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41171 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41172 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41173 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41174 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41175 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41176 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}};
41177 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41178 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41179 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41180 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41181 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41182 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41183 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41184 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41185 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41186 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41187 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41188 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}};
41189 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41190 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41191 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41192 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41193 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41194 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41195 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41196 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41197 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
41198 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41199 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41200 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41201 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41202 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41203 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41204 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41205 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41206 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41207 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41208 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41209 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41210 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41211 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41212 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41213 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41214 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41215 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41216 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41217 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
41218 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41219 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41220 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41221 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41222 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41223 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41224 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41225 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41226 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41227 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41228 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41229 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41230 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41231 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41232 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41233 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
41234 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41235 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41236 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41237 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41238 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41239 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41240 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41241 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41242 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41243 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41244 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}};
41245 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41246 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41247 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41248 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41249 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41250 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41251 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41252 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41253 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41254 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41255 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41256 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41257 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41258 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41259 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41260 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41261 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41262 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}};
41263 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41264 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41265 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41266 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41267 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}};
41268 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41269 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41270 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41271 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}};
41272 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41273
41274 static swig_cast_info *swig_cast_initial[] = {
41275 _swigc__p_char,
41276 _swigc__p_form_ops_t,
41277 _swigc__p_int,
41278 _swigc__p_unsigned_char,
41279 _swigc__p_unsigned_int,
41280 _swigc__p_unsigned_long,
41281 _swigc__p_void,
41282 _swigc__p_wxANIHandler,
41283 _swigc__p_wxAboutDialogInfo,
41284 _swigc__p_wxAcceleratorTable,
41285 _swigc__p_wxActivateEvent,
41286 _swigc__p_wxArrayString,
41287 _swigc__p_wxBMPHandler,
41288 _swigc__p_wxBitmap,
41289 _swigc__p_wxBitmapDataObject,
41290 _swigc__p_wxBoxSizer,
41291 _swigc__p_wxBusyCursor,
41292 _swigc__p_wxBusyInfo,
41293 _swigc__p_wxCURHandler,
41294 _swigc__p_wxCaret,
41295 _swigc__p_wxChar,
41296 _swigc__p_wxChildFocusEvent,
41297 _swigc__p_wxClipboard,
41298 _swigc__p_wxClipboardLocker,
41299 _swigc__p_wxClipboardTextEvent,
41300 _swigc__p_wxCloseEvent,
41301 _swigc__p_wxColour,
41302 _swigc__p_wxCommandEvent,
41303 _swigc__p_wxConfig,
41304 _swigc__p_wxConfigBase,
41305 _swigc__p_wxConfigPathChanger,
41306 _swigc__p_wxContextMenuEvent,
41307 _swigc__p_wxControl,
41308 _swigc__p_wxControlWithItems,
41309 _swigc__p_wxCursor,
41310 _swigc__p_wxCustomDataObject,
41311 _swigc__p_wxDC,
41312 _swigc__p_wxDataFormat,
41313 _swigc__p_wxDataObject,
41314 _swigc__p_wxDataObjectComposite,
41315 _swigc__p_wxDataObjectSimple,
41316 _swigc__p_wxDateEvent,
41317 _swigc__p_wxDateSpan,
41318 _swigc__p_wxDateTime,
41319 _swigc__p_wxDateTime__TimeZone,
41320 _swigc__p_wxDisplay,
41321 _swigc__p_wxDisplayChangedEvent,
41322 _swigc__p_wxDropFilesEvent,
41323 _swigc__p_wxDuplexMode,
41324 _swigc__p_wxEraseEvent,
41325 _swigc__p_wxEvent,
41326 _swigc__p_wxEvtHandler,
41327 _swigc__p_wxFSFile,
41328 _swigc__p_wxFileConfig,
41329 _swigc__p_wxFileDataObject,
41330 _swigc__p_wxFileHistory,
41331 _swigc__p_wxFileSystem,
41332 _swigc__p_wxFileType,
41333 _swigc__p_wxFileTypeInfo,
41334 _swigc__p_wxFlexGridSizer,
41335 _swigc__p_wxFocusEvent,
41336 _swigc__p_wxFont,
41337 _swigc__p_wxFrame,
41338 _swigc__p_wxGBSizerItem,
41339 _swigc__p_wxGIFHandler,
41340 _swigc__p_wxGridBagSizer,
41341 _swigc__p_wxGridSizer,
41342 _swigc__p_wxICOHandler,
41343 _swigc__p_wxIcon,
41344 _swigc__p_wxIconizeEvent,
41345 _swigc__p_wxIdleEvent,
41346 _swigc__p_wxImage,
41347 _swigc__p_wxImageHandler,
41348 _swigc__p_wxIndividualLayoutConstraint,
41349 _swigc__p_wxInitDialogEvent,
41350 _swigc__p_wxJPEGHandler,
41351 _swigc__p_wxJoystick,
41352 _swigc__p_wxJoystickEvent,
41353 _swigc__p_wxKeyEvent,
41354 _swigc__p_wxKillError,
41355 _swigc__p_wxLayoutConstraints,
41356 _swigc__p_wxLog,
41357 _swigc__p_wxLogBuffer,
41358 _swigc__p_wxLogChain,
41359 _swigc__p_wxLogGui,
41360 _swigc__p_wxLogNull,
41361 _swigc__p_wxLogStderr,
41362 _swigc__p_wxLogTextCtrl,
41363 _swigc__p_wxLogWindow,
41364 _swigc__p_wxMaximizeEvent,
41365 _swigc__p_wxMenu,
41366 _swigc__p_wxMenuBar,
41367 _swigc__p_wxMenuEvent,
41368 _swigc__p_wxMenuItem,
41369 _swigc__p_wxMetafile,
41370 _swigc__p_wxMetafileDataObject,
41371 _swigc__p_wxMimeTypesManager,
41372 _swigc__p_wxMouseCaptureChangedEvent,
41373 _swigc__p_wxMouseCaptureLostEvent,
41374 _swigc__p_wxMouseEvent,
41375 _swigc__p_wxMouseState,
41376 _swigc__p_wxMoveEvent,
41377 _swigc__p_wxMutexGuiLocker,
41378 _swigc__p_wxNavigationKeyEvent,
41379 _swigc__p_wxNcPaintEvent,
41380 _swigc__p_wxNotifyEvent,
41381 _swigc__p_wxObject,
41382 _swigc__p_wxOutputStream,
41383 _swigc__p_wxPCXHandler,
41384 _swigc__p_wxPNGHandler,
41385 _swigc__p_wxPNMHandler,
41386 _swigc__p_wxPaintEvent,
41387 _swigc__p_wxPaletteChangedEvent,
41388 _swigc__p_wxPaperSize,
41389 _swigc__p_wxPlatformInfo,
41390 _swigc__p_wxPoint,
41391 _swigc__p_wxPowerEvent,
41392 _swigc__p_wxProcessEvent,
41393 _swigc__p_wxPyApp,
41394 _swigc__p_wxPyArtProvider,
41395 _swigc__p_wxPyBitmapDataObject,
41396 _swigc__p_wxPyCommandEvent,
41397 _swigc__p_wxPyDataObjectSimple,
41398 _swigc__p_wxPyDropSource,
41399 _swigc__p_wxPyDropTarget,
41400 _swigc__p_wxPyEvent,
41401 _swigc__p_wxPyFileDropTarget,
41402 _swigc__p_wxPyImageHandler,
41403 _swigc__p_wxPyLog,
41404 _swigc__p_wxPyProcess,
41405 _swigc__p_wxPySizer,
41406 _swigc__p_wxPyTextDataObject,
41407 _swigc__p_wxPyTextDropTarget,
41408 _swigc__p_wxPyTimer,
41409 _swigc__p_wxPyTipProvider,
41410 _swigc__p_wxPyValidator,
41411 _swigc__p_wxQueryNewPaletteEvent,
41412 _swigc__p_wxRect,
41413 _swigc__p_wxScrollEvent,
41414 _swigc__p_wxScrollWinEvent,
41415 _swigc__p_wxSetCursorEvent,
41416 _swigc__p_wxShowEvent,
41417 _swigc__p_wxSingleInstanceChecker,
41418 _swigc__p_wxSize,
41419 _swigc__p_wxSizeEvent,
41420 _swigc__p_wxSizer,
41421 _swigc__p_wxSizerItem,
41422 _swigc__p_wxSound,
41423 _swigc__p_wxStandardPaths,
41424 _swigc__p_wxStaticBoxSizer,
41425 _swigc__p_wxStdDialogButtonSizer,
41426 _swigc__p_wxStopWatch,
41427 _swigc__p_wxString,
41428 _swigc__p_wxSysColourChangedEvent,
41429 _swigc__p_wxSystemOptions,
41430 _swigc__p_wxSystemSettings,
41431 _swigc__p_wxTGAHandler,
41432 _swigc__p_wxTIFFHandler,
41433 _swigc__p_wxTextCtrl,
41434 _swigc__p_wxTextDataObject,
41435 _swigc__p_wxTimeSpan,
41436 _swigc__p_wxTimer,
41437 _swigc__p_wxTimerEvent,
41438 _swigc__p_wxTimerRunner,
41439 _swigc__p_wxTipProvider,
41440 _swigc__p_wxToolTip,
41441 _swigc__p_wxURLDataObject,
41442 _swigc__p_wxUpdateUIEvent,
41443 _swigc__p_wxValidator,
41444 _swigc__p_wxVideoMode,
41445 _swigc__p_wxWindow,
41446 _swigc__p_wxWindowCreateEvent,
41447 _swigc__p_wxWindowDestroyEvent,
41448 _swigc__p_wxWindowDisabler,
41449 _swigc__p_wxXPMHandler,
41450 };
41451
41452
41453 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41454
41455 static swig_const_info swig_const_table[] = {
41456 {0, 0, 0, 0.0, 0, 0}};
41457
41458 #ifdef __cplusplus
41459 }
41460 #endif
41461 /* -----------------------------------------------------------------------------
41462 * Type initialization:
41463 * This problem is tough by the requirement that no dynamic
41464 * memory is used. Also, since swig_type_info structures store pointers to
41465 * swig_cast_info structures and swig_cast_info structures store pointers back
41466 * to swig_type_info structures, we need some lookup code at initialization.
41467 * The idea is that swig generates all the structures that are needed.
41468 * The runtime then collects these partially filled structures.
41469 * The SWIG_InitializeModule function takes these initial arrays out of
41470 * swig_module, and does all the lookup, filling in the swig_module.types
41471 * array with the correct data and linking the correct swig_cast_info
41472 * structures together.
41473 *
41474 * The generated swig_type_info structures are assigned staticly to an initial
41475 * array. We just loop though that array, and handle each type individually.
41476 * First we lookup if this type has been already loaded, and if so, use the
41477 * loaded structure instead of the generated one. Then we have to fill in the
41478 * cast linked list. The cast data is initially stored in something like a
41479 * two-dimensional array. Each row corresponds to a type (there are the same
41480 * number of rows as there are in the swig_type_initial array). Each entry in
41481 * a column is one of the swig_cast_info structures for that type.
41482 * The cast_initial array is actually an array of arrays, because each row has
41483 * a variable number of columns. So to actually build the cast linked list,
41484 * we find the array of casts associated with the type, and loop through it
41485 * adding the casts to the list. The one last trick we need to do is making
41486 * sure the type pointer in the swig_cast_info struct is correct.
41487 *
41488 * First off, we lookup the cast->type name to see if it is already loaded.
41489 * There are three cases to handle:
41490 * 1) If the cast->type has already been loaded AND the type we are adding
41491 * casting info to has not been loaded (it is in this module), THEN we
41492 * replace the cast->type pointer with the type pointer that has already
41493 * been loaded.
41494 * 2) If BOTH types (the one we are adding casting info to, and the
41495 * cast->type) are loaded, THEN the cast info has already been loaded by
41496 * the previous module so we just ignore it.
41497 * 3) Finally, if cast->type has not already been loaded, then we add that
41498 * swig_cast_info to the linked list (because the cast->type) pointer will
41499 * be correct.
41500 * ----------------------------------------------------------------------------- */
41501
41502 #ifdef __cplusplus
41503 extern "C" {
41504 #if 0
41505 } /* c-mode */
41506 #endif
41507 #endif
41508
41509 #if 0
41510 #define SWIGRUNTIME_DEBUG
41511 #endif
41512
41513 SWIGRUNTIME void
41514 SWIG_InitializeModule(void *clientdata) {
41515 size_t i;
41516 swig_module_info *module_head;
41517 static int init_run = 0;
41518
41519 clientdata = clientdata;
41520
41521 if (init_run) return;
41522 init_run = 1;
41523
41524 /* Initialize the swig_module */
41525 swig_module.type_initial = swig_type_initial;
41526 swig_module.cast_initial = swig_cast_initial;
41527
41528 /* Try and load any already created modules */
41529 module_head = SWIG_GetModule(clientdata);
41530 if (module_head) {
41531 swig_module.next = module_head->next;
41532 module_head->next = &swig_module;
41533 } else {
41534 /* This is the first module loaded */
41535 swig_module.next = &swig_module;
41536 SWIG_SetModule(clientdata, &swig_module);
41537 }
41538
41539 /* Now work on filling in swig_module.types */
41540 #ifdef SWIGRUNTIME_DEBUG
41541 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41542 #endif
41543 for (i = 0; i < swig_module.size; ++i) {
41544 swig_type_info *type = 0;
41545 swig_type_info *ret;
41546 swig_cast_info *cast;
41547
41548 #ifdef SWIGRUNTIME_DEBUG
41549 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41550 #endif
41551
41552 /* if there is another module already loaded */
41553 if (swig_module.next != &swig_module) {
41554 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41555 }
41556 if (type) {
41557 /* Overwrite clientdata field */
41558 #ifdef SWIGRUNTIME_DEBUG
41559 printf("SWIG_InitializeModule: found type %s\n", type->name);
41560 #endif
41561 if (swig_module.type_initial[i]->clientdata) {
41562 type->clientdata = swig_module.type_initial[i]->clientdata;
41563 #ifdef SWIGRUNTIME_DEBUG
41564 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41565 #endif
41566 }
41567 } else {
41568 type = swig_module.type_initial[i];
41569 }
41570
41571 /* Insert casting types */
41572 cast = swig_module.cast_initial[i];
41573 while (cast->type) {
41574 /* Don't need to add information already in the list */
41575 ret = 0;
41576 #ifdef SWIGRUNTIME_DEBUG
41577 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41578 #endif
41579 if (swig_module.next != &swig_module) {
41580 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41581 #ifdef SWIGRUNTIME_DEBUG
41582 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41583 #endif
41584 }
41585 if (ret) {
41586 if (type == swig_module.type_initial[i]) {
41587 #ifdef SWIGRUNTIME_DEBUG
41588 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41589 #endif
41590 cast->type = ret;
41591 ret = 0;
41592 } else {
41593 /* Check for casting already in the list */
41594 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41595 #ifdef SWIGRUNTIME_DEBUG
41596 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41597 #endif
41598 if (!ocast) ret = 0;
41599 }
41600 }
41601
41602 if (!ret) {
41603 #ifdef SWIGRUNTIME_DEBUG
41604 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41605 #endif
41606 if (type->cast) {
41607 type->cast->prev = cast;
41608 cast->next = type->cast;
41609 }
41610 type->cast = cast;
41611 }
41612 cast++;
41613 }
41614 /* Set entry in modules->types array equal to the type */
41615 swig_module.types[i] = type;
41616 }
41617 swig_module.types[i] = 0;
41618
41619 #ifdef SWIGRUNTIME_DEBUG
41620 printf("**** SWIG_InitializeModule: Cast List ******\n");
41621 for (i = 0; i < swig_module.size; ++i) {
41622 int j = 0;
41623 swig_cast_info *cast = swig_module.cast_initial[i];
41624 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41625 while (cast->type) {
41626 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41627 cast++;
41628 ++j;
41629 }
41630 printf("---- Total casts: %d\n",j);
41631 }
41632 printf("**** SWIG_InitializeModule: Cast List ******\n");
41633 #endif
41634 }
41635
41636 /* This function will propagate the clientdata field of type to
41637 * any new swig_type_info structures that have been added into the list
41638 * of equivalent types. It is like calling
41639 * SWIG_TypeClientData(type, clientdata) a second time.
41640 */
41641 SWIGRUNTIME void
41642 SWIG_PropagateClientData(void) {
41643 size_t i;
41644 swig_cast_info *equiv;
41645 static int init_run = 0;
41646
41647 if (init_run) return;
41648 init_run = 1;
41649
41650 for (i = 0; i < swig_module.size; i++) {
41651 if (swig_module.types[i]->clientdata) {
41652 equiv = swig_module.types[i]->cast;
41653 while (equiv) {
41654 if (!equiv->converter) {
41655 if (equiv->type && !equiv->type->clientdata)
41656 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41657 }
41658 equiv = equiv->next;
41659 }
41660 }
41661 }
41662 }
41663
41664 #ifdef __cplusplus
41665 #if 0
41666 {
41667 /* c-mode */
41668 #endif
41669 }
41670 #endif
41671
41672
41673
41674 #ifdef __cplusplus
41675 extern "C" {
41676 #endif
41677
41678 /* Python-specific SWIG API */
41679 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41680 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41681 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41682
41683 /* -----------------------------------------------------------------------------
41684 * global variable support code.
41685 * ----------------------------------------------------------------------------- */
41686
41687 typedef struct swig_globalvar {
41688 char *name; /* Name of global variable */
41689 PyObject *(*get_attr)(void); /* Return the current value */
41690 int (*set_attr)(PyObject *); /* Set the value */
41691 struct swig_globalvar *next;
41692 } swig_globalvar;
41693
41694 typedef struct swig_varlinkobject {
41695 PyObject_HEAD
41696 swig_globalvar *vars;
41697 } swig_varlinkobject;
41698
41699 SWIGINTERN PyObject *
41700 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41701 return PyString_FromString("<Swig global variables>");
41702 }
41703
41704 SWIGINTERN PyObject *
41705 swig_varlink_str(swig_varlinkobject *v) {
41706 PyObject *str = PyString_FromString("(");
41707 swig_globalvar *var;
41708 for (var = v->vars; var; var=var->next) {
41709 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41710 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41711 }
41712 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41713 return str;
41714 }
41715
41716 SWIGINTERN int
41717 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41718 PyObject *str = swig_varlink_str(v);
41719 fprintf(fp,"Swig global variables ");
41720 fprintf(fp,"%s\n", PyString_AsString(str));
41721 Py_DECREF(str);
41722 return 0;
41723 }
41724
41725 SWIGINTERN void
41726 swig_varlink_dealloc(swig_varlinkobject *v) {
41727 swig_globalvar *var = v->vars;
41728 while (var) {
41729 swig_globalvar *n = var->next;
41730 free(var->name);
41731 free(var);
41732 var = n;
41733 }
41734 }
41735
41736 SWIGINTERN PyObject *
41737 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41738 PyObject *res = NULL;
41739 swig_globalvar *var = v->vars;
41740 while (var) {
41741 if (strcmp(var->name,n) == 0) {
41742 res = (*var->get_attr)();
41743 break;
41744 }
41745 var = var->next;
41746 }
41747 if (res == NULL && !PyErr_Occurred()) {
41748 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41749 }
41750 return res;
41751 }
41752
41753 SWIGINTERN int
41754 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41755 int res = 1;
41756 swig_globalvar *var = v->vars;
41757 while (var) {
41758 if (strcmp(var->name,n) == 0) {
41759 res = (*var->set_attr)(p);
41760 break;
41761 }
41762 var = var->next;
41763 }
41764 if (res == 1 && !PyErr_Occurred()) {
41765 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41766 }
41767 return res;
41768 }
41769
41770 SWIGINTERN PyTypeObject*
41771 swig_varlink_type(void) {
41772 static char varlink__doc__[] = "Swig var link object";
41773 static PyTypeObject varlink_type;
41774 static int type_init = 0;
41775 if (!type_init) {
41776 const PyTypeObject tmp
41777 = {
41778 PyObject_HEAD_INIT(NULL)
41779 0, /* Number of items in variable part (ob_size) */
41780 (char *)"swigvarlink", /* Type name (tp_name) */
41781 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41782 0, /* Itemsize (tp_itemsize) */
41783 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41784 (printfunc) swig_varlink_print, /* Print (tp_print) */
41785 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41786 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41787 0, /* tp_compare */
41788 (reprfunc) swig_varlink_repr, /* tp_repr */
41789 0, /* tp_as_number */
41790 0, /* tp_as_sequence */
41791 0, /* tp_as_mapping */
41792 0, /* tp_hash */
41793 0, /* tp_call */
41794 (reprfunc)swig_varlink_str, /* tp_str */
41795 0, /* tp_getattro */
41796 0, /* tp_setattro */
41797 0, /* tp_as_buffer */
41798 0, /* tp_flags */
41799 varlink__doc__, /* tp_doc */
41800 0, /* tp_traverse */
41801 0, /* tp_clear */
41802 0, /* tp_richcompare */
41803 0, /* tp_weaklistoffset */
41804 #if PY_VERSION_HEX >= 0x02020000
41805 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41806 #endif
41807 #if PY_VERSION_HEX >= 0x02030000
41808 0, /* tp_del */
41809 #endif
41810 #ifdef COUNT_ALLOCS
41811 0,0,0,0 /* tp_alloc -> tp_next */
41812 #endif
41813 };
41814 varlink_type = tmp;
41815 varlink_type.ob_type = &PyType_Type;
41816 type_init = 1;
41817 }
41818 return &varlink_type;
41819 }
41820
41821 /* Create a variable linking object for use later */
41822 SWIGINTERN PyObject *
41823 SWIG_Python_newvarlink(void) {
41824 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41825 if (result) {
41826 result->vars = 0;
41827 }
41828 return ((PyObject*) result);
41829 }
41830
41831 SWIGINTERN void
41832 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41833 swig_varlinkobject *v = (swig_varlinkobject *) p;
41834 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41835 if (gv) {
41836 size_t size = strlen(name)+1;
41837 gv->name = (char *)malloc(size);
41838 if (gv->name) {
41839 strncpy(gv->name,name,size);
41840 gv->get_attr = get_attr;
41841 gv->set_attr = set_attr;
41842 gv->next = v->vars;
41843 }
41844 }
41845 v->vars = gv;
41846 }
41847
41848 SWIGINTERN PyObject *
41849 SWIG_globals() {
41850 static PyObject *_SWIG_globals = 0;
41851 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41852 return _SWIG_globals;
41853 }
41854
41855 /* -----------------------------------------------------------------------------
41856 * constants/methods manipulation
41857 * ----------------------------------------------------------------------------- */
41858
41859 /* Install Constants */
41860 SWIGINTERN void
41861 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41862 PyObject *obj = 0;
41863 size_t i;
41864 for (i = 0; constants[i].type; ++i) {
41865 switch(constants[i].type) {
41866 case SWIG_PY_POINTER:
41867 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41868 break;
41869 case SWIG_PY_BINARY:
41870 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41871 break;
41872 default:
41873 obj = 0;
41874 break;
41875 }
41876 if (obj) {
41877 PyDict_SetItemString(d, constants[i].name, obj);
41878 Py_DECREF(obj);
41879 }
41880 }
41881 }
41882
41883 /* -----------------------------------------------------------------------------*/
41884 /* Fix SwigMethods to carry the callback ptrs when needed */
41885 /* -----------------------------------------------------------------------------*/
41886
41887 SWIGINTERN void
41888 SWIG_Python_FixMethods(PyMethodDef *methods,
41889 swig_const_info *const_table,
41890 swig_type_info **types,
41891 swig_type_info **types_initial) {
41892 size_t i;
41893 for (i = 0; methods[i].ml_name; ++i) {
41894 const char *c = methods[i].ml_doc;
41895 if (c && (c = strstr(c, "swig_ptr: "))) {
41896 int j;
41897 swig_const_info *ci = 0;
41898 const char *name = c + 10;
41899 for (j = 0; const_table[j].type; ++j) {
41900 if (strncmp(const_table[j].name, name,
41901 strlen(const_table[j].name)) == 0) {
41902 ci = &(const_table[j]);
41903 break;
41904 }
41905 }
41906 if (ci) {
41907 size_t shift = (ci->ptype) - types;
41908 swig_type_info *ty = types_initial[shift];
41909 size_t ldoc = (c - methods[i].ml_doc);
41910 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41911 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41912 if (ndoc) {
41913 char *buff = ndoc;
41914 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41915 if (ptr) {
41916 strncpy(buff, methods[i].ml_doc, ldoc);
41917 buff += ldoc;
41918 strncpy(buff, "swig_ptr: ", 10);
41919 buff += 10;
41920 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41921 methods[i].ml_doc = ndoc;
41922 }
41923 }
41924 }
41925 }
41926 }
41927 }
41928
41929 #ifdef __cplusplus
41930 }
41931 #endif
41932
41933 /* -----------------------------------------------------------------------------*
41934 * Partial Init method
41935 * -----------------------------------------------------------------------------*/
41936
41937 #ifdef __cplusplus
41938 extern "C"
41939 #endif
41940 SWIGEXPORT void SWIG_init(void) {
41941 PyObject *m, *d;
41942
41943 /* Fix SwigMethods to carry the callback ptrs when needed */
41944 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41945
41946 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41947 d = PyModule_GetDict(m);
41948
41949 SWIG_InitializeModule(0);
41950 SWIG_InstallConstants(d,swig_const_table);
41951
41952
41953 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41954 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41955 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41956 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41957 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41958 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41959 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
41960 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
41961 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
41962 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
41963 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
41964 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
41965 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
41966 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
41967 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
41968 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
41969 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
41970 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
41971 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
41972 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
41973 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
41974 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
41975 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
41976 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
41977 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
41978 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
41979 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
41980 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
41981 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
41982 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
41983 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
41984 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
41985 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
41986 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
41987 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
41988 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
41989 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
41990 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
41991 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
41992 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
41993 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
41994 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
41995 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
41996 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
41997 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
41998 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
41999 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
42000 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
42001 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
42002 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
42003 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
42004 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
42005 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
42006 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
42007 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
42008 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
42009 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
42010 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
42011 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
42012 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
42013 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
42014 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
42015 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
42016 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
42017 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
42018 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
42019 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
42020 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
42021 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
42022 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
42023 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
42024 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
42025 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
42026 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
42027 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
42028 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
42029 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
42030 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
42031 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
42032 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
42033 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
42034 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
42035 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
42036 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
42037 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
42038 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
42039 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
42040 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
42041 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
42042 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
42043 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
42044 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
42045 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
42046 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
42047 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
42048 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
42049 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
42050 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
42051 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
42052 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
42053 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
42054 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
42055 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
42056 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
42057 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
42058 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
42059 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
42060 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
42061 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
42062 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
42063 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
42064 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
42065 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
42066 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
42067 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
42068 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
42069 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
42070 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
42071 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
42072 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
42073 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
42074 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
42075 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
42076 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
42077 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
42078 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
42079 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
42080 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
42081 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
42082 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
42083 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
42084 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
42085 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
42086 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
42087 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
42088 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
42089 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
42090 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
42091 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
42092 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
42093 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
42094 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
42095 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
42096 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
42097 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
42098 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
42099 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
42100 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
42101
42102 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
42103
42104 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
42105 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
42106 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
42107 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
42108 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
42109 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42110 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42111 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42112 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42113 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42114 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42115 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42116 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42117 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42118 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42119 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42120 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42121 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42122 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42123 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42124 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42125 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42126 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42127 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42128 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42129 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42130 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42131 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42132 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42133 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42134 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42135 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42136 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42137 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42138 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42139 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42140 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42141 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42142 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42143 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42144 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42145 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42146 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42147 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42148 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42149 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42150 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42151 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42152 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42153 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42154 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42155 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42156 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42157
42158 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42159
42160 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42161 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42162 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42163 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42164 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42165 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42166 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42167 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42168 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42169 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42170 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42171 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42172 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42173 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42174 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42175 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42176 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42177 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42178 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42179 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42180 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42181 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42182 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42183 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42184 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42185 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42186 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42187 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42188 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42189 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42190 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42191 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42192 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42193 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42194 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42195 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42196 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42197 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42198 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42199 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42200 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42201 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42202 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42203 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42204 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42205 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42206 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42207 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42208 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42209 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42210 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42211 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42212 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42213 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42214 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42215 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42216 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42217 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42218 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42219 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42220 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42221 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42222 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42223 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42224 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42225 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42226 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42227 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42228 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42229 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42230 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42231 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42232 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42233 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42234 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42235 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42236
42237 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42238
42239 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42240 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42241 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42242 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42243 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42244 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42245 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42246 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42247 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42248 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42249 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42250 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42251 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42252 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42253 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42254 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42255 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42256 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42257 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42258 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42259 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42260 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42261 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42262 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42263 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42264 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42265 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42266 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42267 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42268 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42269 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42270 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42271 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42272 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42273 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42274 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42275 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42276 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42277 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42278 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42279 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42280 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42281 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42282 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42283 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42284 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42285 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42286 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42287 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42288 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42289 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42290 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42291 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42292 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42293 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42294 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42295 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42296 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42297 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42298 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42299 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42300 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42301 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42302 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42303 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42304 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42305 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42306 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42307 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42308 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42309 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42310 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42311 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42312 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42313 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42314 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42315 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42316 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42317 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42318 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42319 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42320 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42321 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42322 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42323 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42324 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42325 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42326 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42327 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42328 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42329 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42330 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42331 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42332 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42333 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42334 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42335 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42336 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42337 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42338 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42339 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42340 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42341 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42342 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42343 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42344 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42345 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42346 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42347 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42348 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42349 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42350 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42351 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42352 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42353 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42354 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42355 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42356 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42357 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42358 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42359 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42360 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42361 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42362 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42363 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42364 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42365 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42366 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42367 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42368 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42369 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42370 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42371 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42372 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42373 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42374 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42375 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42376 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42377 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42378 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42379 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42380 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42381 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42382 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42383 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42384 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42385 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42386 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42387 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42388 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42389 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42390 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42391 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42392 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42393 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42394 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42395 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42396 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42397 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42398 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42399 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42400 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42401 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42402 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42403 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42404 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42405 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42406 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42407 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42408 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42409 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42410 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42411 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42412 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42413 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42414 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42415 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42416 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42417 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42418 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42419 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42420 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42421 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42422 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42423 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42424 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42425 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42426 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42427 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42428 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42429 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42430 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42431 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42432 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42433 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42434 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42435 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42436 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42437 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42438 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42439 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42440 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42441 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42442
42443 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42444 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42445 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42446 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42447
42448 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42449 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42450 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42451 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42452 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42453 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42454 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42455 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42456 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42457 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42458 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42459 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42460 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42461 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42462 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42463 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42464 }
42465
wxWidgets (Impactor)