]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Move the language catalogs install directory on MSW from 'locale' to
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBitmap swig_types[12]
2479 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2480 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2481 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2482 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2483 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2484 #define SWIGTYPE_p_wxCaret swig_types[18]
2485 #define SWIGTYPE_p_wxChar swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboard swig_types[21]
2488 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[23]
2490 #define SWIGTYPE_p_wxCloseEvent swig_types[24]
2491 #define SWIGTYPE_p_wxColour swig_types[25]
2492 #define SWIGTYPE_p_wxCommandEvent swig_types[26]
2493 #define SWIGTYPE_p_wxConfig swig_types[27]
2494 #define SWIGTYPE_p_wxConfigBase swig_types[28]
2495 #define SWIGTYPE_p_wxConfigPathChanger swig_types[29]
2496 #define SWIGTYPE_p_wxContextMenuEvent swig_types[30]
2497 #define SWIGTYPE_p_wxControl swig_types[31]
2498 #define SWIGTYPE_p_wxControlWithItems swig_types[32]
2499 #define SWIGTYPE_p_wxCursor swig_types[33]
2500 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
2501 #define SWIGTYPE_p_wxDC swig_types[35]
2502 #define SWIGTYPE_p_wxDataFormat swig_types[36]
2503 #define SWIGTYPE_p_wxDataObject swig_types[37]
2504 #define SWIGTYPE_p_wxDataObjectComposite swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectSimple swig_types[39]
2506 #define SWIGTYPE_p_wxDateEvent swig_types[40]
2507 #define SWIGTYPE_p_wxDateSpan swig_types[41]
2508 #define SWIGTYPE_p_wxDateTime swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[43]
2510 #define SWIGTYPE_p_wxDisplay swig_types[44]
2511 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[45]
2512 #define SWIGTYPE_p_wxDropFilesEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDuplexMode swig_types[47]
2514 #define SWIGTYPE_p_wxEraseEvent swig_types[48]
2515 #define SWIGTYPE_p_wxEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvtHandler swig_types[50]
2517 #define SWIGTYPE_p_wxFSFile swig_types[51]
2518 #define SWIGTYPE_p_wxFileConfig swig_types[52]
2519 #define SWIGTYPE_p_wxFileDataObject swig_types[53]
2520 #define SWIGTYPE_p_wxFileHistory swig_types[54]
2521 #define SWIGTYPE_p_wxFileSystem swig_types[55]
2522 #define SWIGTYPE_p_wxFileType swig_types[56]
2523 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
2524 #define SWIGTYPE_p_wxFlexGridSizer swig_types[58]
2525 #define SWIGTYPE_p_wxFocusEvent swig_types[59]
2526 #define SWIGTYPE_p_wxFont swig_types[60]
2527 #define SWIGTYPE_p_wxFrame swig_types[61]
2528 #define SWIGTYPE_p_wxGBSizerItem swig_types[62]
2529 #define SWIGTYPE_p_wxGIFHandler swig_types[63]
2530 #define SWIGTYPE_p_wxGridBagSizer swig_types[64]
2531 #define SWIGTYPE_p_wxGridSizer swig_types[65]
2532 #define SWIGTYPE_p_wxICOHandler swig_types[66]
2533 #define SWIGTYPE_p_wxIcon swig_types[67]
2534 #define SWIGTYPE_p_wxIconizeEvent swig_types[68]
2535 #define SWIGTYPE_p_wxIdleEvent swig_types[69]
2536 #define SWIGTYPE_p_wxImage swig_types[70]
2537 #define SWIGTYPE_p_wxImageHandler swig_types[71]
2538 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[72]
2539 #define SWIGTYPE_p_wxInitDialogEvent swig_types[73]
2540 #define SWIGTYPE_p_wxJPEGHandler swig_types[74]
2541 #define SWIGTYPE_p_wxJoystick swig_types[75]
2542 #define SWIGTYPE_p_wxJoystickEvent swig_types[76]
2543 #define SWIGTYPE_p_wxKeyEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKillError swig_types[78]
2545 #define SWIGTYPE_p_wxLayoutConstraints swig_types[79]
2546 #define SWIGTYPE_p_wxLog swig_types[80]
2547 #define SWIGTYPE_p_wxLogBuffer swig_types[81]
2548 #define SWIGTYPE_p_wxLogChain swig_types[82]
2549 #define SWIGTYPE_p_wxLogGui swig_types[83]
2550 #define SWIGTYPE_p_wxLogNull swig_types[84]
2551 #define SWIGTYPE_p_wxLogStderr swig_types[85]
2552 #define SWIGTYPE_p_wxLogTextCtrl swig_types[86]
2553 #define SWIGTYPE_p_wxLogWindow swig_types[87]
2554 #define SWIGTYPE_p_wxMaximizeEvent swig_types[88]
2555 #define SWIGTYPE_p_wxMenu swig_types[89]
2556 #define SWIGTYPE_p_wxMenuBar swig_types[90]
2557 #define SWIGTYPE_p_wxMenuEvent swig_types[91]
2558 #define SWIGTYPE_p_wxMenuItem swig_types[92]
2559 #define SWIGTYPE_p_wxMetafileDataObject swig_types[93]
2560 #define SWIGTYPE_p_wxMimeTypesManager swig_types[94]
2561 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseState swig_types[98]
2565 #define SWIGTYPE_p_wxMoveEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[100]
2567 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
2568 #define SWIGTYPE_p_wxNcPaintEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNotifyEvent swig_types[103]
2570 #define SWIGTYPE_p_wxObject swig_types[104]
2571 #define SWIGTYPE_p_wxOutputStream swig_types[105]
2572 #define SWIGTYPE_p_wxPCXHandler swig_types[106]
2573 #define SWIGTYPE_p_wxPNGHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNMHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPaintEvent swig_types[109]
2576 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaperSize swig_types[111]
2578 #define SWIGTYPE_p_wxPlatformInfo swig_types[112]
2579 #define SWIGTYPE_p_wxPoint swig_types[113]
2580 #define SWIGTYPE_p_wxPowerEvent swig_types[114]
2581 #define SWIGTYPE_p_wxProcessEvent swig_types[115]
2582 #define SWIGTYPE_p_wxPyApp swig_types[116]
2583 #define SWIGTYPE_p_wxPyArtProvider swig_types[117]
2584 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[118]
2585 #define SWIGTYPE_p_wxPyCommandEvent swig_types[119]
2586 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[120]
2587 #define SWIGTYPE_p_wxPyDropSource swig_types[121]
2588 #define SWIGTYPE_p_wxPyDropTarget swig_types[122]
2589 #define SWIGTYPE_p_wxPyEvent swig_types[123]
2590 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[124]
2591 #define SWIGTYPE_p_wxPyImageHandler swig_types[125]
2592 #define SWIGTYPE_p_wxPyLog swig_types[126]
2593 #define SWIGTYPE_p_wxPyProcess swig_types[127]
2594 #define SWIGTYPE_p_wxPySizer swig_types[128]
2595 #define SWIGTYPE_p_wxPyTextDataObject swig_types[129]
2596 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[130]
2597 #define SWIGTYPE_p_wxPyTimer swig_types[131]
2598 #define SWIGTYPE_p_wxPyTipProvider swig_types[132]
2599 #define SWIGTYPE_p_wxPyValidator swig_types[133]
2600 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[134]
2601 #define SWIGTYPE_p_wxRect swig_types[135]
2602 #define SWIGTYPE_p_wxScrollEvent swig_types[136]
2603 #define SWIGTYPE_p_wxScrollWinEvent swig_types[137]
2604 #define SWIGTYPE_p_wxSetCursorEvent swig_types[138]
2605 #define SWIGTYPE_p_wxShowEvent swig_types[139]
2606 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[140]
2607 #define SWIGTYPE_p_wxSize swig_types[141]
2608 #define SWIGTYPE_p_wxSizeEvent swig_types[142]
2609 #define SWIGTYPE_p_wxSizer swig_types[143]
2610 #define SWIGTYPE_p_wxSizerItem swig_types[144]
2611 #define SWIGTYPE_p_wxSound swig_types[145]
2612 #define SWIGTYPE_p_wxStandardPaths swig_types[146]
2613 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[147]
2614 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[148]
2615 #define SWIGTYPE_p_wxStopWatch swig_types[149]
2616 #define SWIGTYPE_p_wxString swig_types[150]
2617 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[151]
2618 #define SWIGTYPE_p_wxSystemOptions swig_types[152]
2619 #define SWIGTYPE_p_wxSystemSettings swig_types[153]
2620 #define SWIGTYPE_p_wxTIFFHandler swig_types[154]
2621 #define SWIGTYPE_p_wxTextCtrl swig_types[155]
2622 #define SWIGTYPE_p_wxTextDataObject swig_types[156]
2623 #define SWIGTYPE_p_wxTimeSpan swig_types[157]
2624 #define SWIGTYPE_p_wxTimer swig_types[158]
2625 #define SWIGTYPE_p_wxTimerEvent swig_types[159]
2626 #define SWIGTYPE_p_wxTimerRunner swig_types[160]
2627 #define SWIGTYPE_p_wxTipProvider swig_types[161]
2628 #define SWIGTYPE_p_wxToolTip swig_types[162]
2629 #define SWIGTYPE_p_wxURLDataObject swig_types[163]
2630 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[164]
2631 #define SWIGTYPE_p_wxValidator swig_types[165]
2632 #define SWIGTYPE_p_wxVideoMode swig_types[166]
2633 #define SWIGTYPE_p_wxWindow swig_types[167]
2634 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[168]
2635 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[169]
2636 #define SWIGTYPE_p_wxWindowDisabler swig_types[170]
2637 #define SWIGTYPE_p_wxXPMHandler swig_types[171]
2638 static swig_type_info *swig_types[173];
2639 static swig_module_info swig_module = {swig_types, 172, 0, 0, 0, 0};
2640 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2641 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2642
2643 /* -------- TYPES TABLE (END) -------- */
2644
2645 #if (PY_VERSION_HEX <= 0x02000000)
2646 # if !defined(SWIG_PYTHON_CLASSIC)
2647 # error "This python version requires to use swig with the '-classic' option"
2648 # endif
2649 #endif
2650 #if (PY_VERSION_HEX <= 0x02020000)
2651 # error "This python version requires to use swig with the '-nomodern' option"
2652 #endif
2653 #if (PY_VERSION_HEX <= 0x02020000)
2654 # error "This python version requires to use swig with the '-nomodernargs' option"
2655 #endif
2656 #ifndef METH_O
2657 # error "This python version requires to use swig with the '-nofastunpack' option"
2658 #endif
2659
2660 /*-----------------------------------------------
2661 @(target):= _misc_.so
2662 ------------------------------------------------*/
2663 #define SWIG_init init_misc_
2664
2665 #define SWIG_name "_misc_"
2666
2667 #define SWIGVERSION 0x010329
2668
2669
2670 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2671 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2672
2673
2674 #include <stdexcept>
2675
2676
2677 namespace swig {
2678 class PyObject_ptr {
2679 protected:
2680 PyObject *_obj;
2681
2682 public:
2683 PyObject_ptr() :_obj(0)
2684 {
2685 }
2686
2687 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2688 {
2689 Py_XINCREF(_obj);
2690 }
2691
2692 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2693 {
2694 if (initial_ref) Py_XINCREF(_obj);
2695 }
2696
2697 PyObject_ptr & operator=(const PyObject_ptr& item)
2698 {
2699 Py_XINCREF(item._obj);
2700 Py_XDECREF(_obj);
2701 _obj = item._obj;
2702 return *this;
2703 }
2704
2705 ~PyObject_ptr()
2706 {
2707 Py_XDECREF(_obj);
2708 }
2709
2710 operator PyObject *() const
2711 {
2712 return _obj;
2713 }
2714
2715 PyObject *operator->() const
2716 {
2717 return _obj;
2718 }
2719 };
2720 }
2721
2722
2723 namespace swig {
2724 struct PyObject_var : PyObject_ptr {
2725 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2726
2727 PyObject_var & operator = (PyObject* obj)
2728 {
2729 Py_XDECREF(_obj);
2730 _obj = obj;
2731 return *this;
2732 }
2733 };
2734 }
2735
2736
2737 #include "wx/wxPython/wxPython.h"
2738 #include "wx/wxPython/pyclasses.h"
2739 #include "wx/wxPython/pyistream.h"
2740
2741 static const wxString wxPyEmptyString(wxEmptyString);
2742
2743
2744
2745 #define SWIG_From_long PyInt_FromLong
2746
2747
2748 SWIGINTERNINLINE PyObject *
2749 SWIG_From_int (int value)
2750 {
2751 return SWIG_From_long (value);
2752 }
2753
2754
2755 #include <limits.h>
2756 #ifndef LLONG_MIN
2757 # define LLONG_MIN LONG_LONG_MIN
2758 #endif
2759 #ifndef LLONG_MAX
2760 # define LLONG_MAX LONG_LONG_MAX
2761 #endif
2762 #ifndef ULLONG_MAX
2763 # define ULLONG_MAX ULONG_LONG_MAX
2764 #endif
2765
2766
2767 SWIGINTERN int
2768 SWIG_AsVal_long (PyObject* obj, long* val)
2769 {
2770 if (PyNumber_Check(obj)) {
2771 if (val) *val = PyInt_AsLong(obj);
2772 return SWIG_OK;
2773 }
2774 return SWIG_TypeError;
2775 }
2776
2777
2778 SWIGINTERN int
2779 SWIG_AsVal_int (PyObject * obj, int *val)
2780 {
2781 long v;
2782 int res = SWIG_AsVal_long (obj, &v);
2783 if (SWIG_IsOK(res)) {
2784 if ((v < INT_MIN || v > INT_MAX)) {
2785 return SWIG_OverflowError;
2786 } else {
2787 if (val) *val = static_cast< int >(v);
2788 }
2789 }
2790 return res;
2791 }
2792
2793 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2794
2795 #include <wx/stockitem.h>
2796
2797 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2798 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2799 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2800
2801 SWIGINTERN int
2802 SWIG_AsVal_bool (PyObject *obj, bool *val)
2803 {
2804 if (obj == Py_True) {
2805 if (val) *val = true;
2806 return SWIG_OK;
2807 } else if (obj == Py_False) {
2808 if (val) *val = false;
2809 return SWIG_OK;
2810 } else {
2811 long v = 0;
2812 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2813 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2814 return res;
2815 }
2816 }
2817
2818
2819 wxMemorySize wxGetFreeMemory()
2820 { wxPyRaiseNotImplemented(); return 0; }
2821
2822
2823 SWIGINTERN int
2824 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2825 {
2826 long v = 0;
2827 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2828 return SWIG_TypeError;
2829 }
2830 else if (val)
2831 *val = (unsigned long)v;
2832 return SWIG_OK;
2833 }
2834
2835
2836 SWIGINTERNINLINE PyObject*
2837 SWIG_From_unsigned_SS_long (unsigned long value)
2838 {
2839 return (value > LONG_MAX) ?
2840 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2841 }
2842
2843
2844 void* wxGetXDisplay()
2845 {
2846 #ifdef __WXGTK__
2847 return wxGetDisplay();
2848 #else
2849 return NULL;
2850 #endif
2851 }
2852
2853
2854 wxWindow* FindWindowAtPointer() {
2855 wxPoint unused;
2856 return wxFindWindowAtPointer(unused);
2857 }
2858
2859
2860 void wxWakeUpMainThread() {}
2861
2862
2863 bool wxThread_IsMain() {
2864 #ifdef WXP_WITH_THREAD
2865 return wxThread::IsMain();
2866 #else
2867 return true;
2868 #endif
2869 }
2870
2871 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2872 delete self;
2873 }
2874
2875 #include <wx/snglinst.h>
2876
2877
2878 #ifdef __WXMSW__
2879 #include <wx/msw/private.h>
2880 #include <wx/dynload.h>
2881 #endif
2882
2883
2884
2885 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2886 #if 0
2887 , int method
2888 #endif
2889 )
2890 {
2891 #ifdef __WXMSW__
2892 #if 0
2893 switch (method)
2894 {
2895 case 1:
2896 // This one only partially works. Appears to be an undocumented
2897 // "standard" convention that not all widgets adhear to. For
2898 // example, for some widgets backgrounds or non-client areas may
2899 // not be painted.
2900 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2901 break;
2902
2903 case 2:
2904 #endif
2905 // This one works much better, nearly all widgets and their
2906 // children are captured correctly[**]. Prior to the big
2907 // background erase changes that Vadim did in 2004-2005 this
2908 // method failed badly on XP with Themes activated, most native
2909 // widgets draw only partially, if at all. Without themes it
2910 // worked just like on Win2k. After those changes this method
2911 // works very well.
2912 //
2913 // ** For example the radio buttons in a wxRadioBox are not its
2914 // children by default, but you can capture it via the panel
2915 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2916 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2917 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2918 PRF_ERASEBKGND | PRF_OWNED );
2919 return true;
2920 #if 0
2921 break;
2922
2923 case 3:
2924 // This one is only defined in the latest SDK and is only
2925 // available on XP. MSDN says it is similar to sending WM_PRINT
2926 // so I expect that it will work similar to the above. Since it
2927 // is avaialble only on XP, it can't be compiled like this and
2928 // will have to be loaded dynamically.
2929 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2930
2931 // fall through
2932
2933 case 4:
2934 // Use PrintWindow if available, or fallback to WM_PRINT
2935 // otherwise. Unfortunately using PrintWindow is even worse than
2936 // WM_PRINT. For most native widgets nothing is drawn to the dc
2937 // at all, with or without Themes.
2938 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2939 static bool s_triedToLoad = false;
2940 static PrintWindow_t pfnPrintWindow = NULL;
2941 if ( !s_triedToLoad )
2942 {
2943
2944 s_triedToLoad = true;
2945 wxDynamicLibrary dllUser32(_T("user32.dll"));
2946 if ( dllUser32.IsLoaded() )
2947 {
2948 wxLogNull nolog; // Don't report errors here
2949 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2950 }
2951 }
2952 if (pfnPrintWindow)
2953 {
2954 //printf("Using PrintWindow\n");
2955 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2956 }
2957 else
2958 {
2959 //printf("Using WM_PRINT\n");
2960 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2961 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2962 PRF_ERASEBKGND | PRF_OWNED );
2963 }
2964 }
2965 #endif // 0
2966 #else
2967 return false;
2968 #endif // __WXMSW__
2969 }
2970
2971
2972
2973 #include <wx/tipdlg.h>
2974
2975
2976 SWIGINTERNINLINE PyObject *
2977 SWIG_From_size_t (size_t value)
2978 {
2979 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2980 }
2981
2982
2983 class wxPyTipProvider : public wxTipProvider {
2984 public:
2985 wxPyTipProvider(size_t currentTip)
2986 : wxTipProvider(currentTip) {}
2987
2988 DEC_PYCALLBACK_STRING__pure(GetTip);
2989 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2990 PYPRIVATE;
2991 };
2992
2993 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2994 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2995
2996
2997 SWIGINTERNINLINE int
2998 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2999 {
3000 unsigned long v;
3001 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3002 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3003 return res;
3004 }
3005
3006
3007 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3008
3009 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3010
3011 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3012 : wxTimer(owner, id)
3013 {
3014 if (owner == NULL)
3015 SetOwner(this);
3016 }
3017
3018
3019 SWIGINTERN swig_type_info*
3020 SWIG_pchar_descriptor()
3021 {
3022 static int init = 0;
3023 static swig_type_info* info = 0;
3024 if (!init) {
3025 info = SWIG_TypeQuery("_p_char");
3026 init = 1;
3027 }
3028 return info;
3029 }
3030
3031
3032 SWIGINTERNINLINE PyObject *
3033 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3034 {
3035 if (carray) {
3036 if (size > INT_MAX) {
3037 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3038 return pchar_descriptor ?
3039 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3040 } else {
3041 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3042 }
3043 } else {
3044 return SWIG_Py_Void();
3045 }
3046 }
3047
3048
3049 SWIGINTERNINLINE PyObject *
3050 SWIG_FromCharPtr(const char *cptr)
3051 {
3052 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3053 }
3054
3055
3056 SWIGINTERN int
3057 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3058 {
3059 unsigned long v;
3060 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3061 if (SWIG_IsOK(res)) {
3062 if ((v > UINT_MAX)) {
3063 return SWIG_OverflowError;
3064 } else {
3065 if (val) *val = static_cast< unsigned int >(v);
3066 }
3067 }
3068 return res;
3069 }
3070
3071 SWIGINTERN wxString wxLog_TimeStamp(){
3072 wxString msg;
3073 wxLog::TimeStamp(&msg);
3074 return msg;
3075 }
3076 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3077 // Make some wrappers that double any % signs so they are 'escaped'
3078 void wxPyLogFatalError(const wxString& msg)
3079 {
3080 wxString m(msg);
3081 m.Replace(wxT("%"), wxT("%%"));
3082 wxLogFatalError(m);
3083 }
3084
3085 void wxPyLogError(const wxString& msg)
3086 {
3087 wxString m(msg);
3088 m.Replace(wxT("%"), wxT("%%"));
3089 wxLogError(m);
3090 }
3091
3092 void wxPyLogWarning(const wxString& msg)
3093 {
3094 wxString m(msg);
3095 m.Replace(wxT("%"), wxT("%%"));
3096 wxLogWarning(m);
3097 }
3098
3099 void wxPyLogMessage(const wxString& msg)
3100 {
3101 wxString m(msg);
3102 m.Replace(wxT("%"), wxT("%%"));
3103 wxLogMessage(m);
3104 }
3105
3106 void wxPyLogInfo(const wxString& msg)
3107 {
3108 wxString m(msg);
3109 m.Replace(wxT("%"), wxT("%%"));
3110 wxLogInfo(m);
3111 }
3112
3113 void wxPyLogDebug(const wxString& msg)
3114 {
3115 wxString m(msg);
3116 m.Replace(wxT("%"), wxT("%%"));
3117 wxLogDebug(m);
3118 }
3119
3120 void wxPyLogVerbose(const wxString& msg)
3121 {
3122 wxString m(msg);
3123 m.Replace(wxT("%"), wxT("%%"));
3124 wxLogVerbose(m);
3125 }
3126
3127 void wxPyLogStatus(const wxString& msg)
3128 {
3129 wxString m(msg);
3130 m.Replace(wxT("%"), wxT("%%"));
3131 wxLogStatus(m);
3132 }
3133
3134 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3135 {
3136 wxString m(msg);
3137 m.Replace(wxT("%"), wxT("%%"));
3138 wxLogStatus(pFrame, m);
3139 }
3140
3141 void wxPyLogSysError(const wxString& msg)
3142 {
3143 wxString m(msg);
3144 m.Replace(wxT("%"), wxT("%%"));
3145 wxLogSysError(m);
3146 }
3147
3148 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3149 {
3150 wxString m(msg);
3151 m.Replace(wxT("%"), wxT("%%"));
3152 wxLogGeneric(level, m);
3153 }
3154
3155 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3156 {
3157 wxString m(msg);
3158 m.Replace(wxT("%"), wxT("%%"));
3159 wxLogTrace(mask, m);
3160 }
3161
3162 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3163 {
3164 wxString m(msg);
3165 m.Replace(wxT("%"), wxT("%%"));
3166 wxLogTrace(mask, m);
3167 }
3168
3169
3170
3171 // A wxLog class that can be derived from in wxPython
3172 class wxPyLog : public wxLog {
3173 public:
3174 wxPyLog() : wxLog() {}
3175
3176 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3177 bool found;
3178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3179 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3180 PyObject* s = wx2PyString(szString);
3181 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3182 Py_DECREF(s);
3183 }
3184 wxPyEndBlockThreads(blocked);
3185 if (! found)
3186 wxLog::DoLog(level, szString, t);
3187 }
3188
3189 virtual void DoLogString(const wxChar *szString, time_t t) {
3190 bool found;
3191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3192 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3193 PyObject* s = wx2PyString(szString);
3194 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3195 Py_DECREF(s);
3196 }
3197 wxPyEndBlockThreads(blocked);
3198 if (! found)
3199 wxLog::DoLogString(szString, t);
3200 }
3201
3202 DEC_PYCALLBACK_VOID_(Flush);
3203 PYPRIVATE;
3204 };
3205 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3206
3207
3208
3209
3210 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3211
3212
3213 #include <wx/joystick.h>
3214
3215
3216 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3217 // A C++ stub class for wxJoystick for platforms that don't have it.
3218 class wxJoystick : public wxObject {
3219 public:
3220 wxJoystick(int joystick = wxJOYSTICK1) {
3221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3222 PyErr_SetString(PyExc_NotImplementedError,
3223 "wxJoystick is not available on this platform.");
3224 wxPyEndBlockThreads(blocked);
3225 }
3226 wxPoint GetPosition() { return wxPoint(-1,-1); }
3227 int GetZPosition() { return -1; }
3228 int GetButtonState() { return -1; }
3229 int GetPOVPosition() { return -1; }
3230 int GetPOVCTSPosition() { return -1; }
3231 int GetRudderPosition() { return -1; }
3232 int GetUPosition() { return -1; }
3233 int GetVPosition() { return -1; }
3234 int GetMovementThreshold() { return -1; }
3235 void SetMovementThreshold(int threshold) {}
3236
3237 bool IsOk(void) { return false; }
3238 int GetNumberJoysticks() { return -1; }
3239 int GetManufacturerId() { return -1; }
3240 int GetProductId() { return -1; }
3241 wxString GetProductName() { return wxEmptyString; }
3242 int GetXMin() { return -1; }
3243 int GetYMin() { return -1; }
3244 int GetZMin() { return -1; }
3245 int GetXMax() { return -1; }
3246 int GetYMax() { return -1; }
3247 int GetZMax() { return -1; }
3248 int GetNumberButtons() { return -1; }
3249 int GetNumberAxes() { return -1; }
3250 int GetMaxButtons() { return -1; }
3251 int GetMaxAxes() { return -1; }
3252 int GetPollingMin() { return -1; }
3253 int GetPollingMax() { return -1; }
3254 int GetRudderMin() { return -1; }
3255 int GetRudderMax() { return -1; }
3256 int GetUMin() { return -1; }
3257 int GetUMax() { return -1; }
3258 int GetVMin() { return -1; }
3259 int GetVMax() { return -1; }
3260
3261 bool HasRudder() { return false; }
3262 bool HasZ() { return false; }
3263 bool HasU() { return false; }
3264 bool HasV() { return false; }
3265 bool HasPOV() { return false; }
3266 bool HasPOV4Dir() { return false; }
3267 bool HasPOVCTS() { return false; }
3268
3269 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3270 bool ReleaseCapture() { return false; }
3271 };
3272 #endif
3273
3274
3275 #include <wx/sound.h>
3276
3277
3278 #if !wxUSE_SOUND
3279 // A C++ stub class for wxWave for platforms that don't have it.
3280 class wxSound : public wxObject
3281 {
3282 public:
3283 wxSound() {
3284 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3285 PyErr_SetString(PyExc_NotImplementedError,
3286 "wxSound is not available on this platform.");
3287 wxPyEndBlockThreads(blocked);
3288 }
3289 wxSound(const wxString&/*, bool*/) {
3290 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3291 PyErr_SetString(PyExc_NotImplementedError,
3292 "wxSound is not available on this platform.");
3293 wxPyEndBlockThreads(blocked);
3294 }
3295 wxSound(int, const wxByte*) {
3296 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3297 PyErr_SetString(PyExc_NotImplementedError,
3298 "wxSound is not available on this platform.");
3299 wxPyEndBlockThreads(blocked);
3300 }
3301
3302 ~wxSound() {};
3303
3304 bool Create(const wxString&/*, bool*/) { return false; }
3305 bool Create(int, const wxByte*) { return false; };
3306 bool IsOk() { return false; };
3307 bool Play(unsigned) const { return false; }
3308 static bool Play(const wxString&, unsigned) { return false; }
3309 static void Stop() {}
3310 };
3311
3312 #endif
3313
3314 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3315 if (fileName.Length() == 0)
3316 return new wxSound;
3317 else
3318 return new wxSound(fileName);
3319 }
3320 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3321 unsigned char* buffer; int size;
3322 wxSound *sound = NULL;
3323
3324 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3325 if (!PyArg_Parse(data, "t#", &buffer, &size))
3326 goto done;
3327 sound = new wxSound(size, buffer);
3328 done:
3329 wxPyEndBlockThreads(blocked);
3330 return sound;
3331 }
3332 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3333 #ifndef __WXMAC__
3334 unsigned char* buffer;
3335 int size;
3336 bool rv = false;
3337
3338 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3339 if (!PyArg_Parse(data, "t#", &buffer, &size))
3340 goto done;
3341 rv = self->Create(size, buffer);
3342 done:
3343 wxPyEndBlockThreads(blocked);
3344 return rv;
3345 #else
3346 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3347 PyErr_SetString(PyExc_NotImplementedError,
3348 "Create from data is not available on this platform.");
3349 wxPyEndBlockThreads(blocked);
3350 return false;
3351 #endif
3352 }
3353
3354 #include <wx/mimetype.h>
3355
3356 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3357 wxString str;
3358 if (self->GetMimeType(&str))
3359 return wx2PyString(str);
3360 else
3361 RETURN_NONE();
3362 }
3363 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3364 wxArrayString arr;
3365 if (self->GetMimeTypes(arr))
3366 return wxArrayString2PyList_helper(arr);
3367 else
3368 RETURN_NONE();
3369 }
3370 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3371 wxArrayString arr;
3372 if (self->GetExtensions(arr))
3373 return wxArrayString2PyList_helper(arr);
3374 else
3375 RETURN_NONE();
3376 }
3377 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3378 wxIconLocation loc;
3379 if (self->GetIcon(&loc))
3380 return new wxIcon(loc);
3381 else
3382 return NULL;
3383 }
3384 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3385 wxIconLocation loc;
3386 if (self->GetIcon(&loc)) {
3387 wxString iconFile = loc.GetFileName();
3388 int iconIndex = -1;
3389
3390
3391
3392 // Make a tuple and put the values in it
3393 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3394 PyObject* tuple = PyTuple_New(3);
3395 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3396 wxT("wxIcon"), true));
3397 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3398 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3399 wxPyEndBlockThreads(blocked);
3400 return tuple;
3401 }
3402 else
3403 RETURN_NONE();
3404 }
3405 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3406 wxString str;
3407 if (self->GetDescription(&str))
3408 return wx2PyString(str);
3409 else
3410 RETURN_NONE();
3411 }
3412 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3413 wxString str;
3414 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3415 return wx2PyString(str);
3416 else
3417 RETURN_NONE();
3418 }
3419 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3420 wxString str;
3421 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3422 return wx2PyString(str);
3423 else
3424 RETURN_NONE();
3425 }
3426 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3427 wxArrayString verbs;
3428 wxArrayString commands;
3429 if (self->GetAllCommands(&verbs, &commands,
3430 wxFileType::MessageParameters(filename, mimetype))) {
3431 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3432 PyObject* tuple = PyTuple_New(2);
3433 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3434 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3435 wxPyEndBlockThreads(blocked);
3436 return tuple;
3437 }
3438 else
3439 RETURN_NONE();
3440 }
3441 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3442 return wxFileType::ExpandCommand(command,
3443 wxFileType::MessageParameters(filename, mimetype));
3444 }
3445 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3446 wxArrayString arr;
3447 self->EnumAllFileTypes(arr);
3448 return wxArrayString2PyList_helper(arr);
3449 }
3450
3451 #include <wx/artprov.h>
3452
3453 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3454 static const wxString wxPyART_MENU(wxART_MENU);
3455 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3456 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3457 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3458 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3459 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3460 static const wxString wxPyART_OTHER(wxART_OTHER);
3461 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3462 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3463 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3464 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3465 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3466 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3467 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3468 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3469 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3470 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3471 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3472 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3473 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3474 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3475 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3476 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3477 static const wxString wxPyART_PRINT(wxART_PRINT);
3478 static const wxString wxPyART_HELP(wxART_HELP);
3479 static const wxString wxPyART_TIP(wxART_TIP);
3480 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3481 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3482 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3483 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3484 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3485 static const wxString wxPyART_CDROM(wxART_CDROM);
3486 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3487 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3488 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3489 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3490 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3491 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3492 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3493 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3494 static const wxString wxPyART_ERROR(wxART_ERROR);
3495 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3496 static const wxString wxPyART_WARNING(wxART_WARNING);
3497 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3498 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3499 static const wxString wxPyART_COPY(wxART_COPY);
3500 static const wxString wxPyART_CUT(wxART_CUT);
3501 static const wxString wxPyART_PASTE(wxART_PASTE);
3502 static const wxString wxPyART_DELETE(wxART_DELETE);
3503 static const wxString wxPyART_NEW(wxART_NEW);
3504 static const wxString wxPyART_UNDO(wxART_UNDO);
3505 static const wxString wxPyART_REDO(wxART_REDO);
3506 static const wxString wxPyART_QUIT(wxART_QUIT);
3507 static const wxString wxPyART_FIND(wxART_FIND);
3508 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3509 // Python aware wxArtProvider
3510 class wxPyArtProvider : public wxArtProvider {
3511 public:
3512
3513 virtual wxBitmap CreateBitmap(const wxArtID& id,
3514 const wxArtClient& client,
3515 const wxSize& size) {
3516 wxBitmap rval = wxNullBitmap;
3517 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3518 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3519 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3520 PyObject* ro;
3521 wxBitmap* ptr;
3522 PyObject* s1, *s2;
3523 s1 = wx2PyString(id);
3524 s2 = wx2PyString(client);
3525 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3526 Py_DECREF(so);
3527 Py_DECREF(s1);
3528 Py_DECREF(s2);
3529 if (ro) {
3530 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3531 rval = *ptr;
3532 Py_DECREF(ro);
3533 }
3534 }
3535 wxPyEndBlockThreads(blocked);
3536 return rval;
3537 }
3538
3539 PYPRIVATE;
3540 };
3541
3542 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3543
3544
3545
3546 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3547 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3548 PyObject* ret = PyTuple_New(3);
3549 if (ret) {
3550 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3551 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3552 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3553 }
3554 wxPyEndBlockThreads(blocked);
3555 return ret;
3556 }
3557
3558 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3559 bool cont;
3560 long index = 0;
3561 wxString value;
3562
3563 cont = self->GetFirstGroup(value, index);
3564 return __EnumerationHelper(cont, value, index);
3565 }
3566 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3567 bool cont;
3568 wxString value;
3569
3570 cont = self->GetNextGroup(value, index);
3571 return __EnumerationHelper(cont, value, index);
3572 }
3573 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3574 bool cont;
3575 long index = 0;
3576 wxString value;
3577
3578 cont = self->GetFirstEntry(value, index);
3579 return __EnumerationHelper(cont, value, index);
3580 }
3581 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3582 bool cont;
3583 wxString value;
3584
3585 cont = self->GetNextEntry(value, index);
3586 return __EnumerationHelper(cont, value, index);
3587 }
3588 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3589 long rv;
3590 self->Read(key, &rv, defaultVal);
3591 return rv;
3592 }
3593
3594 SWIGINTERN int
3595 SWIG_AsVal_double (PyObject *obj, double* val)
3596 {
3597 if (PyNumber_Check(obj)) {
3598 if (val) *val = PyFloat_AsDouble(obj);
3599 return SWIG_OK;
3600 }
3601 return SWIG_TypeError;
3602 }
3603
3604 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3605 double rv;
3606 self->Read(key, &rv, defaultVal);
3607 return rv;
3608 }
3609
3610 #define SWIG_From_double PyFloat_FromDouble
3611
3612 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3613 bool rv;
3614 self->Read(key, &rv, defaultVal);
3615 return rv;
3616 }
3617
3618 #include <wx/datetime.h>
3619
3620 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3621 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3622
3623 #define LOCAL_TZ wxDateTime::Local
3624
3625 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3626 wxString am;
3627 wxString pm;
3628 wxDateTime::GetAmPmStrings(&am, &pm);
3629 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3630 PyObject* tup = PyTuple_New(2);
3631 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3632 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3633 wxPyEndBlockThreads(blocked);
3634 return tup;
3635 }
3636
3637 SWIGINTERNINLINE PyObject *
3638 SWIG_From_unsigned_SS_int (unsigned int value)
3639 {
3640 return SWIG_From_unsigned_SS_long (value);
3641 }
3642
3643 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3644 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3645 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3646 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3647 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3648 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3649 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3650 return (*self < *other);
3651 }
3652 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3653 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3654 return (*self <= *other);
3655 }
3656 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3657 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3658 return (*self > *other);
3659 }
3660 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3661 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3662 return (*self >= *other);
3663 }
3664 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3665 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3666 return (*self == *other);
3667 }
3668 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3669 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3670 return (*self != *other);
3671 }
3672 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3673 const wxChar* rv;
3674 const wxChar* _date = date;
3675 rv = self->ParseRfc822Date(_date);
3676 if (rv == NULL) return -1;
3677 return rv - _date;
3678 }
3679 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3680 const wxChar* rv;
3681 const wxChar* _date = date;
3682 rv = self->ParseFormat(_date, format, dateDef);
3683 if (rv == NULL) return -1;
3684 return rv - _date;
3685 }
3686 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3687 const wxChar* rv;
3688 const wxChar* _datetime = datetime;
3689 rv = self->ParseDateTime(_datetime);
3690 if (rv == NULL) return -1;
3691 return rv - _datetime;
3692 }
3693 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3694 const wxChar* rv;
3695 const wxChar* _date = date;
3696 rv = self->ParseDate(_date);
3697 if (rv == NULL) return -1;
3698 return rv - _date;
3699 }
3700 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3701 const wxChar* rv;
3702 const wxChar* _time = time;
3703 rv = self->ParseTime(_time);
3704 if (rv == NULL) return -1;
3705 return rv - _time;
3706 }
3707 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3708 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3709 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3710 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3711 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3712 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3713 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3714 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3715 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3716 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3717 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3718 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3719 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3720 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3721 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3722 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3723
3724 #include <wx/dataobj.h>
3725
3726 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3727 size_t count = self->GetFormatCount(dir);
3728 wxDataFormat* formats = new wxDataFormat[count];
3729 self->GetAllFormats(formats, dir);
3730
3731 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3732 PyObject* list = PyList_New(count);
3733 for (size_t i=0; i<count; i++) {
3734 wxDataFormat* format = new wxDataFormat(formats[i]);
3735 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3736 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3737 }
3738 wxPyEndBlockThreads(blocked);
3739 delete [] formats;
3740 return list;
3741 }
3742 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3743 PyObject* rval = NULL;
3744 size_t size = self->GetDataSize(format);
3745 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3746 if (size) {
3747 char* buf = new char[size];
3748 if (self->GetDataHere(format, buf))
3749 rval = PyString_FromStringAndSize(buf, size);
3750 delete [] buf;
3751 }
3752 if (! rval) {
3753 rval = Py_None;
3754 Py_INCREF(rval);
3755 }
3756 wxPyEndBlockThreads(blocked);
3757 return rval;
3758 }
3759 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3760 bool rval;
3761 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3762 if (PyString_Check(data)) {
3763 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3764 }
3765 else {
3766 // raise a TypeError if not a string
3767 PyErr_SetString(PyExc_TypeError, "String expected.");
3768 rval = false;
3769 }
3770 wxPyEndBlockThreads(blocked);
3771 return rval;
3772 }
3773 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3774 PyObject* rval = NULL;
3775 size_t size = self->GetDataSize();
3776 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3777 if (size) {
3778 char* buf = new char[size];
3779 if (self->GetDataHere(buf))
3780 rval = PyString_FromStringAndSize(buf, size);
3781 delete [] buf;
3782 }
3783 if (! rval) {
3784 rval = Py_None;
3785 Py_INCREF(rval);
3786 }
3787 wxPyEndBlockThreads(blocked);
3788 return rval;
3789 }
3790 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3791 bool rval;
3792 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3793 if (PyString_Check(data)) {
3794 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3795 }
3796 else {
3797 // raise a TypeError if not a string
3798 PyErr_SetString(PyExc_TypeError, "String expected.");
3799 rval = false;
3800 }
3801 wxPyEndBlockThreads(blocked);
3802 return rval;
3803 }
3804 // Create a new class for wxPython to use
3805 class wxPyDataObjectSimple : public wxDataObjectSimple {
3806 public:
3807 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3808 : wxDataObjectSimple(format) {}
3809
3810 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3811 bool GetDataHere(void *buf) const;
3812 bool SetData(size_t len, const void *buf);
3813 PYPRIVATE;
3814 };
3815
3816 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3817
3818 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3819 // We need to get the data for this object and write it to buf. I think
3820 // the best way to do this for wxPython is to have the Python method
3821 // return either a string or None and then act appropriately with the
3822 // C++ version.
3823
3824 bool rval = false;
3825 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3826 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3827 PyObject* ro;
3828 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3829 if (ro) {
3830 rval = (ro != Py_None && PyString_Check(ro));
3831 if (rval)
3832 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3833 Py_DECREF(ro);
3834 }
3835 }
3836 wxPyEndBlockThreads(blocked);
3837 return rval;
3838 }
3839
3840 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3841 // For this one we simply need to make a string from buf and len
3842 // and send it to the Python method.
3843 bool rval = false;
3844 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3845 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3846 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3847 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3848 Py_DECREF(data);
3849 }
3850 wxPyEndBlockThreads(blocked);
3851 return rval;
3852 }
3853
3854 // Create a new class for wxPython to use
3855 class wxPyTextDataObject : public wxTextDataObject {
3856 public:
3857 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3858 : wxTextDataObject(text) {}
3859
3860 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3861 DEC_PYCALLBACK_STRING__const(GetText);
3862 DEC_PYCALLBACK__STRING(SetText);
3863 PYPRIVATE;
3864 };
3865
3866 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3867 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3868 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3869
3870
3871 // Create a new class for wxPython to use
3872 class wxPyBitmapDataObject : public wxBitmapDataObject {
3873 public:
3874 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3875 : wxBitmapDataObject(bitmap) {}
3876
3877 wxBitmap GetBitmap() const;
3878 void SetBitmap(const wxBitmap& bitmap);
3879 PYPRIVATE;
3880 };
3881
3882 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3883 wxBitmap* rval = &wxNullBitmap;
3884 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3885 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3886 PyObject* ro;
3887 wxBitmap* ptr;
3888 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3889 if (ro) {
3890 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3891 rval = ptr;
3892 Py_DECREF(ro);
3893 }
3894 }
3895 wxPyEndBlockThreads(blocked);
3896 return *rval;
3897 }
3898
3899 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3900 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3901 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3902 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3903 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3904 Py_DECREF(bo);
3905 }
3906 wxPyEndBlockThreads(blocked);
3907 }
3908
3909 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3910 return new wxCustomDataObject(wxDataFormat(formatName));
3911 }
3912 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3913 bool rval;
3914 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3915 if (PyString_Check(data)) {
3916 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3917 }
3918 else {
3919 // raise a TypeError if not a string
3920 PyErr_SetString(PyExc_TypeError, "String expected.");
3921 rval = false;
3922 }
3923 wxPyEndBlockThreads(blocked);
3924 return rval;
3925 }
3926 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3927 PyObject* obj;
3928 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3929 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3930 wxPyEndBlockThreads(blocked);
3931 return obj;
3932 }
3933
3934 class wxMetafileDataObject : public wxDataObjectSimple
3935 {
3936 public:
3937 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3938 };
3939
3940
3941 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3942
3943
3944 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3945 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3946 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3947 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3948 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3949
3950
3951 class wxPyTextDropTarget : public wxTextDropTarget {
3952 public:
3953 wxPyTextDropTarget() {}
3954
3955 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3956
3957 DEC_PYCALLBACK__(OnLeave);
3958 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3959 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3960 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3961 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3962
3963 PYPRIVATE;
3964 };
3965
3966 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3967 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3968 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3969 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3970 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3971 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3972
3973
3974
3975 class wxPyFileDropTarget : public wxFileDropTarget {
3976 public:
3977 wxPyFileDropTarget() {}
3978
3979 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3980
3981 DEC_PYCALLBACK__(OnLeave);
3982 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3983 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3984 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3985 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3986
3987 PYPRIVATE;
3988 };
3989
3990 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3991 const wxArrayString& filenames) {
3992 bool rval = false;
3993 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3994 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3995 PyObject* list = wxArrayString2PyList_helper(filenames);
3996 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3997 Py_DECREF(list);
3998 }
3999 wxPyEndBlockThreads(blocked);
4000 return rval;
4001 }
4002
4003
4004
4005 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4006 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4007 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4008 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4009 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4010
4011
4012
4013
4014 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4015
4016 #include <wx/display.h>
4017
4018 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4019 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4020
4021 #if !wxUSE_DISPLAY
4022 const wxVideoMode wxDefaultVideoMode;
4023 #endif
4024
4025 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4026 #if wxUSE_DISPLAY
4027 PyObject* pyList = NULL;
4028 wxArrayVideoModes arr = self->GetModes(mode);
4029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4030 pyList = PyList_New(0);
4031 for (size_t i=0; i < arr.GetCount(); i++)
4032 {
4033 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4034 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4035 PyList_Append(pyList, pyObj);
4036 Py_DECREF(pyObj);
4037 }
4038 wxPyEndBlockThreads(blocked);
4039 return pyList;
4040 #else
4041 wxPyRaiseNotImplemented();
4042 return NULL;
4043 #endif
4044 }
4045 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4046 #if wxUSE_DISPLAY
4047 return self->GetCurrentMode();
4048 #else
4049 wxPyRaiseNotImplemented();
4050 return wxDefaultVideoMode;
4051 #endif
4052 }
4053 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4054 #if wxUSE_DISPLAY
4055 return self->ChangeMode(mode);
4056 #else
4057 wxPyRaiseNotImplemented();
4058 return false;
4059 #endif
4060 }
4061 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4062 #if wxUSE_DISPLAY
4063 self->ResetMode();
4064 #else
4065 wxPyRaiseNotImplemented();
4066 #endif
4067 }
4068
4069 #include <wx/stdpaths.h>
4070
4071 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4072 return (wxStandardPaths*) &wxStandardPaths::Get();
4073 }
4074
4075 #ifndef wxHAS_POWER_EVENTS
4076 // Dummy class and other definitions for platforms that don't have them
4077
4078 // See wxPython_int.h for wxPowerEvent
4079
4080 enum {
4081 wxEVT_POWER_SUSPENDING,
4082 wxEVT_POWER_SUSPENDED,
4083 wxEVT_POWER_SUSPEND_CANCEL,
4084 wxEVT_POWER_RESUME,
4085 };
4086
4087 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4088 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4089
4090 #endif
4091
4092 #ifdef __cplusplus
4093 extern "C" {
4094 #endif
4095 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4096 PyObject *resultobj = 0;
4097 wxSystemColour arg1 ;
4098 wxColour result;
4099 int val1 ;
4100 int ecode1 = 0 ;
4101 PyObject * obj0 = 0 ;
4102 char * kwnames[] = {
4103 (char *) "index", NULL
4104 };
4105
4106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4107 ecode1 = SWIG_AsVal_int(obj0, &val1);
4108 if (!SWIG_IsOK(ecode1)) {
4109 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4110 }
4111 arg1 = static_cast< wxSystemColour >(val1);
4112 {
4113 if (!wxPyCheckForApp()) SWIG_fail;
4114 PyThreadState* __tstate = wxPyBeginAllowThreads();
4115 result = wxSystemSettings::GetColour(arg1);
4116 wxPyEndAllowThreads(__tstate);
4117 if (PyErr_Occurred()) SWIG_fail;
4118 }
4119 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4120 return resultobj;
4121 fail:
4122 return NULL;
4123 }
4124
4125
4126 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4127 PyObject *resultobj = 0;
4128 wxSystemFont arg1 ;
4129 wxFont result;
4130 int val1 ;
4131 int ecode1 = 0 ;
4132 PyObject * obj0 = 0 ;
4133 char * kwnames[] = {
4134 (char *) "index", NULL
4135 };
4136
4137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4138 ecode1 = SWIG_AsVal_int(obj0, &val1);
4139 if (!SWIG_IsOK(ecode1)) {
4140 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4141 }
4142 arg1 = static_cast< wxSystemFont >(val1);
4143 {
4144 if (!wxPyCheckForApp()) SWIG_fail;
4145 PyThreadState* __tstate = wxPyBeginAllowThreads();
4146 result = wxSystemSettings::GetFont(arg1);
4147 wxPyEndAllowThreads(__tstate);
4148 if (PyErr_Occurred()) SWIG_fail;
4149 }
4150 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4151 return resultobj;
4152 fail:
4153 return NULL;
4154 }
4155
4156
4157 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4158 PyObject *resultobj = 0;
4159 wxSystemMetric arg1 ;
4160 wxWindow *arg2 = (wxWindow *) NULL ;
4161 int result;
4162 int val1 ;
4163 int ecode1 = 0 ;
4164 void *argp2 = 0 ;
4165 int res2 = 0 ;
4166 PyObject * obj0 = 0 ;
4167 PyObject * obj1 = 0 ;
4168 char * kwnames[] = {
4169 (char *) "index",(char *) "win", NULL
4170 };
4171
4172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4173 ecode1 = SWIG_AsVal_int(obj0, &val1);
4174 if (!SWIG_IsOK(ecode1)) {
4175 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4176 }
4177 arg1 = static_cast< wxSystemMetric >(val1);
4178 if (obj1) {
4179 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4180 if (!SWIG_IsOK(res2)) {
4181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4182 }
4183 arg2 = reinterpret_cast< wxWindow * >(argp2);
4184 }
4185 {
4186 if (!wxPyCheckForApp()) SWIG_fail;
4187 PyThreadState* __tstate = wxPyBeginAllowThreads();
4188 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4189 wxPyEndAllowThreads(__tstate);
4190 if (PyErr_Occurred()) SWIG_fail;
4191 }
4192 resultobj = SWIG_From_int(static_cast< int >(result));
4193 return resultobj;
4194 fail:
4195 return NULL;
4196 }
4197
4198
4199 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4200 PyObject *resultobj = 0;
4201 wxSystemFeature arg1 ;
4202 bool result;
4203 int val1 ;
4204 int ecode1 = 0 ;
4205 PyObject * obj0 = 0 ;
4206 char * kwnames[] = {
4207 (char *) "index", NULL
4208 };
4209
4210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4211 ecode1 = SWIG_AsVal_int(obj0, &val1);
4212 if (!SWIG_IsOK(ecode1)) {
4213 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4214 }
4215 arg1 = static_cast< wxSystemFeature >(val1);
4216 {
4217 if (!wxPyCheckForApp()) SWIG_fail;
4218 PyThreadState* __tstate = wxPyBeginAllowThreads();
4219 result = (bool)wxSystemSettings::HasFeature(arg1);
4220 wxPyEndAllowThreads(__tstate);
4221 if (PyErr_Occurred()) SWIG_fail;
4222 }
4223 {
4224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4225 }
4226 return resultobj;
4227 fail:
4228 return NULL;
4229 }
4230
4231
4232 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4233 PyObject *resultobj = 0;
4234 wxSystemScreenType result;
4235
4236 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4237 {
4238 if (!wxPyCheckForApp()) SWIG_fail;
4239 PyThreadState* __tstate = wxPyBeginAllowThreads();
4240 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4241 wxPyEndAllowThreads(__tstate);
4242 if (PyErr_Occurred()) SWIG_fail;
4243 }
4244 resultobj = SWIG_From_int(static_cast< int >(result));
4245 return resultobj;
4246 fail:
4247 return NULL;
4248 }
4249
4250
4251 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4252 PyObject *resultobj = 0;
4253 wxSystemScreenType arg1 ;
4254 int val1 ;
4255 int ecode1 = 0 ;
4256 PyObject * obj0 = 0 ;
4257 char * kwnames[] = {
4258 (char *) "screen", NULL
4259 };
4260
4261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4262 ecode1 = SWIG_AsVal_int(obj0, &val1);
4263 if (!SWIG_IsOK(ecode1)) {
4264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4265 }
4266 arg1 = static_cast< wxSystemScreenType >(val1);
4267 {
4268 if (!wxPyCheckForApp()) SWIG_fail;
4269 PyThreadState* __tstate = wxPyBeginAllowThreads();
4270 wxSystemSettings::SetScreenType(arg1);
4271 wxPyEndAllowThreads(__tstate);
4272 if (PyErr_Occurred()) SWIG_fail;
4273 }
4274 resultobj = SWIG_Py_Void();
4275 return resultobj;
4276 fail:
4277 return NULL;
4278 }
4279
4280
4281 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4282 PyObject *obj;
4283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4284 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4285 return SWIG_Py_Void();
4286 }
4287
4288 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4289 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4290 return 1;
4291 }
4292
4293
4294 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4295 PyObject *pyobj = 0;
4296
4297 {
4298 #if wxUSE_UNICODE
4299 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4300 #else
4301 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4302 #endif
4303 }
4304 return pyobj;
4305 }
4306
4307
4308 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4309 PyObject *resultobj = 0;
4310 wxSystemOptions *result = 0 ;
4311
4312 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4313 {
4314 PyThreadState* __tstate = wxPyBeginAllowThreads();
4315 result = (wxSystemOptions *)new wxSystemOptions();
4316 wxPyEndAllowThreads(__tstate);
4317 if (PyErr_Occurred()) SWIG_fail;
4318 }
4319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4320 return resultobj;
4321 fail:
4322 return NULL;
4323 }
4324
4325
4326 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4327 PyObject *resultobj = 0;
4328 wxString *arg1 = 0 ;
4329 wxString *arg2 = 0 ;
4330 bool temp1 = false ;
4331 bool temp2 = false ;
4332 PyObject * obj0 = 0 ;
4333 PyObject * obj1 = 0 ;
4334 char * kwnames[] = {
4335 (char *) "name",(char *) "value", NULL
4336 };
4337
4338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4339 {
4340 arg1 = wxString_in_helper(obj0);
4341 if (arg1 == NULL) SWIG_fail;
4342 temp1 = true;
4343 }
4344 {
4345 arg2 = wxString_in_helper(obj1);
4346 if (arg2 == NULL) SWIG_fail;
4347 temp2 = true;
4348 }
4349 {
4350 PyThreadState* __tstate = wxPyBeginAllowThreads();
4351 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4352 wxPyEndAllowThreads(__tstate);
4353 if (PyErr_Occurred()) SWIG_fail;
4354 }
4355 resultobj = SWIG_Py_Void();
4356 {
4357 if (temp1)
4358 delete arg1;
4359 }
4360 {
4361 if (temp2)
4362 delete arg2;
4363 }
4364 return resultobj;
4365 fail:
4366 {
4367 if (temp1)
4368 delete arg1;
4369 }
4370 {
4371 if (temp2)
4372 delete arg2;
4373 }
4374 return NULL;
4375 }
4376
4377
4378 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4379 PyObject *resultobj = 0;
4380 wxString *arg1 = 0 ;
4381 int arg2 ;
4382 bool temp1 = false ;
4383 int val2 ;
4384 int ecode2 = 0 ;
4385 PyObject * obj0 = 0 ;
4386 PyObject * obj1 = 0 ;
4387 char * kwnames[] = {
4388 (char *) "name",(char *) "value", NULL
4389 };
4390
4391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4392 {
4393 arg1 = wxString_in_helper(obj0);
4394 if (arg1 == NULL) SWIG_fail;
4395 temp1 = true;
4396 }
4397 ecode2 = SWIG_AsVal_int(obj1, &val2);
4398 if (!SWIG_IsOK(ecode2)) {
4399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4400 }
4401 arg2 = static_cast< int >(val2);
4402 {
4403 PyThreadState* __tstate = wxPyBeginAllowThreads();
4404 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4405 wxPyEndAllowThreads(__tstate);
4406 if (PyErr_Occurred()) SWIG_fail;
4407 }
4408 resultobj = SWIG_Py_Void();
4409 {
4410 if (temp1)
4411 delete arg1;
4412 }
4413 return resultobj;
4414 fail:
4415 {
4416 if (temp1)
4417 delete arg1;
4418 }
4419 return NULL;
4420 }
4421
4422
4423 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4424 PyObject *resultobj = 0;
4425 wxString *arg1 = 0 ;
4426 wxString result;
4427 bool temp1 = false ;
4428 PyObject * obj0 = 0 ;
4429 char * kwnames[] = {
4430 (char *) "name", NULL
4431 };
4432
4433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4434 {
4435 arg1 = wxString_in_helper(obj0);
4436 if (arg1 == NULL) SWIG_fail;
4437 temp1 = true;
4438 }
4439 {
4440 PyThreadState* __tstate = wxPyBeginAllowThreads();
4441 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4442 wxPyEndAllowThreads(__tstate);
4443 if (PyErr_Occurred()) SWIG_fail;
4444 }
4445 {
4446 #if wxUSE_UNICODE
4447 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4448 #else
4449 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4450 #endif
4451 }
4452 {
4453 if (temp1)
4454 delete arg1;
4455 }
4456 return resultobj;
4457 fail:
4458 {
4459 if (temp1)
4460 delete arg1;
4461 }
4462 return NULL;
4463 }
4464
4465
4466 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4467 PyObject *resultobj = 0;
4468 wxString *arg1 = 0 ;
4469 int result;
4470 bool temp1 = false ;
4471 PyObject * obj0 = 0 ;
4472 char * kwnames[] = {
4473 (char *) "name", NULL
4474 };
4475
4476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4477 {
4478 arg1 = wxString_in_helper(obj0);
4479 if (arg1 == NULL) SWIG_fail;
4480 temp1 = true;
4481 }
4482 {
4483 PyThreadState* __tstate = wxPyBeginAllowThreads();
4484 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4485 wxPyEndAllowThreads(__tstate);
4486 if (PyErr_Occurred()) SWIG_fail;
4487 }
4488 resultobj = SWIG_From_int(static_cast< int >(result));
4489 {
4490 if (temp1)
4491 delete arg1;
4492 }
4493 return resultobj;
4494 fail:
4495 {
4496 if (temp1)
4497 delete arg1;
4498 }
4499 return NULL;
4500 }
4501
4502
4503 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4504 PyObject *resultobj = 0;
4505 wxString *arg1 = 0 ;
4506 bool result;
4507 bool temp1 = false ;
4508 PyObject * obj0 = 0 ;
4509 char * kwnames[] = {
4510 (char *) "name", NULL
4511 };
4512
4513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4514 {
4515 arg1 = wxString_in_helper(obj0);
4516 if (arg1 == NULL) SWIG_fail;
4517 temp1 = true;
4518 }
4519 {
4520 PyThreadState* __tstate = wxPyBeginAllowThreads();
4521 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4522 wxPyEndAllowThreads(__tstate);
4523 if (PyErr_Occurred()) SWIG_fail;
4524 }
4525 {
4526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4527 }
4528 {
4529 if (temp1)
4530 delete arg1;
4531 }
4532 return resultobj;
4533 fail:
4534 {
4535 if (temp1)
4536 delete arg1;
4537 }
4538 return NULL;
4539 }
4540
4541
4542 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4543 PyObject *resultobj = 0;
4544 wxString *arg1 = 0 ;
4545 bool result;
4546 bool temp1 = false ;
4547 PyObject * obj0 = 0 ;
4548 char * kwnames[] = {
4549 (char *) "name", NULL
4550 };
4551
4552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4553 {
4554 arg1 = wxString_in_helper(obj0);
4555 if (arg1 == NULL) SWIG_fail;
4556 temp1 = true;
4557 }
4558 {
4559 PyThreadState* __tstate = wxPyBeginAllowThreads();
4560 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4561 wxPyEndAllowThreads(__tstate);
4562 if (PyErr_Occurred()) SWIG_fail;
4563 }
4564 {
4565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4566 }
4567 {
4568 if (temp1)
4569 delete arg1;
4570 }
4571 return resultobj;
4572 fail:
4573 {
4574 if (temp1)
4575 delete arg1;
4576 }
4577 return NULL;
4578 }
4579
4580
4581 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4582 PyObject *obj;
4583 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4584 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4585 return SWIG_Py_Void();
4586 }
4587
4588 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4589 return SWIG_Python_InitShadowInstance(args);
4590 }
4591
4592 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4593 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4594 return 1;
4595 }
4596
4597
4598 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4599 PyObject *pyobj = 0;
4600
4601 {
4602 #if wxUSE_UNICODE
4603 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4604 #else
4605 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4606 #endif
4607 }
4608 return pyobj;
4609 }
4610
4611
4612 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4613 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4614 return 1;
4615 }
4616
4617
4618 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4619 PyObject *pyobj = 0;
4620
4621 {
4622 #if wxUSE_UNICODE
4623 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4624 #else
4625 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4626 #endif
4627 }
4628 return pyobj;
4629 }
4630
4631
4632 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4633 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4634 return 1;
4635 }
4636
4637
4638 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4639 PyObject *pyobj = 0;
4640
4641 {
4642 #if wxUSE_UNICODE
4643 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4644 #else
4645 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4646 #endif
4647 }
4648 return pyobj;
4649 }
4650
4651
4652 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4653 PyObject *resultobj = 0;
4654 long result;
4655
4656 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4657 {
4658 PyThreadState* __tstate = wxPyBeginAllowThreads();
4659 result = (long)wxNewId();
4660 wxPyEndAllowThreads(__tstate);
4661 if (PyErr_Occurred()) SWIG_fail;
4662 }
4663 resultobj = SWIG_From_long(static_cast< long >(result));
4664 return resultobj;
4665 fail:
4666 return NULL;
4667 }
4668
4669
4670 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4671 PyObject *resultobj = 0;
4672 long arg1 ;
4673 long val1 ;
4674 int ecode1 = 0 ;
4675 PyObject * obj0 = 0 ;
4676 char * kwnames[] = {
4677 (char *) "id", NULL
4678 };
4679
4680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4681 ecode1 = SWIG_AsVal_long(obj0, &val1);
4682 if (!SWIG_IsOK(ecode1)) {
4683 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4684 }
4685 arg1 = static_cast< long >(val1);
4686 {
4687 PyThreadState* __tstate = wxPyBeginAllowThreads();
4688 wxRegisterId(arg1);
4689 wxPyEndAllowThreads(__tstate);
4690 if (PyErr_Occurred()) SWIG_fail;
4691 }
4692 resultobj = SWIG_Py_Void();
4693 return resultobj;
4694 fail:
4695 return NULL;
4696 }
4697
4698
4699 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4700 PyObject *resultobj = 0;
4701 long result;
4702
4703 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4704 {
4705 PyThreadState* __tstate = wxPyBeginAllowThreads();
4706 result = (long)wxGetCurrentId();
4707 wxPyEndAllowThreads(__tstate);
4708 if (PyErr_Occurred()) SWIG_fail;
4709 }
4710 resultobj = SWIG_From_long(static_cast< long >(result));
4711 return resultobj;
4712 fail:
4713 return NULL;
4714 }
4715
4716
4717 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4718 PyObject *resultobj = 0;
4719 int arg1 ;
4720 bool result;
4721 int val1 ;
4722 int ecode1 = 0 ;
4723 PyObject * obj0 = 0 ;
4724 char * kwnames[] = {
4725 (char *) "id", NULL
4726 };
4727
4728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4729 ecode1 = SWIG_AsVal_int(obj0, &val1);
4730 if (!SWIG_IsOK(ecode1)) {
4731 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4732 }
4733 arg1 = static_cast< int >(val1);
4734 {
4735 PyThreadState* __tstate = wxPyBeginAllowThreads();
4736 result = (bool)wxIsStockID(arg1);
4737 wxPyEndAllowThreads(__tstate);
4738 if (PyErr_Occurred()) SWIG_fail;
4739 }
4740 {
4741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4742 }
4743 return resultobj;
4744 fail:
4745 return NULL;
4746 }
4747
4748
4749 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4750 PyObject *resultobj = 0;
4751 int arg1 ;
4752 wxString *arg2 = 0 ;
4753 bool result;
4754 int val1 ;
4755 int ecode1 = 0 ;
4756 bool temp2 = false ;
4757 PyObject * obj0 = 0 ;
4758 PyObject * obj1 = 0 ;
4759 char * kwnames[] = {
4760 (char *) "id",(char *) "label", NULL
4761 };
4762
4763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4764 ecode1 = SWIG_AsVal_int(obj0, &val1);
4765 if (!SWIG_IsOK(ecode1)) {
4766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4767 }
4768 arg1 = static_cast< int >(val1);
4769 {
4770 arg2 = wxString_in_helper(obj1);
4771 if (arg2 == NULL) SWIG_fail;
4772 temp2 = true;
4773 }
4774 {
4775 PyThreadState* __tstate = wxPyBeginAllowThreads();
4776 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4777 wxPyEndAllowThreads(__tstate);
4778 if (PyErr_Occurred()) SWIG_fail;
4779 }
4780 {
4781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4782 }
4783 {
4784 if (temp2)
4785 delete arg2;
4786 }
4787 return resultobj;
4788 fail:
4789 {
4790 if (temp2)
4791 delete arg2;
4792 }
4793 return NULL;
4794 }
4795
4796
4797 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4798 PyObject *resultobj = 0;
4799 int arg1 ;
4800 bool arg2 = (bool) true ;
4801 wxString arg3 = (wxString) wxPyEmptyString ;
4802 wxString result;
4803 int val1 ;
4804 int ecode1 = 0 ;
4805 bool val2 ;
4806 int ecode2 = 0 ;
4807 PyObject * obj0 = 0 ;
4808 PyObject * obj1 = 0 ;
4809 PyObject * obj2 = 0 ;
4810 char * kwnames[] = {
4811 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4812 };
4813
4814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4815 ecode1 = SWIG_AsVal_int(obj0, &val1);
4816 if (!SWIG_IsOK(ecode1)) {
4817 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4818 }
4819 arg1 = static_cast< int >(val1);
4820 if (obj1) {
4821 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4822 if (!SWIG_IsOK(ecode2)) {
4823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4824 }
4825 arg2 = static_cast< bool >(val2);
4826 }
4827 if (obj2) {
4828 {
4829 wxString* sptr = wxString_in_helper(obj2);
4830 if (sptr == NULL) SWIG_fail;
4831 arg3 = *sptr;
4832 delete sptr;
4833 }
4834 }
4835 {
4836 PyThreadState* __tstate = wxPyBeginAllowThreads();
4837 result = wxGetStockLabel(arg1,arg2,arg3);
4838 wxPyEndAllowThreads(__tstate);
4839 if (PyErr_Occurred()) SWIG_fail;
4840 }
4841 {
4842 #if wxUSE_UNICODE
4843 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4844 #else
4845 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4846 #endif
4847 }
4848 return resultobj;
4849 fail:
4850 return NULL;
4851 }
4852
4853
4854 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4855 PyObject *resultobj = 0;
4856
4857 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4858 {
4859 if (!wxPyCheckForApp()) SWIG_fail;
4860 PyThreadState* __tstate = wxPyBeginAllowThreads();
4861 wxBell();
4862 wxPyEndAllowThreads(__tstate);
4863 if (PyErr_Occurred()) SWIG_fail;
4864 }
4865 resultobj = SWIG_Py_Void();
4866 return resultobj;
4867 fail:
4868 return NULL;
4869 }
4870
4871
4872 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4873 PyObject *resultobj = 0;
4874
4875 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4876 {
4877 if (!wxPyCheckForApp()) SWIG_fail;
4878 PyThreadState* __tstate = wxPyBeginAllowThreads();
4879 wxEndBusyCursor();
4880 wxPyEndAllowThreads(__tstate);
4881 if (PyErr_Occurred()) SWIG_fail;
4882 }
4883 resultobj = SWIG_Py_Void();
4884 return resultobj;
4885 fail:
4886 return NULL;
4887 }
4888
4889
4890 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4891 PyObject *resultobj = 0;
4892 bool arg1 = (bool) true ;
4893 long result;
4894 bool val1 ;
4895 int ecode1 = 0 ;
4896 PyObject * obj0 = 0 ;
4897 char * kwnames[] = {
4898 (char *) "resetTimer", NULL
4899 };
4900
4901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4902 if (obj0) {
4903 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4904 if (!SWIG_IsOK(ecode1)) {
4905 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4906 }
4907 arg1 = static_cast< bool >(val1);
4908 }
4909 {
4910 PyThreadState* __tstate = wxPyBeginAllowThreads();
4911 result = (long)wxGetElapsedTime(arg1);
4912 wxPyEndAllowThreads(__tstate);
4913 if (PyErr_Occurred()) SWIG_fail;
4914 }
4915 resultobj = SWIG_From_long(static_cast< long >(result));
4916 return resultobj;
4917 fail:
4918 return NULL;
4919 }
4920
4921
4922 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4923 PyObject *resultobj = 0;
4924 bool result;
4925
4926 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4927 {
4928 PyThreadState* __tstate = wxPyBeginAllowThreads();
4929 result = (bool)wxIsBusy();
4930 wxPyEndAllowThreads(__tstate);
4931 if (PyErr_Occurred()) SWIG_fail;
4932 }
4933 {
4934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4935 }
4936 return resultobj;
4937 fail:
4938 return NULL;
4939 }
4940
4941
4942 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4943 PyObject *resultobj = 0;
4944 wxString result;
4945
4946 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4947 {
4948 PyThreadState* __tstate = wxPyBeginAllowThreads();
4949 result = wxNow();
4950 wxPyEndAllowThreads(__tstate);
4951 if (PyErr_Occurred()) SWIG_fail;
4952 }
4953 {
4954 #if wxUSE_UNICODE
4955 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4956 #else
4957 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4958 #endif
4959 }
4960 return resultobj;
4961 fail:
4962 return NULL;
4963 }
4964
4965
4966 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4967 PyObject *resultobj = 0;
4968 wxString const &arg1_defvalue = wxPyEmptyString ;
4969 wxString *arg1 = (wxString *) &arg1_defvalue ;
4970 bool result;
4971 bool temp1 = false ;
4972 PyObject * obj0 = 0 ;
4973 char * kwnames[] = {
4974 (char *) "command", NULL
4975 };
4976
4977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4978 if (obj0) {
4979 {
4980 arg1 = wxString_in_helper(obj0);
4981 if (arg1 == NULL) SWIG_fail;
4982 temp1 = true;
4983 }
4984 }
4985 {
4986 PyThreadState* __tstate = wxPyBeginAllowThreads();
4987 result = (bool)wxShell((wxString const &)*arg1);
4988 wxPyEndAllowThreads(__tstate);
4989 if (PyErr_Occurred()) SWIG_fail;
4990 }
4991 {
4992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4993 }
4994 {
4995 if (temp1)
4996 delete arg1;
4997 }
4998 return resultobj;
4999 fail:
5000 {
5001 if (temp1)
5002 delete arg1;
5003 }
5004 return NULL;
5005 }
5006
5007
5008 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5009 PyObject *resultobj = 0;
5010
5011 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5012 {
5013 PyThreadState* __tstate = wxPyBeginAllowThreads();
5014 wxStartTimer();
5015 wxPyEndAllowThreads(__tstate);
5016 if (PyErr_Occurred()) SWIG_fail;
5017 }
5018 resultobj = SWIG_Py_Void();
5019 return resultobj;
5020 fail:
5021 return NULL;
5022 }
5023
5024
5025 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5026 PyObject *resultobj = 0;
5027 int *arg1 = (int *) 0 ;
5028 int *arg2 = (int *) 0 ;
5029 int result;
5030 int temp1 ;
5031 int res1 = SWIG_TMPOBJ ;
5032 int temp2 ;
5033 int res2 = SWIG_TMPOBJ ;
5034
5035 arg1 = &temp1;
5036 arg2 = &temp2;
5037 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5038 {
5039 PyThreadState* __tstate = wxPyBeginAllowThreads();
5040 result = (int)wxGetOsVersion(arg1,arg2);
5041 wxPyEndAllowThreads(__tstate);
5042 if (PyErr_Occurred()) SWIG_fail;
5043 }
5044 resultobj = SWIG_From_int(static_cast< int >(result));
5045 if (SWIG_IsTmpObj(res1)) {
5046 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5047 } else {
5048 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5049 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5050 }
5051 if (SWIG_IsTmpObj(res2)) {
5052 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5053 } else {
5054 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5055 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5056 }
5057 return resultobj;
5058 fail:
5059 return NULL;
5060 }
5061
5062
5063 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5064 PyObject *resultobj = 0;
5065 wxString result;
5066
5067 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5068 {
5069 PyThreadState* __tstate = wxPyBeginAllowThreads();
5070 result = wxGetOsDescription();
5071 wxPyEndAllowThreads(__tstate);
5072 if (PyErr_Occurred()) SWIG_fail;
5073 }
5074 {
5075 #if wxUSE_UNICODE
5076 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5077 #else
5078 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5079 #endif
5080 }
5081 return resultobj;
5082 fail:
5083 return NULL;
5084 }
5085
5086
5087 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5088 PyObject *resultobj = 0;
5089 bool result;
5090
5091 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5092 {
5093 PyThreadState* __tstate = wxPyBeginAllowThreads();
5094 result = (bool)wxIsPlatformLittleEndian();
5095 wxPyEndAllowThreads(__tstate);
5096 if (PyErr_Occurred()) SWIG_fail;
5097 }
5098 {
5099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5100 }
5101 return resultobj;
5102 fail:
5103 return NULL;
5104 }
5105
5106
5107 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5108 PyObject *resultobj = 0;
5109 bool result;
5110
5111 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5112 {
5113 PyThreadState* __tstate = wxPyBeginAllowThreads();
5114 result = (bool)wxIsPlatform64Bit();
5115 wxPyEndAllowThreads(__tstate);
5116 if (PyErr_Occurred()) SWIG_fail;
5117 }
5118 {
5119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5120 }
5121 return resultobj;
5122 fail:
5123 return NULL;
5124 }
5125
5126
5127 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5128 PyObject *resultobj = 0;
5129 wxMemorySize result;
5130
5131 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5132 {
5133 PyThreadState* __tstate = wxPyBeginAllowThreads();
5134 result = wxGetFreeMemory();
5135 wxPyEndAllowThreads(__tstate);
5136 if (PyErr_Occurred()) SWIG_fail;
5137 }
5138 {
5139 #if wxUSE_LONGLONG
5140 resultobj = PyLong_FromLongLong((&result)->GetValue());
5141 #else
5142 resultobj = PyInt_FromLong(result);
5143 #endif
5144 }
5145 return resultobj;
5146 fail:
5147 return NULL;
5148 }
5149
5150
5151 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5152 PyObject *resultobj = 0;
5153 wxShutdownFlags arg1 ;
5154 bool result;
5155 int val1 ;
5156 int ecode1 = 0 ;
5157 PyObject * obj0 = 0 ;
5158 char * kwnames[] = {
5159 (char *) "wFlags", NULL
5160 };
5161
5162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5163 ecode1 = SWIG_AsVal_int(obj0, &val1);
5164 if (!SWIG_IsOK(ecode1)) {
5165 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5166 }
5167 arg1 = static_cast< wxShutdownFlags >(val1);
5168 {
5169 if (!wxPyCheckForApp()) SWIG_fail;
5170 PyThreadState* __tstate = wxPyBeginAllowThreads();
5171 result = (bool)wxShutdown(arg1);
5172 wxPyEndAllowThreads(__tstate);
5173 if (PyErr_Occurred()) SWIG_fail;
5174 }
5175 {
5176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5177 }
5178 return resultobj;
5179 fail:
5180 return NULL;
5181 }
5182
5183
5184 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5185 PyObject *resultobj = 0;
5186 int arg1 ;
5187 int val1 ;
5188 int ecode1 = 0 ;
5189 PyObject * obj0 = 0 ;
5190 char * kwnames[] = {
5191 (char *) "secs", NULL
5192 };
5193
5194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5195 ecode1 = SWIG_AsVal_int(obj0, &val1);
5196 if (!SWIG_IsOK(ecode1)) {
5197 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5198 }
5199 arg1 = static_cast< int >(val1);
5200 {
5201 PyThreadState* __tstate = wxPyBeginAllowThreads();
5202 wxSleep(arg1);
5203 wxPyEndAllowThreads(__tstate);
5204 if (PyErr_Occurred()) SWIG_fail;
5205 }
5206 resultobj = SWIG_Py_Void();
5207 return resultobj;
5208 fail:
5209 return NULL;
5210 }
5211
5212
5213 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5214 PyObject *resultobj = 0;
5215 unsigned long arg1 ;
5216 unsigned long val1 ;
5217 int ecode1 = 0 ;
5218 PyObject * obj0 = 0 ;
5219 char * kwnames[] = {
5220 (char *) "milliseconds", NULL
5221 };
5222
5223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5224 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5225 if (!SWIG_IsOK(ecode1)) {
5226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5227 }
5228 arg1 = static_cast< unsigned long >(val1);
5229 {
5230 PyThreadState* __tstate = wxPyBeginAllowThreads();
5231 wxMilliSleep(arg1);
5232 wxPyEndAllowThreads(__tstate);
5233 if (PyErr_Occurred()) SWIG_fail;
5234 }
5235 resultobj = SWIG_Py_Void();
5236 return resultobj;
5237 fail:
5238 return NULL;
5239 }
5240
5241
5242 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5243 PyObject *resultobj = 0;
5244 unsigned long arg1 ;
5245 unsigned long val1 ;
5246 int ecode1 = 0 ;
5247 PyObject * obj0 = 0 ;
5248 char * kwnames[] = {
5249 (char *) "microseconds", NULL
5250 };
5251
5252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5253 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5254 if (!SWIG_IsOK(ecode1)) {
5255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5256 }
5257 arg1 = static_cast< unsigned long >(val1);
5258 {
5259 PyThreadState* __tstate = wxPyBeginAllowThreads();
5260 wxMicroSleep(arg1);
5261 wxPyEndAllowThreads(__tstate);
5262 if (PyErr_Occurred()) SWIG_fail;
5263 }
5264 resultobj = SWIG_Py_Void();
5265 return resultobj;
5266 fail:
5267 return NULL;
5268 }
5269
5270
5271 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5272 PyObject *resultobj = 0;
5273 bool arg1 ;
5274 bool val1 ;
5275 int ecode1 = 0 ;
5276 PyObject * obj0 = 0 ;
5277 char * kwnames[] = {
5278 (char *) "enable", NULL
5279 };
5280
5281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5282 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5283 if (!SWIG_IsOK(ecode1)) {
5284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5285 }
5286 arg1 = static_cast< bool >(val1);
5287 {
5288 PyThreadState* __tstate = wxPyBeginAllowThreads();
5289 wxEnableTopLevelWindows(arg1);
5290 wxPyEndAllowThreads(__tstate);
5291 if (PyErr_Occurred()) SWIG_fail;
5292 }
5293 resultobj = SWIG_Py_Void();
5294 return resultobj;
5295 fail:
5296 return NULL;
5297 }
5298
5299
5300 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5301 PyObject *resultobj = 0;
5302 wxString *arg1 = 0 ;
5303 wxString result;
5304 bool temp1 = false ;
5305 PyObject * obj0 = 0 ;
5306 char * kwnames[] = {
5307 (char *) "in", NULL
5308 };
5309
5310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5311 {
5312 arg1 = wxString_in_helper(obj0);
5313 if (arg1 == NULL) SWIG_fail;
5314 temp1 = true;
5315 }
5316 {
5317 PyThreadState* __tstate = wxPyBeginAllowThreads();
5318 result = wxStripMenuCodes((wxString const &)*arg1);
5319 wxPyEndAllowThreads(__tstate);
5320 if (PyErr_Occurred()) SWIG_fail;
5321 }
5322 {
5323 #if wxUSE_UNICODE
5324 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5325 #else
5326 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5327 #endif
5328 }
5329 {
5330 if (temp1)
5331 delete arg1;
5332 }
5333 return resultobj;
5334 fail:
5335 {
5336 if (temp1)
5337 delete arg1;
5338 }
5339 return NULL;
5340 }
5341
5342
5343 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5344 PyObject *resultobj = 0;
5345 wxString result;
5346
5347 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5348 {
5349 PyThreadState* __tstate = wxPyBeginAllowThreads();
5350 result = wxGetEmailAddress();
5351 wxPyEndAllowThreads(__tstate);
5352 if (PyErr_Occurred()) SWIG_fail;
5353 }
5354 {
5355 #if wxUSE_UNICODE
5356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5357 #else
5358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5359 #endif
5360 }
5361 return resultobj;
5362 fail:
5363 return NULL;
5364 }
5365
5366
5367 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5368 PyObject *resultobj = 0;
5369 wxString result;
5370
5371 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5372 {
5373 PyThreadState* __tstate = wxPyBeginAllowThreads();
5374 result = wxGetHostName();
5375 wxPyEndAllowThreads(__tstate);
5376 if (PyErr_Occurred()) SWIG_fail;
5377 }
5378 {
5379 #if wxUSE_UNICODE
5380 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5381 #else
5382 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5383 #endif
5384 }
5385 return resultobj;
5386 fail:
5387 return NULL;
5388 }
5389
5390
5391 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5392 PyObject *resultobj = 0;
5393 wxString result;
5394
5395 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5396 {
5397 PyThreadState* __tstate = wxPyBeginAllowThreads();
5398 result = wxGetFullHostName();
5399 wxPyEndAllowThreads(__tstate);
5400 if (PyErr_Occurred()) SWIG_fail;
5401 }
5402 {
5403 #if wxUSE_UNICODE
5404 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5405 #else
5406 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5407 #endif
5408 }
5409 return resultobj;
5410 fail:
5411 return NULL;
5412 }
5413
5414
5415 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5416 PyObject *resultobj = 0;
5417 wxString result;
5418
5419 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5420 {
5421 PyThreadState* __tstate = wxPyBeginAllowThreads();
5422 result = wxGetUserId();
5423 wxPyEndAllowThreads(__tstate);
5424 if (PyErr_Occurred()) SWIG_fail;
5425 }
5426 {
5427 #if wxUSE_UNICODE
5428 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5429 #else
5430 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5431 #endif
5432 }
5433 return resultobj;
5434 fail:
5435 return NULL;
5436 }
5437
5438
5439 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5440 PyObject *resultobj = 0;
5441 wxString result;
5442
5443 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5444 {
5445 PyThreadState* __tstate = wxPyBeginAllowThreads();
5446 result = wxGetUserName();
5447 wxPyEndAllowThreads(__tstate);
5448 if (PyErr_Occurred()) SWIG_fail;
5449 }
5450 {
5451 #if wxUSE_UNICODE
5452 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5453 #else
5454 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5455 #endif
5456 }
5457 return resultobj;
5458 fail:
5459 return NULL;
5460 }
5461
5462
5463 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5464 PyObject *resultobj = 0;
5465 wxString result;
5466
5467 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5468 {
5469 PyThreadState* __tstate = wxPyBeginAllowThreads();
5470 result = wxGetHomeDir();
5471 wxPyEndAllowThreads(__tstate);
5472 if (PyErr_Occurred()) SWIG_fail;
5473 }
5474 {
5475 #if wxUSE_UNICODE
5476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5477 #else
5478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5479 #endif
5480 }
5481 return resultobj;
5482 fail:
5483 return NULL;
5484 }
5485
5486
5487 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5488 PyObject *resultobj = 0;
5489 wxString const &arg1_defvalue = wxPyEmptyString ;
5490 wxString *arg1 = (wxString *) &arg1_defvalue ;
5491 wxString result;
5492 bool temp1 = false ;
5493 PyObject * obj0 = 0 ;
5494 char * kwnames[] = {
5495 (char *) "user", NULL
5496 };
5497
5498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5499 if (obj0) {
5500 {
5501 arg1 = wxString_in_helper(obj0);
5502 if (arg1 == NULL) SWIG_fail;
5503 temp1 = true;
5504 }
5505 }
5506 {
5507 PyThreadState* __tstate = wxPyBeginAllowThreads();
5508 result = wxGetUserHome((wxString const &)*arg1);
5509 wxPyEndAllowThreads(__tstate);
5510 if (PyErr_Occurred()) SWIG_fail;
5511 }
5512 {
5513 #if wxUSE_UNICODE
5514 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5515 #else
5516 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5517 #endif
5518 }
5519 {
5520 if (temp1)
5521 delete arg1;
5522 }
5523 return resultobj;
5524 fail:
5525 {
5526 if (temp1)
5527 delete arg1;
5528 }
5529 return NULL;
5530 }
5531
5532
5533 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5534 PyObject *resultobj = 0;
5535 unsigned long result;
5536
5537 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5538 {
5539 PyThreadState* __tstate = wxPyBeginAllowThreads();
5540 result = (unsigned long)wxGetProcessId();
5541 wxPyEndAllowThreads(__tstate);
5542 if (PyErr_Occurred()) SWIG_fail;
5543 }
5544 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5545 return resultobj;
5546 fail:
5547 return NULL;
5548 }
5549
5550
5551 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5552 PyObject *resultobj = 0;
5553
5554 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5555 {
5556 PyThreadState* __tstate = wxPyBeginAllowThreads();
5557 wxTrap();
5558 wxPyEndAllowThreads(__tstate);
5559 if (PyErr_Occurred()) SWIG_fail;
5560 }
5561 resultobj = SWIG_Py_Void();
5562 return resultobj;
5563 fail:
5564 return NULL;
5565 }
5566
5567
5568 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5569 PyObject *resultobj = 0;
5570 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5571 wxString *arg1 = (wxString *) &arg1_defvalue ;
5572 wxString const &arg2_defvalue = wxPyEmptyString ;
5573 wxString *arg2 = (wxString *) &arg2_defvalue ;
5574 wxString const &arg3_defvalue = wxPyEmptyString ;
5575 wxString *arg3 = (wxString *) &arg3_defvalue ;
5576 wxString const &arg4_defvalue = wxPyEmptyString ;
5577 wxString *arg4 = (wxString *) &arg4_defvalue ;
5578 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5579 wxString *arg5 = (wxString *) &arg5_defvalue ;
5580 int arg6 = (int) 0 ;
5581 wxWindow *arg7 = (wxWindow *) NULL ;
5582 int arg8 = (int) -1 ;
5583 int arg9 = (int) -1 ;
5584 wxString result;
5585 bool temp1 = false ;
5586 bool temp2 = false ;
5587 bool temp3 = false ;
5588 bool temp4 = false ;
5589 bool temp5 = false ;
5590 int val6 ;
5591 int ecode6 = 0 ;
5592 void *argp7 = 0 ;
5593 int res7 = 0 ;
5594 int val8 ;
5595 int ecode8 = 0 ;
5596 int val9 ;
5597 int ecode9 = 0 ;
5598 PyObject * obj0 = 0 ;
5599 PyObject * obj1 = 0 ;
5600 PyObject * obj2 = 0 ;
5601 PyObject * obj3 = 0 ;
5602 PyObject * obj4 = 0 ;
5603 PyObject * obj5 = 0 ;
5604 PyObject * obj6 = 0 ;
5605 PyObject * obj7 = 0 ;
5606 PyObject * obj8 = 0 ;
5607 char * kwnames[] = {
5608 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5609 };
5610
5611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5612 if (obj0) {
5613 {
5614 arg1 = wxString_in_helper(obj0);
5615 if (arg1 == NULL) SWIG_fail;
5616 temp1 = true;
5617 }
5618 }
5619 if (obj1) {
5620 {
5621 arg2 = wxString_in_helper(obj1);
5622 if (arg2 == NULL) SWIG_fail;
5623 temp2 = true;
5624 }
5625 }
5626 if (obj2) {
5627 {
5628 arg3 = wxString_in_helper(obj2);
5629 if (arg3 == NULL) SWIG_fail;
5630 temp3 = true;
5631 }
5632 }
5633 if (obj3) {
5634 {
5635 arg4 = wxString_in_helper(obj3);
5636 if (arg4 == NULL) SWIG_fail;
5637 temp4 = true;
5638 }
5639 }
5640 if (obj4) {
5641 {
5642 arg5 = wxString_in_helper(obj4);
5643 if (arg5 == NULL) SWIG_fail;
5644 temp5 = true;
5645 }
5646 }
5647 if (obj5) {
5648 ecode6 = SWIG_AsVal_int(obj5, &val6);
5649 if (!SWIG_IsOK(ecode6)) {
5650 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5651 }
5652 arg6 = static_cast< int >(val6);
5653 }
5654 if (obj6) {
5655 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5656 if (!SWIG_IsOK(res7)) {
5657 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5658 }
5659 arg7 = reinterpret_cast< wxWindow * >(argp7);
5660 }
5661 if (obj7) {
5662 ecode8 = SWIG_AsVal_int(obj7, &val8);
5663 if (!SWIG_IsOK(ecode8)) {
5664 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5665 }
5666 arg8 = static_cast< int >(val8);
5667 }
5668 if (obj8) {
5669 ecode9 = SWIG_AsVal_int(obj8, &val9);
5670 if (!SWIG_IsOK(ecode9)) {
5671 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5672 }
5673 arg9 = static_cast< int >(val9);
5674 }
5675 {
5676 if (!wxPyCheckForApp()) SWIG_fail;
5677 PyThreadState* __tstate = wxPyBeginAllowThreads();
5678 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5679 wxPyEndAllowThreads(__tstate);
5680 if (PyErr_Occurred()) SWIG_fail;
5681 }
5682 {
5683 #if wxUSE_UNICODE
5684 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5685 #else
5686 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5687 #endif
5688 }
5689 {
5690 if (temp1)
5691 delete arg1;
5692 }
5693 {
5694 if (temp2)
5695 delete arg2;
5696 }
5697 {
5698 if (temp3)
5699 delete arg3;
5700 }
5701 {
5702 if (temp4)
5703 delete arg4;
5704 }
5705 {
5706 if (temp5)
5707 delete arg5;
5708 }
5709 return resultobj;
5710 fail:
5711 {
5712 if (temp1)
5713 delete arg1;
5714 }
5715 {
5716 if (temp2)
5717 delete arg2;
5718 }
5719 {
5720 if (temp3)
5721 delete arg3;
5722 }
5723 {
5724 if (temp4)
5725 delete arg4;
5726 }
5727 {
5728 if (temp5)
5729 delete arg5;
5730 }
5731 return NULL;
5732 }
5733
5734
5735 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5736 PyObject *resultobj = 0;
5737 wxString *arg1 = 0 ;
5738 wxString *arg2 = 0 ;
5739 wxString const &arg3_defvalue = wxPyEmptyString ;
5740 wxString *arg3 = (wxString *) &arg3_defvalue ;
5741 wxWindow *arg4 = (wxWindow *) NULL ;
5742 wxString result;
5743 bool temp1 = false ;
5744 bool temp2 = false ;
5745 bool temp3 = false ;
5746 void *argp4 = 0 ;
5747 int res4 = 0 ;
5748 PyObject * obj0 = 0 ;
5749 PyObject * obj1 = 0 ;
5750 PyObject * obj2 = 0 ;
5751 PyObject * obj3 = 0 ;
5752 char * kwnames[] = {
5753 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5754 };
5755
5756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5757 {
5758 arg1 = wxString_in_helper(obj0);
5759 if (arg1 == NULL) SWIG_fail;
5760 temp1 = true;
5761 }
5762 {
5763 arg2 = wxString_in_helper(obj1);
5764 if (arg2 == NULL) SWIG_fail;
5765 temp2 = true;
5766 }
5767 if (obj2) {
5768 {
5769 arg3 = wxString_in_helper(obj2);
5770 if (arg3 == NULL) SWIG_fail;
5771 temp3 = true;
5772 }
5773 }
5774 if (obj3) {
5775 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5776 if (!SWIG_IsOK(res4)) {
5777 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5778 }
5779 arg4 = reinterpret_cast< wxWindow * >(argp4);
5780 }
5781 {
5782 if (!wxPyCheckForApp()) SWIG_fail;
5783 PyThreadState* __tstate = wxPyBeginAllowThreads();
5784 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5785 wxPyEndAllowThreads(__tstate);
5786 if (PyErr_Occurred()) SWIG_fail;
5787 }
5788 {
5789 #if wxUSE_UNICODE
5790 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5791 #else
5792 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5793 #endif
5794 }
5795 {
5796 if (temp1)
5797 delete arg1;
5798 }
5799 {
5800 if (temp2)
5801 delete arg2;
5802 }
5803 {
5804 if (temp3)
5805 delete arg3;
5806 }
5807 return resultobj;
5808 fail:
5809 {
5810 if (temp1)
5811 delete arg1;
5812 }
5813 {
5814 if (temp2)
5815 delete arg2;
5816 }
5817 {
5818 if (temp3)
5819 delete arg3;
5820 }
5821 return NULL;
5822 }
5823
5824
5825 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5826 PyObject *resultobj = 0;
5827 wxString *arg1 = 0 ;
5828 wxString *arg2 = 0 ;
5829 wxString const &arg3_defvalue = wxPyEmptyString ;
5830 wxString *arg3 = (wxString *) &arg3_defvalue ;
5831 wxWindow *arg4 = (wxWindow *) NULL ;
5832 wxString result;
5833 bool temp1 = false ;
5834 bool temp2 = false ;
5835 bool temp3 = false ;
5836 void *argp4 = 0 ;
5837 int res4 = 0 ;
5838 PyObject * obj0 = 0 ;
5839 PyObject * obj1 = 0 ;
5840 PyObject * obj2 = 0 ;
5841 PyObject * obj3 = 0 ;
5842 char * kwnames[] = {
5843 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5844 };
5845
5846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5847 {
5848 arg1 = wxString_in_helper(obj0);
5849 if (arg1 == NULL) SWIG_fail;
5850 temp1 = true;
5851 }
5852 {
5853 arg2 = wxString_in_helper(obj1);
5854 if (arg2 == NULL) SWIG_fail;
5855 temp2 = true;
5856 }
5857 if (obj2) {
5858 {
5859 arg3 = wxString_in_helper(obj2);
5860 if (arg3 == NULL) SWIG_fail;
5861 temp3 = true;
5862 }
5863 }
5864 if (obj3) {
5865 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5866 if (!SWIG_IsOK(res4)) {
5867 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5868 }
5869 arg4 = reinterpret_cast< wxWindow * >(argp4);
5870 }
5871 {
5872 if (!wxPyCheckForApp()) SWIG_fail;
5873 PyThreadState* __tstate = wxPyBeginAllowThreads();
5874 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5875 wxPyEndAllowThreads(__tstate);
5876 if (PyErr_Occurred()) SWIG_fail;
5877 }
5878 {
5879 #if wxUSE_UNICODE
5880 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5881 #else
5882 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5883 #endif
5884 }
5885 {
5886 if (temp1)
5887 delete arg1;
5888 }
5889 {
5890 if (temp2)
5891 delete arg2;
5892 }
5893 {
5894 if (temp3)
5895 delete arg3;
5896 }
5897 return resultobj;
5898 fail:
5899 {
5900 if (temp1)
5901 delete arg1;
5902 }
5903 {
5904 if (temp2)
5905 delete arg2;
5906 }
5907 {
5908 if (temp3)
5909 delete arg3;
5910 }
5911 return NULL;
5912 }
5913
5914
5915 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5916 PyObject *resultobj = 0;
5917 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5918 wxString *arg1 = (wxString *) &arg1_defvalue ;
5919 wxString const &arg2_defvalue = wxPyEmptyString ;
5920 wxString *arg2 = (wxString *) &arg2_defvalue ;
5921 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5922 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5923 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5924 wxWindow *arg5 = (wxWindow *) NULL ;
5925 wxString result;
5926 bool temp1 = false ;
5927 bool temp2 = false ;
5928 long val3 ;
5929 int ecode3 = 0 ;
5930 wxPoint temp4 ;
5931 void *argp5 = 0 ;
5932 int res5 = 0 ;
5933 PyObject * obj0 = 0 ;
5934 PyObject * obj1 = 0 ;
5935 PyObject * obj2 = 0 ;
5936 PyObject * obj3 = 0 ;
5937 PyObject * obj4 = 0 ;
5938 char * kwnames[] = {
5939 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5940 };
5941
5942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5943 if (obj0) {
5944 {
5945 arg1 = wxString_in_helper(obj0);
5946 if (arg1 == NULL) SWIG_fail;
5947 temp1 = true;
5948 }
5949 }
5950 if (obj1) {
5951 {
5952 arg2 = wxString_in_helper(obj1);
5953 if (arg2 == NULL) SWIG_fail;
5954 temp2 = true;
5955 }
5956 }
5957 if (obj2) {
5958 ecode3 = SWIG_AsVal_long(obj2, &val3);
5959 if (!SWIG_IsOK(ecode3)) {
5960 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5961 }
5962 arg3 = static_cast< long >(val3);
5963 }
5964 if (obj3) {
5965 {
5966 arg4 = &temp4;
5967 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5968 }
5969 }
5970 if (obj4) {
5971 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5972 if (!SWIG_IsOK(res5)) {
5973 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5974 }
5975 arg5 = reinterpret_cast< wxWindow * >(argp5);
5976 }
5977 {
5978 if (!wxPyCheckForApp()) SWIG_fail;
5979 PyThreadState* __tstate = wxPyBeginAllowThreads();
5980 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5981 wxPyEndAllowThreads(__tstate);
5982 if (PyErr_Occurred()) SWIG_fail;
5983 }
5984 {
5985 #if wxUSE_UNICODE
5986 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5987 #else
5988 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5989 #endif
5990 }
5991 {
5992 if (temp1)
5993 delete arg1;
5994 }
5995 {
5996 if (temp2)
5997 delete arg2;
5998 }
5999 return resultobj;
6000 fail:
6001 {
6002 if (temp1)
6003 delete arg1;
6004 }
6005 {
6006 if (temp2)
6007 delete arg2;
6008 }
6009 return NULL;
6010 }
6011
6012
6013 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6014 PyObject *resultobj = 0;
6015 wxString *arg1 = 0 ;
6016 wxString const &arg2_defvalue = wxPyEmptyString ;
6017 wxString *arg2 = (wxString *) &arg2_defvalue ;
6018 wxString const &arg3_defvalue = wxPyEmptyString ;
6019 wxString *arg3 = (wxString *) &arg3_defvalue ;
6020 wxWindow *arg4 = (wxWindow *) NULL ;
6021 int arg5 = (int) -1 ;
6022 int arg6 = (int) -1 ;
6023 bool arg7 = (bool) true ;
6024 wxString result;
6025 bool temp1 = false ;
6026 bool temp2 = false ;
6027 bool temp3 = false ;
6028 void *argp4 = 0 ;
6029 int res4 = 0 ;
6030 int val5 ;
6031 int ecode5 = 0 ;
6032 int val6 ;
6033 int ecode6 = 0 ;
6034 bool val7 ;
6035 int ecode7 = 0 ;
6036 PyObject * obj0 = 0 ;
6037 PyObject * obj1 = 0 ;
6038 PyObject * obj2 = 0 ;
6039 PyObject * obj3 = 0 ;
6040 PyObject * obj4 = 0 ;
6041 PyObject * obj5 = 0 ;
6042 PyObject * obj6 = 0 ;
6043 char * kwnames[] = {
6044 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6045 };
6046
6047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6048 {
6049 arg1 = wxString_in_helper(obj0);
6050 if (arg1 == NULL) SWIG_fail;
6051 temp1 = true;
6052 }
6053 if (obj1) {
6054 {
6055 arg2 = wxString_in_helper(obj1);
6056 if (arg2 == NULL) SWIG_fail;
6057 temp2 = true;
6058 }
6059 }
6060 if (obj2) {
6061 {
6062 arg3 = wxString_in_helper(obj2);
6063 if (arg3 == NULL) SWIG_fail;
6064 temp3 = true;
6065 }
6066 }
6067 if (obj3) {
6068 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6069 if (!SWIG_IsOK(res4)) {
6070 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6071 }
6072 arg4 = reinterpret_cast< wxWindow * >(argp4);
6073 }
6074 if (obj4) {
6075 ecode5 = SWIG_AsVal_int(obj4, &val5);
6076 if (!SWIG_IsOK(ecode5)) {
6077 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6078 }
6079 arg5 = static_cast< int >(val5);
6080 }
6081 if (obj5) {
6082 ecode6 = SWIG_AsVal_int(obj5, &val6);
6083 if (!SWIG_IsOK(ecode6)) {
6084 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6085 }
6086 arg6 = static_cast< int >(val6);
6087 }
6088 if (obj6) {
6089 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6090 if (!SWIG_IsOK(ecode7)) {
6091 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6092 }
6093 arg7 = static_cast< bool >(val7);
6094 }
6095 {
6096 if (!wxPyCheckForApp()) SWIG_fail;
6097 PyThreadState* __tstate = wxPyBeginAllowThreads();
6098 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6099 wxPyEndAllowThreads(__tstate);
6100 if (PyErr_Occurred()) SWIG_fail;
6101 }
6102 {
6103 #if wxUSE_UNICODE
6104 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6105 #else
6106 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6107 #endif
6108 }
6109 {
6110 if (temp1)
6111 delete arg1;
6112 }
6113 {
6114 if (temp2)
6115 delete arg2;
6116 }
6117 {
6118 if (temp3)
6119 delete arg3;
6120 }
6121 return resultobj;
6122 fail:
6123 {
6124 if (temp1)
6125 delete arg1;
6126 }
6127 {
6128 if (temp2)
6129 delete arg2;
6130 }
6131 {
6132 if (temp3)
6133 delete arg3;
6134 }
6135 return NULL;
6136 }
6137
6138
6139 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6140 PyObject *resultobj = 0;
6141 wxString *arg1 = 0 ;
6142 wxString const &arg2_defvalue = wxPyEmptyString ;
6143 wxString *arg2 = (wxString *) &arg2_defvalue ;
6144 wxString const &arg3_defvalue = wxPyEmptyString ;
6145 wxString *arg3 = (wxString *) &arg3_defvalue ;
6146 wxWindow *arg4 = (wxWindow *) NULL ;
6147 wxString result;
6148 bool temp1 = false ;
6149 bool temp2 = false ;
6150 bool temp3 = false ;
6151 void *argp4 = 0 ;
6152 int res4 = 0 ;
6153 PyObject * obj0 = 0 ;
6154 PyObject * obj1 = 0 ;
6155 PyObject * obj2 = 0 ;
6156 PyObject * obj3 = 0 ;
6157 char * kwnames[] = {
6158 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6159 };
6160
6161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6162 {
6163 arg1 = wxString_in_helper(obj0);
6164 if (arg1 == NULL) SWIG_fail;
6165 temp1 = true;
6166 }
6167 if (obj1) {
6168 {
6169 arg2 = wxString_in_helper(obj1);
6170 if (arg2 == NULL) SWIG_fail;
6171 temp2 = true;
6172 }
6173 }
6174 if (obj2) {
6175 {
6176 arg3 = wxString_in_helper(obj2);
6177 if (arg3 == NULL) SWIG_fail;
6178 temp3 = true;
6179 }
6180 }
6181 if (obj3) {
6182 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6183 if (!SWIG_IsOK(res4)) {
6184 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6185 }
6186 arg4 = reinterpret_cast< wxWindow * >(argp4);
6187 }
6188 {
6189 if (!wxPyCheckForApp()) SWIG_fail;
6190 PyThreadState* __tstate = wxPyBeginAllowThreads();
6191 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6192 wxPyEndAllowThreads(__tstate);
6193 if (PyErr_Occurred()) SWIG_fail;
6194 }
6195 {
6196 #if wxUSE_UNICODE
6197 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6198 #else
6199 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6200 #endif
6201 }
6202 {
6203 if (temp1)
6204 delete arg1;
6205 }
6206 {
6207 if (temp2)
6208 delete arg2;
6209 }
6210 {
6211 if (temp3)
6212 delete arg3;
6213 }
6214 return resultobj;
6215 fail:
6216 {
6217 if (temp1)
6218 delete arg1;
6219 }
6220 {
6221 if (temp2)
6222 delete arg2;
6223 }
6224 {
6225 if (temp3)
6226 delete arg3;
6227 }
6228 return NULL;
6229 }
6230
6231
6232 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6233 PyObject *resultobj = 0;
6234 wxString *arg1 = 0 ;
6235 wxString *arg2 = 0 ;
6236 int arg3 ;
6237 wxString *arg4 = (wxString *) 0 ;
6238 wxWindow *arg5 = (wxWindow *) NULL ;
6239 int arg6 = (int) -1 ;
6240 int arg7 = (int) -1 ;
6241 bool arg8 = (bool) true ;
6242 int arg9 = (int) 150 ;
6243 int arg10 = (int) 200 ;
6244 wxString result;
6245 bool temp1 = false ;
6246 bool temp2 = false ;
6247 void *argp5 = 0 ;
6248 int res5 = 0 ;
6249 int val6 ;
6250 int ecode6 = 0 ;
6251 int val7 ;
6252 int ecode7 = 0 ;
6253 bool val8 ;
6254 int ecode8 = 0 ;
6255 int val9 ;
6256 int ecode9 = 0 ;
6257 int val10 ;
6258 int ecode10 = 0 ;
6259 PyObject * obj0 = 0 ;
6260 PyObject * obj1 = 0 ;
6261 PyObject * obj2 = 0 ;
6262 PyObject * obj3 = 0 ;
6263 PyObject * obj4 = 0 ;
6264 PyObject * obj5 = 0 ;
6265 PyObject * obj6 = 0 ;
6266 PyObject * obj7 = 0 ;
6267 PyObject * obj8 = 0 ;
6268 char * kwnames[] = {
6269 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6270 };
6271
6272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6273 {
6274 arg1 = wxString_in_helper(obj0);
6275 if (arg1 == NULL) SWIG_fail;
6276 temp1 = true;
6277 }
6278 {
6279 arg2 = wxString_in_helper(obj1);
6280 if (arg2 == NULL) SWIG_fail;
6281 temp2 = true;
6282 }
6283 {
6284 arg3 = PyList_Size(obj2);
6285 arg4 = wxString_LIST_helper(obj2);
6286 if (arg4 == NULL) SWIG_fail;
6287 }
6288 if (obj3) {
6289 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6290 if (!SWIG_IsOK(res5)) {
6291 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6292 }
6293 arg5 = reinterpret_cast< wxWindow * >(argp5);
6294 }
6295 if (obj4) {
6296 ecode6 = SWIG_AsVal_int(obj4, &val6);
6297 if (!SWIG_IsOK(ecode6)) {
6298 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6299 }
6300 arg6 = static_cast< int >(val6);
6301 }
6302 if (obj5) {
6303 ecode7 = SWIG_AsVal_int(obj5, &val7);
6304 if (!SWIG_IsOK(ecode7)) {
6305 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6306 }
6307 arg7 = static_cast< int >(val7);
6308 }
6309 if (obj6) {
6310 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6311 if (!SWIG_IsOK(ecode8)) {
6312 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6313 }
6314 arg8 = static_cast< bool >(val8);
6315 }
6316 if (obj7) {
6317 ecode9 = SWIG_AsVal_int(obj7, &val9);
6318 if (!SWIG_IsOK(ecode9)) {
6319 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6320 }
6321 arg9 = static_cast< int >(val9);
6322 }
6323 if (obj8) {
6324 ecode10 = SWIG_AsVal_int(obj8, &val10);
6325 if (!SWIG_IsOK(ecode10)) {
6326 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6327 }
6328 arg10 = static_cast< int >(val10);
6329 }
6330 {
6331 if (!wxPyCheckForApp()) SWIG_fail;
6332 PyThreadState* __tstate = wxPyBeginAllowThreads();
6333 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6334 wxPyEndAllowThreads(__tstate);
6335 if (PyErr_Occurred()) SWIG_fail;
6336 }
6337 {
6338 #if wxUSE_UNICODE
6339 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6340 #else
6341 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6342 #endif
6343 }
6344 {
6345 if (temp1)
6346 delete arg1;
6347 }
6348 {
6349 if (temp2)
6350 delete arg2;
6351 }
6352 {
6353 if (arg4) delete [] arg4;
6354 }
6355 return resultobj;
6356 fail:
6357 {
6358 if (temp1)
6359 delete arg1;
6360 }
6361 {
6362 if (temp2)
6363 delete arg2;
6364 }
6365 {
6366 if (arg4) delete [] arg4;
6367 }
6368 return NULL;
6369 }
6370
6371
6372 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6373 PyObject *resultobj = 0;
6374 wxString *arg1 = 0 ;
6375 wxString *arg2 = 0 ;
6376 int arg3 ;
6377 wxString *arg4 = (wxString *) 0 ;
6378 wxWindow *arg5 = (wxWindow *) NULL ;
6379 int arg6 = (int) -1 ;
6380 int arg7 = (int) -1 ;
6381 bool arg8 = (bool) true ;
6382 int arg9 = (int) 150 ;
6383 int arg10 = (int) 200 ;
6384 int result;
6385 bool temp1 = false ;
6386 bool temp2 = false ;
6387 void *argp5 = 0 ;
6388 int res5 = 0 ;
6389 int val6 ;
6390 int ecode6 = 0 ;
6391 int val7 ;
6392 int ecode7 = 0 ;
6393 bool val8 ;
6394 int ecode8 = 0 ;
6395 int val9 ;
6396 int ecode9 = 0 ;
6397 int val10 ;
6398 int ecode10 = 0 ;
6399 PyObject * obj0 = 0 ;
6400 PyObject * obj1 = 0 ;
6401 PyObject * obj2 = 0 ;
6402 PyObject * obj3 = 0 ;
6403 PyObject * obj4 = 0 ;
6404 PyObject * obj5 = 0 ;
6405 PyObject * obj6 = 0 ;
6406 PyObject * obj7 = 0 ;
6407 PyObject * obj8 = 0 ;
6408 char * kwnames[] = {
6409 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6410 };
6411
6412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6413 {
6414 arg1 = wxString_in_helper(obj0);
6415 if (arg1 == NULL) SWIG_fail;
6416 temp1 = true;
6417 }
6418 {
6419 arg2 = wxString_in_helper(obj1);
6420 if (arg2 == NULL) SWIG_fail;
6421 temp2 = true;
6422 }
6423 {
6424 arg3 = PyList_Size(obj2);
6425 arg4 = wxString_LIST_helper(obj2);
6426 if (arg4 == NULL) SWIG_fail;
6427 }
6428 if (obj3) {
6429 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6430 if (!SWIG_IsOK(res5)) {
6431 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6432 }
6433 arg5 = reinterpret_cast< wxWindow * >(argp5);
6434 }
6435 if (obj4) {
6436 ecode6 = SWIG_AsVal_int(obj4, &val6);
6437 if (!SWIG_IsOK(ecode6)) {
6438 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6439 }
6440 arg6 = static_cast< int >(val6);
6441 }
6442 if (obj5) {
6443 ecode7 = SWIG_AsVal_int(obj5, &val7);
6444 if (!SWIG_IsOK(ecode7)) {
6445 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6446 }
6447 arg7 = static_cast< int >(val7);
6448 }
6449 if (obj6) {
6450 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6451 if (!SWIG_IsOK(ecode8)) {
6452 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6453 }
6454 arg8 = static_cast< bool >(val8);
6455 }
6456 if (obj7) {
6457 ecode9 = SWIG_AsVal_int(obj7, &val9);
6458 if (!SWIG_IsOK(ecode9)) {
6459 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6460 }
6461 arg9 = static_cast< int >(val9);
6462 }
6463 if (obj8) {
6464 ecode10 = SWIG_AsVal_int(obj8, &val10);
6465 if (!SWIG_IsOK(ecode10)) {
6466 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6467 }
6468 arg10 = static_cast< int >(val10);
6469 }
6470 {
6471 if (!wxPyCheckForApp()) SWIG_fail;
6472 PyThreadState* __tstate = wxPyBeginAllowThreads();
6473 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6474 wxPyEndAllowThreads(__tstate);
6475 if (PyErr_Occurred()) SWIG_fail;
6476 }
6477 resultobj = SWIG_From_int(static_cast< int >(result));
6478 {
6479 if (temp1)
6480 delete arg1;
6481 }
6482 {
6483 if (temp2)
6484 delete arg2;
6485 }
6486 {
6487 if (arg4) delete [] arg4;
6488 }
6489 return resultobj;
6490 fail:
6491 {
6492 if (temp1)
6493 delete arg1;
6494 }
6495 {
6496 if (temp2)
6497 delete arg2;
6498 }
6499 {
6500 if (arg4) delete [] arg4;
6501 }
6502 return NULL;
6503 }
6504
6505
6506 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6507 PyObject *resultobj = 0;
6508 wxString *arg1 = 0 ;
6509 wxString const &arg2_defvalue = wxPyEmptyString ;
6510 wxString *arg2 = (wxString *) &arg2_defvalue ;
6511 int arg3 = (int) wxOK|wxCENTRE ;
6512 wxWindow *arg4 = (wxWindow *) NULL ;
6513 int arg5 = (int) -1 ;
6514 int arg6 = (int) -1 ;
6515 int result;
6516 bool temp1 = false ;
6517 bool temp2 = false ;
6518 int val3 ;
6519 int ecode3 = 0 ;
6520 void *argp4 = 0 ;
6521 int res4 = 0 ;
6522 int val5 ;
6523 int ecode5 = 0 ;
6524 int val6 ;
6525 int ecode6 = 0 ;
6526 PyObject * obj0 = 0 ;
6527 PyObject * obj1 = 0 ;
6528 PyObject * obj2 = 0 ;
6529 PyObject * obj3 = 0 ;
6530 PyObject * obj4 = 0 ;
6531 PyObject * obj5 = 0 ;
6532 char * kwnames[] = {
6533 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6534 };
6535
6536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6537 {
6538 arg1 = wxString_in_helper(obj0);
6539 if (arg1 == NULL) SWIG_fail;
6540 temp1 = true;
6541 }
6542 if (obj1) {
6543 {
6544 arg2 = wxString_in_helper(obj1);
6545 if (arg2 == NULL) SWIG_fail;
6546 temp2 = true;
6547 }
6548 }
6549 if (obj2) {
6550 ecode3 = SWIG_AsVal_int(obj2, &val3);
6551 if (!SWIG_IsOK(ecode3)) {
6552 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6553 }
6554 arg3 = static_cast< int >(val3);
6555 }
6556 if (obj3) {
6557 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6558 if (!SWIG_IsOK(res4)) {
6559 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6560 }
6561 arg4 = reinterpret_cast< wxWindow * >(argp4);
6562 }
6563 if (obj4) {
6564 ecode5 = SWIG_AsVal_int(obj4, &val5);
6565 if (!SWIG_IsOK(ecode5)) {
6566 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6567 }
6568 arg5 = static_cast< int >(val5);
6569 }
6570 if (obj5) {
6571 ecode6 = SWIG_AsVal_int(obj5, &val6);
6572 if (!SWIG_IsOK(ecode6)) {
6573 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6574 }
6575 arg6 = static_cast< int >(val6);
6576 }
6577 {
6578 if (!wxPyCheckForApp()) SWIG_fail;
6579 PyThreadState* __tstate = wxPyBeginAllowThreads();
6580 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6581 wxPyEndAllowThreads(__tstate);
6582 if (PyErr_Occurred()) SWIG_fail;
6583 }
6584 resultobj = SWIG_From_int(static_cast< int >(result));
6585 {
6586 if (temp1)
6587 delete arg1;
6588 }
6589 {
6590 if (temp2)
6591 delete arg2;
6592 }
6593 return resultobj;
6594 fail:
6595 {
6596 if (temp1)
6597 delete arg1;
6598 }
6599 {
6600 if (temp2)
6601 delete arg2;
6602 }
6603 return NULL;
6604 }
6605
6606
6607 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6608 PyObject *resultobj = 0;
6609 wxString *arg1 = 0 ;
6610 wxString *arg2 = 0 ;
6611 wxString *arg3 = 0 ;
6612 long arg4 ;
6613 long arg5 = (long) 0 ;
6614 long arg6 = (long) 100 ;
6615 wxWindow *arg7 = (wxWindow *) NULL ;
6616 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6617 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6618 long result;
6619 bool temp1 = false ;
6620 bool temp2 = false ;
6621 bool temp3 = false ;
6622 long val4 ;
6623 int ecode4 = 0 ;
6624 long val5 ;
6625 int ecode5 = 0 ;
6626 long val6 ;
6627 int ecode6 = 0 ;
6628 void *argp7 = 0 ;
6629 int res7 = 0 ;
6630 wxPoint temp8 ;
6631 PyObject * obj0 = 0 ;
6632 PyObject * obj1 = 0 ;
6633 PyObject * obj2 = 0 ;
6634 PyObject * obj3 = 0 ;
6635 PyObject * obj4 = 0 ;
6636 PyObject * obj5 = 0 ;
6637 PyObject * obj6 = 0 ;
6638 PyObject * obj7 = 0 ;
6639 char * kwnames[] = {
6640 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6641 };
6642
6643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6644 {
6645 arg1 = wxString_in_helper(obj0);
6646 if (arg1 == NULL) SWIG_fail;
6647 temp1 = true;
6648 }
6649 {
6650 arg2 = wxString_in_helper(obj1);
6651 if (arg2 == NULL) SWIG_fail;
6652 temp2 = true;
6653 }
6654 {
6655 arg3 = wxString_in_helper(obj2);
6656 if (arg3 == NULL) SWIG_fail;
6657 temp3 = true;
6658 }
6659 ecode4 = SWIG_AsVal_long(obj3, &val4);
6660 if (!SWIG_IsOK(ecode4)) {
6661 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6662 }
6663 arg4 = static_cast< long >(val4);
6664 if (obj4) {
6665 ecode5 = SWIG_AsVal_long(obj4, &val5);
6666 if (!SWIG_IsOK(ecode5)) {
6667 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6668 }
6669 arg5 = static_cast< long >(val5);
6670 }
6671 if (obj5) {
6672 ecode6 = SWIG_AsVal_long(obj5, &val6);
6673 if (!SWIG_IsOK(ecode6)) {
6674 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6675 }
6676 arg6 = static_cast< long >(val6);
6677 }
6678 if (obj6) {
6679 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6680 if (!SWIG_IsOK(res7)) {
6681 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6682 }
6683 arg7 = reinterpret_cast< wxWindow * >(argp7);
6684 }
6685 if (obj7) {
6686 {
6687 arg8 = &temp8;
6688 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6689 }
6690 }
6691 {
6692 if (!wxPyCheckForApp()) SWIG_fail;
6693 PyThreadState* __tstate = wxPyBeginAllowThreads();
6694 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6695 wxPyEndAllowThreads(__tstate);
6696 if (PyErr_Occurred()) SWIG_fail;
6697 }
6698 resultobj = SWIG_From_long(static_cast< long >(result));
6699 {
6700 if (temp1)
6701 delete arg1;
6702 }
6703 {
6704 if (temp2)
6705 delete arg2;
6706 }
6707 {
6708 if (temp3)
6709 delete arg3;
6710 }
6711 return resultobj;
6712 fail:
6713 {
6714 if (temp1)
6715 delete arg1;
6716 }
6717 {
6718 if (temp2)
6719 delete arg2;
6720 }
6721 {
6722 if (temp3)
6723 delete arg3;
6724 }
6725 return NULL;
6726 }
6727
6728
6729 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6730 PyObject *resultobj = 0;
6731 bool result;
6732
6733 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6734 {
6735 if (!wxPyCheckForApp()) SWIG_fail;
6736 PyThreadState* __tstate = wxPyBeginAllowThreads();
6737 result = (bool)wxColourDisplay();
6738 wxPyEndAllowThreads(__tstate);
6739 if (PyErr_Occurred()) SWIG_fail;
6740 }
6741 {
6742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6743 }
6744 return resultobj;
6745 fail:
6746 return NULL;
6747 }
6748
6749
6750 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6751 PyObject *resultobj = 0;
6752 int result;
6753
6754 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6755 {
6756 if (!wxPyCheckForApp()) SWIG_fail;
6757 PyThreadState* __tstate = wxPyBeginAllowThreads();
6758 result = (int)wxDisplayDepth();
6759 wxPyEndAllowThreads(__tstate);
6760 if (PyErr_Occurred()) SWIG_fail;
6761 }
6762 resultobj = SWIG_From_int(static_cast< int >(result));
6763 return resultobj;
6764 fail:
6765 return NULL;
6766 }
6767
6768
6769 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6770 PyObject *resultobj = 0;
6771 int result;
6772
6773 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6774 {
6775 if (!wxPyCheckForApp()) SWIG_fail;
6776 PyThreadState* __tstate = wxPyBeginAllowThreads();
6777 result = (int)wxGetDisplayDepth();
6778 wxPyEndAllowThreads(__tstate);
6779 if (PyErr_Occurred()) SWIG_fail;
6780 }
6781 resultobj = SWIG_From_int(static_cast< int >(result));
6782 return resultobj;
6783 fail:
6784 return NULL;
6785 }
6786
6787
6788 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6789 PyObject *resultobj = 0;
6790 int *arg1 = (int *) 0 ;
6791 int *arg2 = (int *) 0 ;
6792 int temp1 ;
6793 int res1 = SWIG_TMPOBJ ;
6794 int temp2 ;
6795 int res2 = SWIG_TMPOBJ ;
6796
6797 arg1 = &temp1;
6798 arg2 = &temp2;
6799 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6800 {
6801 if (!wxPyCheckForApp()) SWIG_fail;
6802 PyThreadState* __tstate = wxPyBeginAllowThreads();
6803 wxDisplaySize(arg1,arg2);
6804 wxPyEndAllowThreads(__tstate);
6805 if (PyErr_Occurred()) SWIG_fail;
6806 }
6807 resultobj = SWIG_Py_Void();
6808 if (SWIG_IsTmpObj(res1)) {
6809 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6810 } else {
6811 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6812 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6813 }
6814 if (SWIG_IsTmpObj(res2)) {
6815 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6816 } else {
6817 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6818 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6819 }
6820 return resultobj;
6821 fail:
6822 return NULL;
6823 }
6824
6825
6826 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6827 PyObject *resultobj = 0;
6828 wxSize result;
6829
6830 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6831 {
6832 if (!wxPyCheckForApp()) SWIG_fail;
6833 PyThreadState* __tstate = wxPyBeginAllowThreads();
6834 result = wxGetDisplaySize();
6835 wxPyEndAllowThreads(__tstate);
6836 if (PyErr_Occurred()) SWIG_fail;
6837 }
6838 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6839 return resultobj;
6840 fail:
6841 return NULL;
6842 }
6843
6844
6845 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6846 PyObject *resultobj = 0;
6847 int *arg1 = (int *) 0 ;
6848 int *arg2 = (int *) 0 ;
6849 int temp1 ;
6850 int res1 = SWIG_TMPOBJ ;
6851 int temp2 ;
6852 int res2 = SWIG_TMPOBJ ;
6853
6854 arg1 = &temp1;
6855 arg2 = &temp2;
6856 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6857 {
6858 if (!wxPyCheckForApp()) SWIG_fail;
6859 PyThreadState* __tstate = wxPyBeginAllowThreads();
6860 wxDisplaySizeMM(arg1,arg2);
6861 wxPyEndAllowThreads(__tstate);
6862 if (PyErr_Occurred()) SWIG_fail;
6863 }
6864 resultobj = SWIG_Py_Void();
6865 if (SWIG_IsTmpObj(res1)) {
6866 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6867 } else {
6868 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6869 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6870 }
6871 if (SWIG_IsTmpObj(res2)) {
6872 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6873 } else {
6874 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6875 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6876 }
6877 return resultobj;
6878 fail:
6879 return NULL;
6880 }
6881
6882
6883 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6884 PyObject *resultobj = 0;
6885 wxSize result;
6886
6887 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6888 {
6889 if (!wxPyCheckForApp()) SWIG_fail;
6890 PyThreadState* __tstate = wxPyBeginAllowThreads();
6891 result = wxGetDisplaySizeMM();
6892 wxPyEndAllowThreads(__tstate);
6893 if (PyErr_Occurred()) SWIG_fail;
6894 }
6895 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6896 return resultobj;
6897 fail:
6898 return NULL;
6899 }
6900
6901
6902 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6903 PyObject *resultobj = 0;
6904 int *arg1 = (int *) 0 ;
6905 int *arg2 = (int *) 0 ;
6906 int *arg3 = (int *) 0 ;
6907 int *arg4 = (int *) 0 ;
6908 int temp1 ;
6909 int res1 = SWIG_TMPOBJ ;
6910 int temp2 ;
6911 int res2 = SWIG_TMPOBJ ;
6912 int temp3 ;
6913 int res3 = SWIG_TMPOBJ ;
6914 int temp4 ;
6915 int res4 = SWIG_TMPOBJ ;
6916
6917 arg1 = &temp1;
6918 arg2 = &temp2;
6919 arg3 = &temp3;
6920 arg4 = &temp4;
6921 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6922 {
6923 if (!wxPyCheckForApp()) SWIG_fail;
6924 PyThreadState* __tstate = wxPyBeginAllowThreads();
6925 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6926 wxPyEndAllowThreads(__tstate);
6927 if (PyErr_Occurred()) SWIG_fail;
6928 }
6929 resultobj = SWIG_Py_Void();
6930 if (SWIG_IsTmpObj(res1)) {
6931 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6932 } else {
6933 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6934 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6935 }
6936 if (SWIG_IsTmpObj(res2)) {
6937 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6938 } else {
6939 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6940 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6941 }
6942 if (SWIG_IsTmpObj(res3)) {
6943 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6944 } else {
6945 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6946 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6947 }
6948 if (SWIG_IsTmpObj(res4)) {
6949 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6950 } else {
6951 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6952 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6953 }
6954 return resultobj;
6955 fail:
6956 return NULL;
6957 }
6958
6959
6960 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6961 PyObject *resultobj = 0;
6962 wxRect result;
6963
6964 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6965 {
6966 if (!wxPyCheckForApp()) SWIG_fail;
6967 PyThreadState* __tstate = wxPyBeginAllowThreads();
6968 result = wxGetClientDisplayRect();
6969 wxPyEndAllowThreads(__tstate);
6970 if (PyErr_Occurred()) SWIG_fail;
6971 }
6972 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6973 return resultobj;
6974 fail:
6975 return NULL;
6976 }
6977
6978
6979 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6980 PyObject *resultobj = 0;
6981 wxCursor *arg1 = 0 ;
6982 void *argp1 = 0 ;
6983 int res1 = 0 ;
6984 PyObject * obj0 = 0 ;
6985 char * kwnames[] = {
6986 (char *) "cursor", NULL
6987 };
6988
6989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6990 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6991 if (!SWIG_IsOK(res1)) {
6992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6993 }
6994 if (!argp1) {
6995 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6996 }
6997 arg1 = reinterpret_cast< wxCursor * >(argp1);
6998 {
6999 if (!wxPyCheckForApp()) SWIG_fail;
7000 PyThreadState* __tstate = wxPyBeginAllowThreads();
7001 wxSetCursor(*arg1);
7002 wxPyEndAllowThreads(__tstate);
7003 if (PyErr_Occurred()) SWIG_fail;
7004 }
7005 resultobj = SWIG_Py_Void();
7006 return resultobj;
7007 fail:
7008 return NULL;
7009 }
7010
7011
7012 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7013 PyObject *resultobj = 0;
7014 void *result = 0 ;
7015
7016 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7017 {
7018 if (!wxPyCheckForApp()) SWIG_fail;
7019 PyThreadState* __tstate = wxPyBeginAllowThreads();
7020 result = (void *)wxGetXDisplay();
7021 wxPyEndAllowThreads(__tstate);
7022 if (PyErr_Occurred()) SWIG_fail;
7023 }
7024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7025 return resultobj;
7026 fail:
7027 return NULL;
7028 }
7029
7030
7031 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7032 PyObject *resultobj = 0;
7033 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7034 void *argp1 = 0 ;
7035 int res1 = 0 ;
7036 PyObject * obj0 = 0 ;
7037 char * kwnames[] = {
7038 (char *) "cursor", NULL
7039 };
7040
7041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7042 if (obj0) {
7043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7044 if (!SWIG_IsOK(res1)) {
7045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7046 }
7047 arg1 = reinterpret_cast< wxCursor * >(argp1);
7048 }
7049 {
7050 if (!wxPyCheckForApp()) SWIG_fail;
7051 PyThreadState* __tstate = wxPyBeginAllowThreads();
7052 wxBeginBusyCursor(arg1);
7053 wxPyEndAllowThreads(__tstate);
7054 if (PyErr_Occurred()) SWIG_fail;
7055 }
7056 resultobj = SWIG_Py_Void();
7057 return resultobj;
7058 fail:
7059 return NULL;
7060 }
7061
7062
7063 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7064 PyObject *resultobj = 0;
7065 wxPoint result;
7066
7067 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7068 {
7069 if (!wxPyCheckForApp()) SWIG_fail;
7070 PyThreadState* __tstate = wxPyBeginAllowThreads();
7071 result = wxGetMousePosition();
7072 wxPyEndAllowThreads(__tstate);
7073 if (PyErr_Occurred()) SWIG_fail;
7074 }
7075 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7076 return resultobj;
7077 fail:
7078 return NULL;
7079 }
7080
7081
7082 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7083 PyObject *resultobj = 0;
7084 wxWindow *result = 0 ;
7085
7086 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7087 {
7088 if (!wxPyCheckForApp()) SWIG_fail;
7089 PyThreadState* __tstate = wxPyBeginAllowThreads();
7090 result = (wxWindow *)FindWindowAtPointer();
7091 wxPyEndAllowThreads(__tstate);
7092 if (PyErr_Occurred()) SWIG_fail;
7093 }
7094 {
7095 resultobj = wxPyMake_wxObject(result, 0);
7096 }
7097 return resultobj;
7098 fail:
7099 return NULL;
7100 }
7101
7102
7103 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7104 PyObject *resultobj = 0;
7105 wxWindow *result = 0 ;
7106
7107 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7108 {
7109 if (!wxPyCheckForApp()) SWIG_fail;
7110 PyThreadState* __tstate = wxPyBeginAllowThreads();
7111 result = (wxWindow *)wxGetActiveWindow();
7112 wxPyEndAllowThreads(__tstate);
7113 if (PyErr_Occurred()) SWIG_fail;
7114 }
7115 {
7116 resultobj = wxPyMake_wxObject(result, 0);
7117 }
7118 return resultobj;
7119 fail:
7120 return NULL;
7121 }
7122
7123
7124 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7125 PyObject *resultobj = 0;
7126 wxPoint *arg1 = 0 ;
7127 wxWindow *result = 0 ;
7128 wxPoint temp1 ;
7129 PyObject * obj0 = 0 ;
7130 char * kwnames[] = {
7131 (char *) "pt", NULL
7132 };
7133
7134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7135 {
7136 arg1 = &temp1;
7137 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7138 }
7139 {
7140 if (!wxPyCheckForApp()) SWIG_fail;
7141 PyThreadState* __tstate = wxPyBeginAllowThreads();
7142 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7143 wxPyEndAllowThreads(__tstate);
7144 if (PyErr_Occurred()) SWIG_fail;
7145 }
7146 {
7147 resultobj = wxPyMake_wxObject(result, 0);
7148 }
7149 return resultobj;
7150 fail:
7151 return NULL;
7152 }
7153
7154
7155 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7156 PyObject *resultobj = 0;
7157 wxPoint *arg1 = 0 ;
7158 wxWindow *result = 0 ;
7159 wxPoint temp1 ;
7160 PyObject * obj0 = 0 ;
7161 char * kwnames[] = {
7162 (char *) "pt", NULL
7163 };
7164
7165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7166 {
7167 arg1 = &temp1;
7168 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7169 }
7170 {
7171 if (!wxPyCheckForApp()) SWIG_fail;
7172 PyThreadState* __tstate = wxPyBeginAllowThreads();
7173 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7174 wxPyEndAllowThreads(__tstate);
7175 if (PyErr_Occurred()) SWIG_fail;
7176 }
7177 {
7178 resultobj = wxPyMake_wxObject(result, 0);
7179 }
7180 return resultobj;
7181 fail:
7182 return NULL;
7183 }
7184
7185
7186 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7187 PyObject *resultobj = 0;
7188 wxWindow *arg1 = (wxWindow *) 0 ;
7189 wxWindow *result = 0 ;
7190 void *argp1 = 0 ;
7191 int res1 = 0 ;
7192 PyObject * obj0 = 0 ;
7193 char * kwnames[] = {
7194 (char *) "win", NULL
7195 };
7196
7197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7199 if (!SWIG_IsOK(res1)) {
7200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7201 }
7202 arg1 = reinterpret_cast< wxWindow * >(argp1);
7203 {
7204 if (!wxPyCheckForApp()) SWIG_fail;
7205 PyThreadState* __tstate = wxPyBeginAllowThreads();
7206 result = (wxWindow *)wxGetTopLevelParent(arg1);
7207 wxPyEndAllowThreads(__tstate);
7208 if (PyErr_Occurred()) SWIG_fail;
7209 }
7210 {
7211 resultobj = wxPyMake_wxObject(result, 0);
7212 }
7213 return resultobj;
7214 fail:
7215 return NULL;
7216 }
7217
7218
7219 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7220 PyObject *resultobj = 0;
7221 wxString *arg1 = 0 ;
7222 bool result;
7223 bool temp1 = false ;
7224 PyObject * obj0 = 0 ;
7225 char * kwnames[] = {
7226 (char *) "url", NULL
7227 };
7228
7229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7230 {
7231 arg1 = wxString_in_helper(obj0);
7232 if (arg1 == NULL) SWIG_fail;
7233 temp1 = true;
7234 }
7235 {
7236 PyThreadState* __tstate = wxPyBeginAllowThreads();
7237 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7238 wxPyEndAllowThreads(__tstate);
7239 if (PyErr_Occurred()) SWIG_fail;
7240 }
7241 {
7242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7243 }
7244 {
7245 if (temp1)
7246 delete arg1;
7247 }
7248 return resultobj;
7249 fail:
7250 {
7251 if (temp1)
7252 delete arg1;
7253 }
7254 return NULL;
7255 }
7256
7257
7258 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7259 PyObject *resultobj = 0;
7260 wxKeyCode arg1 ;
7261 bool result;
7262 int val1 ;
7263 int ecode1 = 0 ;
7264 PyObject * obj0 = 0 ;
7265 char * kwnames[] = {
7266 (char *) "key", NULL
7267 };
7268
7269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7270 ecode1 = SWIG_AsVal_int(obj0, &val1);
7271 if (!SWIG_IsOK(ecode1)) {
7272 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7273 }
7274 arg1 = static_cast< wxKeyCode >(val1);
7275 {
7276 if (!wxPyCheckForApp()) SWIG_fail;
7277 PyThreadState* __tstate = wxPyBeginAllowThreads();
7278 result = (bool)wxGetKeyState(arg1);
7279 wxPyEndAllowThreads(__tstate);
7280 if (PyErr_Occurred()) SWIG_fail;
7281 }
7282 {
7283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7284 }
7285 return resultobj;
7286 fail:
7287 return NULL;
7288 }
7289
7290
7291 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7292 PyObject *resultobj = 0;
7293 wxMouseState *result = 0 ;
7294
7295 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7296 {
7297 PyThreadState* __tstate = wxPyBeginAllowThreads();
7298 result = (wxMouseState *)new wxMouseState();
7299 wxPyEndAllowThreads(__tstate);
7300 if (PyErr_Occurred()) SWIG_fail;
7301 }
7302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7303 return resultobj;
7304 fail:
7305 return NULL;
7306 }
7307
7308
7309 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7310 PyObject *resultobj = 0;
7311 wxMouseState *arg1 = (wxMouseState *) 0 ;
7312 void *argp1 = 0 ;
7313 int res1 = 0 ;
7314 PyObject *swig_obj[1] ;
7315
7316 if (!args) SWIG_fail;
7317 swig_obj[0] = args;
7318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7319 if (!SWIG_IsOK(res1)) {
7320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7321 }
7322 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7323 {
7324 PyThreadState* __tstate = wxPyBeginAllowThreads();
7325 delete arg1;
7326
7327 wxPyEndAllowThreads(__tstate);
7328 if (PyErr_Occurred()) SWIG_fail;
7329 }
7330 resultobj = SWIG_Py_Void();
7331 return resultobj;
7332 fail:
7333 return NULL;
7334 }
7335
7336
7337 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7338 PyObject *resultobj = 0;
7339 wxMouseState *arg1 = (wxMouseState *) 0 ;
7340 int result;
7341 void *argp1 = 0 ;
7342 int res1 = 0 ;
7343 PyObject *swig_obj[1] ;
7344
7345 if (!args) SWIG_fail;
7346 swig_obj[0] = args;
7347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7348 if (!SWIG_IsOK(res1)) {
7349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7350 }
7351 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7352 {
7353 PyThreadState* __tstate = wxPyBeginAllowThreads();
7354 result = (int)(arg1)->GetX();
7355 wxPyEndAllowThreads(__tstate);
7356 if (PyErr_Occurred()) SWIG_fail;
7357 }
7358 resultobj = SWIG_From_int(static_cast< int >(result));
7359 return resultobj;
7360 fail:
7361 return NULL;
7362 }
7363
7364
7365 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7366 PyObject *resultobj = 0;
7367 wxMouseState *arg1 = (wxMouseState *) 0 ;
7368 int result;
7369 void *argp1 = 0 ;
7370 int res1 = 0 ;
7371 PyObject *swig_obj[1] ;
7372
7373 if (!args) SWIG_fail;
7374 swig_obj[0] = args;
7375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7376 if (!SWIG_IsOK(res1)) {
7377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7378 }
7379 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7380 {
7381 PyThreadState* __tstate = wxPyBeginAllowThreads();
7382 result = (int)(arg1)->GetY();
7383 wxPyEndAllowThreads(__tstate);
7384 if (PyErr_Occurred()) SWIG_fail;
7385 }
7386 resultobj = SWIG_From_int(static_cast< int >(result));
7387 return resultobj;
7388 fail:
7389 return NULL;
7390 }
7391
7392
7393 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7394 PyObject *resultobj = 0;
7395 wxMouseState *arg1 = (wxMouseState *) 0 ;
7396 bool result;
7397 void *argp1 = 0 ;
7398 int res1 = 0 ;
7399 PyObject *swig_obj[1] ;
7400
7401 if (!args) SWIG_fail;
7402 swig_obj[0] = args;
7403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7404 if (!SWIG_IsOK(res1)) {
7405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7406 }
7407 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7408 {
7409 PyThreadState* __tstate = wxPyBeginAllowThreads();
7410 result = (bool)(arg1)->LeftDown();
7411 wxPyEndAllowThreads(__tstate);
7412 if (PyErr_Occurred()) SWIG_fail;
7413 }
7414 {
7415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7416 }
7417 return resultobj;
7418 fail:
7419 return NULL;
7420 }
7421
7422
7423 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7424 PyObject *resultobj = 0;
7425 wxMouseState *arg1 = (wxMouseState *) 0 ;
7426 bool result;
7427 void *argp1 = 0 ;
7428 int res1 = 0 ;
7429 PyObject *swig_obj[1] ;
7430
7431 if (!args) SWIG_fail;
7432 swig_obj[0] = args;
7433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7434 if (!SWIG_IsOK(res1)) {
7435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7436 }
7437 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7438 {
7439 PyThreadState* __tstate = wxPyBeginAllowThreads();
7440 result = (bool)(arg1)->MiddleDown();
7441 wxPyEndAllowThreads(__tstate);
7442 if (PyErr_Occurred()) SWIG_fail;
7443 }
7444 {
7445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7446 }
7447 return resultobj;
7448 fail:
7449 return NULL;
7450 }
7451
7452
7453 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7454 PyObject *resultobj = 0;
7455 wxMouseState *arg1 = (wxMouseState *) 0 ;
7456 bool result;
7457 void *argp1 = 0 ;
7458 int res1 = 0 ;
7459 PyObject *swig_obj[1] ;
7460
7461 if (!args) SWIG_fail;
7462 swig_obj[0] = args;
7463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7464 if (!SWIG_IsOK(res1)) {
7465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7466 }
7467 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7468 {
7469 PyThreadState* __tstate = wxPyBeginAllowThreads();
7470 result = (bool)(arg1)->RightDown();
7471 wxPyEndAllowThreads(__tstate);
7472 if (PyErr_Occurred()) SWIG_fail;
7473 }
7474 {
7475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7476 }
7477 return resultobj;
7478 fail:
7479 return NULL;
7480 }
7481
7482
7483 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7484 PyObject *resultobj = 0;
7485 wxMouseState *arg1 = (wxMouseState *) 0 ;
7486 bool result;
7487 void *argp1 = 0 ;
7488 int res1 = 0 ;
7489 PyObject *swig_obj[1] ;
7490
7491 if (!args) SWIG_fail;
7492 swig_obj[0] = args;
7493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7494 if (!SWIG_IsOK(res1)) {
7495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7496 }
7497 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7498 {
7499 PyThreadState* __tstate = wxPyBeginAllowThreads();
7500 result = (bool)(arg1)->ControlDown();
7501 wxPyEndAllowThreads(__tstate);
7502 if (PyErr_Occurred()) SWIG_fail;
7503 }
7504 {
7505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7506 }
7507 return resultobj;
7508 fail:
7509 return NULL;
7510 }
7511
7512
7513 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7514 PyObject *resultobj = 0;
7515 wxMouseState *arg1 = (wxMouseState *) 0 ;
7516 bool result;
7517 void *argp1 = 0 ;
7518 int res1 = 0 ;
7519 PyObject *swig_obj[1] ;
7520
7521 if (!args) SWIG_fail;
7522 swig_obj[0] = args;
7523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7524 if (!SWIG_IsOK(res1)) {
7525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7526 }
7527 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7528 {
7529 PyThreadState* __tstate = wxPyBeginAllowThreads();
7530 result = (bool)(arg1)->ShiftDown();
7531 wxPyEndAllowThreads(__tstate);
7532 if (PyErr_Occurred()) SWIG_fail;
7533 }
7534 {
7535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7536 }
7537 return resultobj;
7538 fail:
7539 return NULL;
7540 }
7541
7542
7543 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7544 PyObject *resultobj = 0;
7545 wxMouseState *arg1 = (wxMouseState *) 0 ;
7546 bool result;
7547 void *argp1 = 0 ;
7548 int res1 = 0 ;
7549 PyObject *swig_obj[1] ;
7550
7551 if (!args) SWIG_fail;
7552 swig_obj[0] = args;
7553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7554 if (!SWIG_IsOK(res1)) {
7555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7556 }
7557 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7558 {
7559 PyThreadState* __tstate = wxPyBeginAllowThreads();
7560 result = (bool)(arg1)->AltDown();
7561 wxPyEndAllowThreads(__tstate);
7562 if (PyErr_Occurred()) SWIG_fail;
7563 }
7564 {
7565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7566 }
7567 return resultobj;
7568 fail:
7569 return NULL;
7570 }
7571
7572
7573 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7574 PyObject *resultobj = 0;
7575 wxMouseState *arg1 = (wxMouseState *) 0 ;
7576 bool result;
7577 void *argp1 = 0 ;
7578 int res1 = 0 ;
7579 PyObject *swig_obj[1] ;
7580
7581 if (!args) SWIG_fail;
7582 swig_obj[0] = args;
7583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7584 if (!SWIG_IsOK(res1)) {
7585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7586 }
7587 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7588 {
7589 PyThreadState* __tstate = wxPyBeginAllowThreads();
7590 result = (bool)(arg1)->MetaDown();
7591 wxPyEndAllowThreads(__tstate);
7592 if (PyErr_Occurred()) SWIG_fail;
7593 }
7594 {
7595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7596 }
7597 return resultobj;
7598 fail:
7599 return NULL;
7600 }
7601
7602
7603 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7604 PyObject *resultobj = 0;
7605 wxMouseState *arg1 = (wxMouseState *) 0 ;
7606 bool result;
7607 void *argp1 = 0 ;
7608 int res1 = 0 ;
7609 PyObject *swig_obj[1] ;
7610
7611 if (!args) SWIG_fail;
7612 swig_obj[0] = args;
7613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7614 if (!SWIG_IsOK(res1)) {
7615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7616 }
7617 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7618 {
7619 PyThreadState* __tstate = wxPyBeginAllowThreads();
7620 result = (bool)(arg1)->CmdDown();
7621 wxPyEndAllowThreads(__tstate);
7622 if (PyErr_Occurred()) SWIG_fail;
7623 }
7624 {
7625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7626 }
7627 return resultobj;
7628 fail:
7629 return NULL;
7630 }
7631
7632
7633 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7634 PyObject *resultobj = 0;
7635 wxMouseState *arg1 = (wxMouseState *) 0 ;
7636 int arg2 ;
7637 void *argp1 = 0 ;
7638 int res1 = 0 ;
7639 int val2 ;
7640 int ecode2 = 0 ;
7641 PyObject * obj0 = 0 ;
7642 PyObject * obj1 = 0 ;
7643 char * kwnames[] = {
7644 (char *) "self",(char *) "x", NULL
7645 };
7646
7647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7649 if (!SWIG_IsOK(res1)) {
7650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7651 }
7652 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7653 ecode2 = SWIG_AsVal_int(obj1, &val2);
7654 if (!SWIG_IsOK(ecode2)) {
7655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7656 }
7657 arg2 = static_cast< int >(val2);
7658 {
7659 PyThreadState* __tstate = wxPyBeginAllowThreads();
7660 (arg1)->SetX(arg2);
7661 wxPyEndAllowThreads(__tstate);
7662 if (PyErr_Occurred()) SWIG_fail;
7663 }
7664 resultobj = SWIG_Py_Void();
7665 return resultobj;
7666 fail:
7667 return NULL;
7668 }
7669
7670
7671 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7672 PyObject *resultobj = 0;
7673 wxMouseState *arg1 = (wxMouseState *) 0 ;
7674 int arg2 ;
7675 void *argp1 = 0 ;
7676 int res1 = 0 ;
7677 int val2 ;
7678 int ecode2 = 0 ;
7679 PyObject * obj0 = 0 ;
7680 PyObject * obj1 = 0 ;
7681 char * kwnames[] = {
7682 (char *) "self",(char *) "y", NULL
7683 };
7684
7685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7687 if (!SWIG_IsOK(res1)) {
7688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7689 }
7690 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7691 ecode2 = SWIG_AsVal_int(obj1, &val2);
7692 if (!SWIG_IsOK(ecode2)) {
7693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7694 }
7695 arg2 = static_cast< int >(val2);
7696 {
7697 PyThreadState* __tstate = wxPyBeginAllowThreads();
7698 (arg1)->SetY(arg2);
7699 wxPyEndAllowThreads(__tstate);
7700 if (PyErr_Occurred()) SWIG_fail;
7701 }
7702 resultobj = SWIG_Py_Void();
7703 return resultobj;
7704 fail:
7705 return NULL;
7706 }
7707
7708
7709 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7710 PyObject *resultobj = 0;
7711 wxMouseState *arg1 = (wxMouseState *) 0 ;
7712 bool arg2 ;
7713 void *argp1 = 0 ;
7714 int res1 = 0 ;
7715 bool val2 ;
7716 int ecode2 = 0 ;
7717 PyObject * obj0 = 0 ;
7718 PyObject * obj1 = 0 ;
7719 char * kwnames[] = {
7720 (char *) "self",(char *) "down", NULL
7721 };
7722
7723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7725 if (!SWIG_IsOK(res1)) {
7726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7727 }
7728 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7729 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7730 if (!SWIG_IsOK(ecode2)) {
7731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7732 }
7733 arg2 = static_cast< bool >(val2);
7734 {
7735 PyThreadState* __tstate = wxPyBeginAllowThreads();
7736 (arg1)->SetLeftDown(arg2);
7737 wxPyEndAllowThreads(__tstate);
7738 if (PyErr_Occurred()) SWIG_fail;
7739 }
7740 resultobj = SWIG_Py_Void();
7741 return resultobj;
7742 fail:
7743 return NULL;
7744 }
7745
7746
7747 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7748 PyObject *resultobj = 0;
7749 wxMouseState *arg1 = (wxMouseState *) 0 ;
7750 bool arg2 ;
7751 void *argp1 = 0 ;
7752 int res1 = 0 ;
7753 bool val2 ;
7754 int ecode2 = 0 ;
7755 PyObject * obj0 = 0 ;
7756 PyObject * obj1 = 0 ;
7757 char * kwnames[] = {
7758 (char *) "self",(char *) "down", NULL
7759 };
7760
7761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7763 if (!SWIG_IsOK(res1)) {
7764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7765 }
7766 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7767 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7768 if (!SWIG_IsOK(ecode2)) {
7769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7770 }
7771 arg2 = static_cast< bool >(val2);
7772 {
7773 PyThreadState* __tstate = wxPyBeginAllowThreads();
7774 (arg1)->SetMiddleDown(arg2);
7775 wxPyEndAllowThreads(__tstate);
7776 if (PyErr_Occurred()) SWIG_fail;
7777 }
7778 resultobj = SWIG_Py_Void();
7779 return resultobj;
7780 fail:
7781 return NULL;
7782 }
7783
7784
7785 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7786 PyObject *resultobj = 0;
7787 wxMouseState *arg1 = (wxMouseState *) 0 ;
7788 bool arg2 ;
7789 void *argp1 = 0 ;
7790 int res1 = 0 ;
7791 bool val2 ;
7792 int ecode2 = 0 ;
7793 PyObject * obj0 = 0 ;
7794 PyObject * obj1 = 0 ;
7795 char * kwnames[] = {
7796 (char *) "self",(char *) "down", NULL
7797 };
7798
7799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7801 if (!SWIG_IsOK(res1)) {
7802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7803 }
7804 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7805 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7806 if (!SWIG_IsOK(ecode2)) {
7807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7808 }
7809 arg2 = static_cast< bool >(val2);
7810 {
7811 PyThreadState* __tstate = wxPyBeginAllowThreads();
7812 (arg1)->SetRightDown(arg2);
7813 wxPyEndAllowThreads(__tstate);
7814 if (PyErr_Occurred()) SWIG_fail;
7815 }
7816 resultobj = SWIG_Py_Void();
7817 return resultobj;
7818 fail:
7819 return NULL;
7820 }
7821
7822
7823 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7824 PyObject *resultobj = 0;
7825 wxMouseState *arg1 = (wxMouseState *) 0 ;
7826 bool arg2 ;
7827 void *argp1 = 0 ;
7828 int res1 = 0 ;
7829 bool val2 ;
7830 int ecode2 = 0 ;
7831 PyObject * obj0 = 0 ;
7832 PyObject * obj1 = 0 ;
7833 char * kwnames[] = {
7834 (char *) "self",(char *) "down", NULL
7835 };
7836
7837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7839 if (!SWIG_IsOK(res1)) {
7840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7841 }
7842 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7843 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7844 if (!SWIG_IsOK(ecode2)) {
7845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7846 }
7847 arg2 = static_cast< bool >(val2);
7848 {
7849 PyThreadState* __tstate = wxPyBeginAllowThreads();
7850 (arg1)->SetControlDown(arg2);
7851 wxPyEndAllowThreads(__tstate);
7852 if (PyErr_Occurred()) SWIG_fail;
7853 }
7854 resultobj = SWIG_Py_Void();
7855 return resultobj;
7856 fail:
7857 return NULL;
7858 }
7859
7860
7861 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7862 PyObject *resultobj = 0;
7863 wxMouseState *arg1 = (wxMouseState *) 0 ;
7864 bool arg2 ;
7865 void *argp1 = 0 ;
7866 int res1 = 0 ;
7867 bool val2 ;
7868 int ecode2 = 0 ;
7869 PyObject * obj0 = 0 ;
7870 PyObject * obj1 = 0 ;
7871 char * kwnames[] = {
7872 (char *) "self",(char *) "down", NULL
7873 };
7874
7875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7877 if (!SWIG_IsOK(res1)) {
7878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7879 }
7880 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7881 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7882 if (!SWIG_IsOK(ecode2)) {
7883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7884 }
7885 arg2 = static_cast< bool >(val2);
7886 {
7887 PyThreadState* __tstate = wxPyBeginAllowThreads();
7888 (arg1)->SetShiftDown(arg2);
7889 wxPyEndAllowThreads(__tstate);
7890 if (PyErr_Occurred()) SWIG_fail;
7891 }
7892 resultobj = SWIG_Py_Void();
7893 return resultobj;
7894 fail:
7895 return NULL;
7896 }
7897
7898
7899 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7900 PyObject *resultobj = 0;
7901 wxMouseState *arg1 = (wxMouseState *) 0 ;
7902 bool arg2 ;
7903 void *argp1 = 0 ;
7904 int res1 = 0 ;
7905 bool val2 ;
7906 int ecode2 = 0 ;
7907 PyObject * obj0 = 0 ;
7908 PyObject * obj1 = 0 ;
7909 char * kwnames[] = {
7910 (char *) "self",(char *) "down", NULL
7911 };
7912
7913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7915 if (!SWIG_IsOK(res1)) {
7916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7917 }
7918 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7919 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7920 if (!SWIG_IsOK(ecode2)) {
7921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7922 }
7923 arg2 = static_cast< bool >(val2);
7924 {
7925 PyThreadState* __tstate = wxPyBeginAllowThreads();
7926 (arg1)->SetAltDown(arg2);
7927 wxPyEndAllowThreads(__tstate);
7928 if (PyErr_Occurred()) SWIG_fail;
7929 }
7930 resultobj = SWIG_Py_Void();
7931 return resultobj;
7932 fail:
7933 return NULL;
7934 }
7935
7936
7937 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7938 PyObject *resultobj = 0;
7939 wxMouseState *arg1 = (wxMouseState *) 0 ;
7940 bool arg2 ;
7941 void *argp1 = 0 ;
7942 int res1 = 0 ;
7943 bool val2 ;
7944 int ecode2 = 0 ;
7945 PyObject * obj0 = 0 ;
7946 PyObject * obj1 = 0 ;
7947 char * kwnames[] = {
7948 (char *) "self",(char *) "down", NULL
7949 };
7950
7951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7953 if (!SWIG_IsOK(res1)) {
7954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7955 }
7956 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7957 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7958 if (!SWIG_IsOK(ecode2)) {
7959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7960 }
7961 arg2 = static_cast< bool >(val2);
7962 {
7963 PyThreadState* __tstate = wxPyBeginAllowThreads();
7964 (arg1)->SetMetaDown(arg2);
7965 wxPyEndAllowThreads(__tstate);
7966 if (PyErr_Occurred()) SWIG_fail;
7967 }
7968 resultobj = SWIG_Py_Void();
7969 return resultobj;
7970 fail:
7971 return NULL;
7972 }
7973
7974
7975 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7976 PyObject *obj;
7977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7978 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7979 return SWIG_Py_Void();
7980 }
7981
7982 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7983 return SWIG_Python_InitShadowInstance(args);
7984 }
7985
7986 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7987 PyObject *resultobj = 0;
7988 wxMouseState result;
7989
7990 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7991 {
7992 PyThreadState* __tstate = wxPyBeginAllowThreads();
7993 result = wxGetMouseState();
7994 wxPyEndAllowThreads(__tstate);
7995 if (PyErr_Occurred()) SWIG_fail;
7996 }
7997 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7998 return resultobj;
7999 fail:
8000 return NULL;
8001 }
8002
8003
8004 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8005 PyObject *resultobj = 0;
8006
8007 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8008 {
8009 if (!wxPyCheckForApp()) SWIG_fail;
8010 PyThreadState* __tstate = wxPyBeginAllowThreads();
8011 wxWakeUpMainThread();
8012 wxPyEndAllowThreads(__tstate);
8013 if (PyErr_Occurred()) SWIG_fail;
8014 }
8015 resultobj = SWIG_Py_Void();
8016 return resultobj;
8017 fail:
8018 return NULL;
8019 }
8020
8021
8022 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8023 PyObject *resultobj = 0;
8024
8025 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8026 {
8027 if (!wxPyCheckForApp()) SWIG_fail;
8028 PyThreadState* __tstate = wxPyBeginAllowThreads();
8029 wxMutexGuiEnter();
8030 wxPyEndAllowThreads(__tstate);
8031 if (PyErr_Occurred()) SWIG_fail;
8032 }
8033 resultobj = SWIG_Py_Void();
8034 return resultobj;
8035 fail:
8036 return NULL;
8037 }
8038
8039
8040 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8041 PyObject *resultobj = 0;
8042
8043 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8044 {
8045 if (!wxPyCheckForApp()) SWIG_fail;
8046 PyThreadState* __tstate = wxPyBeginAllowThreads();
8047 wxMutexGuiLeave();
8048 wxPyEndAllowThreads(__tstate);
8049 if (PyErr_Occurred()) SWIG_fail;
8050 }
8051 resultobj = SWIG_Py_Void();
8052 return resultobj;
8053 fail:
8054 return NULL;
8055 }
8056
8057
8058 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8059 PyObject *resultobj = 0;
8060 wxMutexGuiLocker *result = 0 ;
8061
8062 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8063 {
8064 if (!wxPyCheckForApp()) SWIG_fail;
8065 PyThreadState* __tstate = wxPyBeginAllowThreads();
8066 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8067 wxPyEndAllowThreads(__tstate);
8068 if (PyErr_Occurred()) SWIG_fail;
8069 }
8070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8071 return resultobj;
8072 fail:
8073 return NULL;
8074 }
8075
8076
8077 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8078 PyObject *resultobj = 0;
8079 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8080 void *argp1 = 0 ;
8081 int res1 = 0 ;
8082 PyObject *swig_obj[1] ;
8083
8084 if (!args) SWIG_fail;
8085 swig_obj[0] = args;
8086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8087 if (!SWIG_IsOK(res1)) {
8088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8089 }
8090 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8091 {
8092 PyThreadState* __tstate = wxPyBeginAllowThreads();
8093 delete arg1;
8094
8095 wxPyEndAllowThreads(__tstate);
8096 if (PyErr_Occurred()) SWIG_fail;
8097 }
8098 resultobj = SWIG_Py_Void();
8099 return resultobj;
8100 fail:
8101 return NULL;
8102 }
8103
8104
8105 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8106 PyObject *obj;
8107 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8108 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8109 return SWIG_Py_Void();
8110 }
8111
8112 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8113 return SWIG_Python_InitShadowInstance(args);
8114 }
8115
8116 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8117 PyObject *resultobj = 0;
8118 bool result;
8119
8120 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8121 {
8122 PyThreadState* __tstate = wxPyBeginAllowThreads();
8123 result = (bool)wxThread_IsMain();
8124 wxPyEndAllowThreads(__tstate);
8125 if (PyErr_Occurred()) SWIG_fail;
8126 }
8127 {
8128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8129 }
8130 return resultobj;
8131 fail:
8132 return NULL;
8133 }
8134
8135
8136 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8137 PyObject *resultobj = 0;
8138 wxString *arg1 = 0 ;
8139 wxToolTip *result = 0 ;
8140 bool temp1 = false ;
8141 PyObject * obj0 = 0 ;
8142 char * kwnames[] = {
8143 (char *) "tip", NULL
8144 };
8145
8146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8147 {
8148 arg1 = wxString_in_helper(obj0);
8149 if (arg1 == NULL) SWIG_fail;
8150 temp1 = true;
8151 }
8152 {
8153 if (!wxPyCheckForApp()) SWIG_fail;
8154 PyThreadState* __tstate = wxPyBeginAllowThreads();
8155 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8156 wxPyEndAllowThreads(__tstate);
8157 if (PyErr_Occurred()) SWIG_fail;
8158 }
8159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8160 {
8161 if (temp1)
8162 delete arg1;
8163 }
8164 return resultobj;
8165 fail:
8166 {
8167 if (temp1)
8168 delete arg1;
8169 }
8170 return NULL;
8171 }
8172
8173
8174 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8175 PyObject *resultobj = 0;
8176 wxToolTip *arg1 = (wxToolTip *) 0 ;
8177 void *argp1 = 0 ;
8178 int res1 = 0 ;
8179 PyObject *swig_obj[1] ;
8180
8181 if (!args) SWIG_fail;
8182 swig_obj[0] = args;
8183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8184 if (!SWIG_IsOK(res1)) {
8185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8186 }
8187 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8188 {
8189 PyThreadState* __tstate = wxPyBeginAllowThreads();
8190 delete arg1;
8191
8192 wxPyEndAllowThreads(__tstate);
8193 if (PyErr_Occurred()) SWIG_fail;
8194 }
8195 resultobj = SWIG_Py_Void();
8196 return resultobj;
8197 fail:
8198 return NULL;
8199 }
8200
8201
8202 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8203 PyObject *resultobj = 0;
8204 wxToolTip *arg1 = (wxToolTip *) 0 ;
8205 wxString *arg2 = 0 ;
8206 void *argp1 = 0 ;
8207 int res1 = 0 ;
8208 bool temp2 = false ;
8209 PyObject * obj0 = 0 ;
8210 PyObject * obj1 = 0 ;
8211 char * kwnames[] = {
8212 (char *) "self",(char *) "tip", NULL
8213 };
8214
8215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8217 if (!SWIG_IsOK(res1)) {
8218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8219 }
8220 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8221 {
8222 arg2 = wxString_in_helper(obj1);
8223 if (arg2 == NULL) SWIG_fail;
8224 temp2 = true;
8225 }
8226 {
8227 PyThreadState* __tstate = wxPyBeginAllowThreads();
8228 (arg1)->SetTip((wxString const &)*arg2);
8229 wxPyEndAllowThreads(__tstate);
8230 if (PyErr_Occurred()) SWIG_fail;
8231 }
8232 resultobj = SWIG_Py_Void();
8233 {
8234 if (temp2)
8235 delete arg2;
8236 }
8237 return resultobj;
8238 fail:
8239 {
8240 if (temp2)
8241 delete arg2;
8242 }
8243 return NULL;
8244 }
8245
8246
8247 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8248 PyObject *resultobj = 0;
8249 wxToolTip *arg1 = (wxToolTip *) 0 ;
8250 wxString result;
8251 void *argp1 = 0 ;
8252 int res1 = 0 ;
8253 PyObject *swig_obj[1] ;
8254
8255 if (!args) SWIG_fail;
8256 swig_obj[0] = args;
8257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8258 if (!SWIG_IsOK(res1)) {
8259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8260 }
8261 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8262 {
8263 PyThreadState* __tstate = wxPyBeginAllowThreads();
8264 result = (arg1)->GetTip();
8265 wxPyEndAllowThreads(__tstate);
8266 if (PyErr_Occurred()) SWIG_fail;
8267 }
8268 {
8269 #if wxUSE_UNICODE
8270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8271 #else
8272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8273 #endif
8274 }
8275 return resultobj;
8276 fail:
8277 return NULL;
8278 }
8279
8280
8281 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8282 PyObject *resultobj = 0;
8283 wxToolTip *arg1 = (wxToolTip *) 0 ;
8284 wxWindow *result = 0 ;
8285 void *argp1 = 0 ;
8286 int res1 = 0 ;
8287 PyObject *swig_obj[1] ;
8288
8289 if (!args) SWIG_fail;
8290 swig_obj[0] = args;
8291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8292 if (!SWIG_IsOK(res1)) {
8293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8294 }
8295 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8296 {
8297 PyThreadState* __tstate = wxPyBeginAllowThreads();
8298 result = (wxWindow *)(arg1)->GetWindow();
8299 wxPyEndAllowThreads(__tstate);
8300 if (PyErr_Occurred()) SWIG_fail;
8301 }
8302 {
8303 resultobj = wxPyMake_wxObject(result, 0);
8304 }
8305 return resultobj;
8306 fail:
8307 return NULL;
8308 }
8309
8310
8311 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8312 PyObject *resultobj = 0;
8313 bool arg1 ;
8314 bool val1 ;
8315 int ecode1 = 0 ;
8316 PyObject * obj0 = 0 ;
8317 char * kwnames[] = {
8318 (char *) "flag", NULL
8319 };
8320
8321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8322 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8323 if (!SWIG_IsOK(ecode1)) {
8324 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8325 }
8326 arg1 = static_cast< bool >(val1);
8327 {
8328 PyThreadState* __tstate = wxPyBeginAllowThreads();
8329 wxToolTip::Enable(arg1);
8330 wxPyEndAllowThreads(__tstate);
8331 if (PyErr_Occurred()) SWIG_fail;
8332 }
8333 resultobj = SWIG_Py_Void();
8334 return resultobj;
8335 fail:
8336 return NULL;
8337 }
8338
8339
8340 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8341 PyObject *resultobj = 0;
8342 long arg1 ;
8343 long val1 ;
8344 int ecode1 = 0 ;
8345 PyObject * obj0 = 0 ;
8346 char * kwnames[] = {
8347 (char *) "milliseconds", NULL
8348 };
8349
8350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8351 ecode1 = SWIG_AsVal_long(obj0, &val1);
8352 if (!SWIG_IsOK(ecode1)) {
8353 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8354 }
8355 arg1 = static_cast< long >(val1);
8356 {
8357 PyThreadState* __tstate = wxPyBeginAllowThreads();
8358 wxToolTip::SetDelay(arg1);
8359 wxPyEndAllowThreads(__tstate);
8360 if (PyErr_Occurred()) SWIG_fail;
8361 }
8362 resultobj = SWIG_Py_Void();
8363 return resultobj;
8364 fail:
8365 return NULL;
8366 }
8367
8368
8369 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8370 PyObject *obj;
8371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8372 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8373 return SWIG_Py_Void();
8374 }
8375
8376 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8377 return SWIG_Python_InitShadowInstance(args);
8378 }
8379
8380 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8381 PyObject *resultobj = 0;
8382 wxWindow *arg1 = (wxWindow *) 0 ;
8383 wxSize *arg2 = 0 ;
8384 wxCaret *result = 0 ;
8385 void *argp1 = 0 ;
8386 int res1 = 0 ;
8387 wxSize temp2 ;
8388 PyObject * obj0 = 0 ;
8389 PyObject * obj1 = 0 ;
8390 char * kwnames[] = {
8391 (char *) "window",(char *) "size", NULL
8392 };
8393
8394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8396 if (!SWIG_IsOK(res1)) {
8397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8398 }
8399 arg1 = reinterpret_cast< wxWindow * >(argp1);
8400 {
8401 arg2 = &temp2;
8402 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8403 }
8404 {
8405 if (!wxPyCheckForApp()) SWIG_fail;
8406 PyThreadState* __tstate = wxPyBeginAllowThreads();
8407 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8408 wxPyEndAllowThreads(__tstate);
8409 if (PyErr_Occurred()) SWIG_fail;
8410 }
8411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8412 return resultobj;
8413 fail:
8414 return NULL;
8415 }
8416
8417
8418 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8419 PyObject *resultobj = 0;
8420 wxCaret *arg1 = (wxCaret *) 0 ;
8421 void *argp1 = 0 ;
8422 int res1 = 0 ;
8423 PyObject *swig_obj[1] ;
8424
8425 if (!args) SWIG_fail;
8426 swig_obj[0] = args;
8427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8428 if (!SWIG_IsOK(res1)) {
8429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8430 }
8431 arg1 = reinterpret_cast< wxCaret * >(argp1);
8432 {
8433 PyThreadState* __tstate = wxPyBeginAllowThreads();
8434 delete arg1;
8435
8436 wxPyEndAllowThreads(__tstate);
8437 if (PyErr_Occurred()) SWIG_fail;
8438 }
8439 resultobj = SWIG_Py_Void();
8440 return resultobj;
8441 fail:
8442 return NULL;
8443 }
8444
8445
8446 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8447 PyObject *resultobj = 0;
8448 wxCaret *arg1 = (wxCaret *) 0 ;
8449 void *argp1 = 0 ;
8450 int res1 = 0 ;
8451 PyObject *swig_obj[1] ;
8452
8453 if (!args) SWIG_fail;
8454 swig_obj[0] = args;
8455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8456 if (!SWIG_IsOK(res1)) {
8457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8458 }
8459 arg1 = reinterpret_cast< wxCaret * >(argp1);
8460 {
8461 PyThreadState* __tstate = wxPyBeginAllowThreads();
8462 wxCaret_Destroy(arg1);
8463 wxPyEndAllowThreads(__tstate);
8464 if (PyErr_Occurred()) SWIG_fail;
8465 }
8466 resultobj = SWIG_Py_Void();
8467 return resultobj;
8468 fail:
8469 return NULL;
8470 }
8471
8472
8473 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8474 PyObject *resultobj = 0;
8475 wxCaret *arg1 = (wxCaret *) 0 ;
8476 bool result;
8477 void *argp1 = 0 ;
8478 int res1 = 0 ;
8479 PyObject *swig_obj[1] ;
8480
8481 if (!args) SWIG_fail;
8482 swig_obj[0] = args;
8483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8484 if (!SWIG_IsOK(res1)) {
8485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8486 }
8487 arg1 = reinterpret_cast< wxCaret * >(argp1);
8488 {
8489 PyThreadState* __tstate = wxPyBeginAllowThreads();
8490 result = (bool)(arg1)->IsOk();
8491 wxPyEndAllowThreads(__tstate);
8492 if (PyErr_Occurred()) SWIG_fail;
8493 }
8494 {
8495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8496 }
8497 return resultobj;
8498 fail:
8499 return NULL;
8500 }
8501
8502
8503 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8504 PyObject *resultobj = 0;
8505 wxCaret *arg1 = (wxCaret *) 0 ;
8506 bool result;
8507 void *argp1 = 0 ;
8508 int res1 = 0 ;
8509 PyObject *swig_obj[1] ;
8510
8511 if (!args) SWIG_fail;
8512 swig_obj[0] = args;
8513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8514 if (!SWIG_IsOK(res1)) {
8515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8516 }
8517 arg1 = reinterpret_cast< wxCaret * >(argp1);
8518 {
8519 PyThreadState* __tstate = wxPyBeginAllowThreads();
8520 result = (bool)(arg1)->IsVisible();
8521 wxPyEndAllowThreads(__tstate);
8522 if (PyErr_Occurred()) SWIG_fail;
8523 }
8524 {
8525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8526 }
8527 return resultobj;
8528 fail:
8529 return NULL;
8530 }
8531
8532
8533 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8534 PyObject *resultobj = 0;
8535 wxCaret *arg1 = (wxCaret *) 0 ;
8536 wxPoint result;
8537 void *argp1 = 0 ;
8538 int res1 = 0 ;
8539 PyObject *swig_obj[1] ;
8540
8541 if (!args) SWIG_fail;
8542 swig_obj[0] = args;
8543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8544 if (!SWIG_IsOK(res1)) {
8545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8546 }
8547 arg1 = reinterpret_cast< wxCaret * >(argp1);
8548 {
8549 PyThreadState* __tstate = wxPyBeginAllowThreads();
8550 result = (arg1)->GetPosition();
8551 wxPyEndAllowThreads(__tstate);
8552 if (PyErr_Occurred()) SWIG_fail;
8553 }
8554 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8555 return resultobj;
8556 fail:
8557 return NULL;
8558 }
8559
8560
8561 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8562 PyObject *resultobj = 0;
8563 wxCaret *arg1 = (wxCaret *) 0 ;
8564 int *arg2 = (int *) 0 ;
8565 int *arg3 = (int *) 0 ;
8566 void *argp1 = 0 ;
8567 int res1 = 0 ;
8568 int temp2 ;
8569 int res2 = SWIG_TMPOBJ ;
8570 int temp3 ;
8571 int res3 = SWIG_TMPOBJ ;
8572 PyObject *swig_obj[1] ;
8573
8574 arg2 = &temp2;
8575 arg3 = &temp3;
8576 if (!args) SWIG_fail;
8577 swig_obj[0] = args;
8578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8579 if (!SWIG_IsOK(res1)) {
8580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8581 }
8582 arg1 = reinterpret_cast< wxCaret * >(argp1);
8583 {
8584 PyThreadState* __tstate = wxPyBeginAllowThreads();
8585 (arg1)->GetPosition(arg2,arg3);
8586 wxPyEndAllowThreads(__tstate);
8587 if (PyErr_Occurred()) SWIG_fail;
8588 }
8589 resultobj = SWIG_Py_Void();
8590 if (SWIG_IsTmpObj(res2)) {
8591 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8592 } else {
8593 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8594 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8595 }
8596 if (SWIG_IsTmpObj(res3)) {
8597 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8598 } else {
8599 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8600 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8601 }
8602 return resultobj;
8603 fail:
8604 return NULL;
8605 }
8606
8607
8608 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8609 PyObject *resultobj = 0;
8610 wxCaret *arg1 = (wxCaret *) 0 ;
8611 wxSize result;
8612 void *argp1 = 0 ;
8613 int res1 = 0 ;
8614 PyObject *swig_obj[1] ;
8615
8616 if (!args) SWIG_fail;
8617 swig_obj[0] = args;
8618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8619 if (!SWIG_IsOK(res1)) {
8620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8621 }
8622 arg1 = reinterpret_cast< wxCaret * >(argp1);
8623 {
8624 PyThreadState* __tstate = wxPyBeginAllowThreads();
8625 result = (arg1)->GetSize();
8626 wxPyEndAllowThreads(__tstate);
8627 if (PyErr_Occurred()) SWIG_fail;
8628 }
8629 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8630 return resultobj;
8631 fail:
8632 return NULL;
8633 }
8634
8635
8636 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8637 PyObject *resultobj = 0;
8638 wxCaret *arg1 = (wxCaret *) 0 ;
8639 int *arg2 = (int *) 0 ;
8640 int *arg3 = (int *) 0 ;
8641 void *argp1 = 0 ;
8642 int res1 = 0 ;
8643 int temp2 ;
8644 int res2 = SWIG_TMPOBJ ;
8645 int temp3 ;
8646 int res3 = SWIG_TMPOBJ ;
8647 PyObject *swig_obj[1] ;
8648
8649 arg2 = &temp2;
8650 arg3 = &temp3;
8651 if (!args) SWIG_fail;
8652 swig_obj[0] = args;
8653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8654 if (!SWIG_IsOK(res1)) {
8655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8656 }
8657 arg1 = reinterpret_cast< wxCaret * >(argp1);
8658 {
8659 PyThreadState* __tstate = wxPyBeginAllowThreads();
8660 (arg1)->GetSize(arg2,arg3);
8661 wxPyEndAllowThreads(__tstate);
8662 if (PyErr_Occurred()) SWIG_fail;
8663 }
8664 resultobj = SWIG_Py_Void();
8665 if (SWIG_IsTmpObj(res2)) {
8666 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8667 } else {
8668 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8669 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8670 }
8671 if (SWIG_IsTmpObj(res3)) {
8672 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8673 } else {
8674 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8675 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8676 }
8677 return resultobj;
8678 fail:
8679 return NULL;
8680 }
8681
8682
8683 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8684 PyObject *resultobj = 0;
8685 wxCaret *arg1 = (wxCaret *) 0 ;
8686 wxWindow *result = 0 ;
8687 void *argp1 = 0 ;
8688 int res1 = 0 ;
8689 PyObject *swig_obj[1] ;
8690
8691 if (!args) SWIG_fail;
8692 swig_obj[0] = args;
8693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8694 if (!SWIG_IsOK(res1)) {
8695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8696 }
8697 arg1 = reinterpret_cast< wxCaret * >(argp1);
8698 {
8699 PyThreadState* __tstate = wxPyBeginAllowThreads();
8700 result = (wxWindow *)(arg1)->GetWindow();
8701 wxPyEndAllowThreads(__tstate);
8702 if (PyErr_Occurred()) SWIG_fail;
8703 }
8704 {
8705 resultobj = wxPyMake_wxObject(result, 0);
8706 }
8707 return resultobj;
8708 fail:
8709 return NULL;
8710 }
8711
8712
8713 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8714 PyObject *resultobj = 0;
8715 wxCaret *arg1 = (wxCaret *) 0 ;
8716 int arg2 ;
8717 int arg3 ;
8718 void *argp1 = 0 ;
8719 int res1 = 0 ;
8720 int val2 ;
8721 int ecode2 = 0 ;
8722 int val3 ;
8723 int ecode3 = 0 ;
8724 PyObject * obj0 = 0 ;
8725 PyObject * obj1 = 0 ;
8726 PyObject * obj2 = 0 ;
8727 char * kwnames[] = {
8728 (char *) "self",(char *) "x",(char *) "y", NULL
8729 };
8730
8731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8733 if (!SWIG_IsOK(res1)) {
8734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8735 }
8736 arg1 = reinterpret_cast< wxCaret * >(argp1);
8737 ecode2 = SWIG_AsVal_int(obj1, &val2);
8738 if (!SWIG_IsOK(ecode2)) {
8739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8740 }
8741 arg2 = static_cast< int >(val2);
8742 ecode3 = SWIG_AsVal_int(obj2, &val3);
8743 if (!SWIG_IsOK(ecode3)) {
8744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8745 }
8746 arg3 = static_cast< int >(val3);
8747 {
8748 PyThreadState* __tstate = wxPyBeginAllowThreads();
8749 (arg1)->Move(arg2,arg3);
8750 wxPyEndAllowThreads(__tstate);
8751 if (PyErr_Occurred()) SWIG_fail;
8752 }
8753 resultobj = SWIG_Py_Void();
8754 return resultobj;
8755 fail:
8756 return NULL;
8757 }
8758
8759
8760 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8761 PyObject *resultobj = 0;
8762 wxCaret *arg1 = (wxCaret *) 0 ;
8763 wxPoint *arg2 = 0 ;
8764 void *argp1 = 0 ;
8765 int res1 = 0 ;
8766 wxPoint temp2 ;
8767 PyObject * obj0 = 0 ;
8768 PyObject * obj1 = 0 ;
8769 char * kwnames[] = {
8770 (char *) "self",(char *) "pt", NULL
8771 };
8772
8773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8775 if (!SWIG_IsOK(res1)) {
8776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8777 }
8778 arg1 = reinterpret_cast< wxCaret * >(argp1);
8779 {
8780 arg2 = &temp2;
8781 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8782 }
8783 {
8784 PyThreadState* __tstate = wxPyBeginAllowThreads();
8785 (arg1)->Move((wxPoint const &)*arg2);
8786 wxPyEndAllowThreads(__tstate);
8787 if (PyErr_Occurred()) SWIG_fail;
8788 }
8789 resultobj = SWIG_Py_Void();
8790 return resultobj;
8791 fail:
8792 return NULL;
8793 }
8794
8795
8796 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8797 PyObject *resultobj = 0;
8798 wxCaret *arg1 = (wxCaret *) 0 ;
8799 int arg2 ;
8800 int arg3 ;
8801 void *argp1 = 0 ;
8802 int res1 = 0 ;
8803 int val2 ;
8804 int ecode2 = 0 ;
8805 int val3 ;
8806 int ecode3 = 0 ;
8807 PyObject * obj0 = 0 ;
8808 PyObject * obj1 = 0 ;
8809 PyObject * obj2 = 0 ;
8810 char * kwnames[] = {
8811 (char *) "self",(char *) "width",(char *) "height", NULL
8812 };
8813
8814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) 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_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8818 }
8819 arg1 = reinterpret_cast< wxCaret * >(argp1);
8820 ecode2 = SWIG_AsVal_int(obj1, &val2);
8821 if (!SWIG_IsOK(ecode2)) {
8822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8823 }
8824 arg2 = static_cast< int >(val2);
8825 ecode3 = SWIG_AsVal_int(obj2, &val3);
8826 if (!SWIG_IsOK(ecode3)) {
8827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8828 }
8829 arg3 = static_cast< int >(val3);
8830 {
8831 PyThreadState* __tstate = wxPyBeginAllowThreads();
8832 (arg1)->SetSize(arg2,arg3);
8833 wxPyEndAllowThreads(__tstate);
8834 if (PyErr_Occurred()) SWIG_fail;
8835 }
8836 resultobj = SWIG_Py_Void();
8837 return resultobj;
8838 fail:
8839 return NULL;
8840 }
8841
8842
8843 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8844 PyObject *resultobj = 0;
8845 wxCaret *arg1 = (wxCaret *) 0 ;
8846 wxSize *arg2 = 0 ;
8847 void *argp1 = 0 ;
8848 int res1 = 0 ;
8849 wxSize temp2 ;
8850 PyObject * obj0 = 0 ;
8851 PyObject * obj1 = 0 ;
8852 char * kwnames[] = {
8853 (char *) "self",(char *) "size", NULL
8854 };
8855
8856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8858 if (!SWIG_IsOK(res1)) {
8859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8860 }
8861 arg1 = reinterpret_cast< wxCaret * >(argp1);
8862 {
8863 arg2 = &temp2;
8864 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8865 }
8866 {
8867 PyThreadState* __tstate = wxPyBeginAllowThreads();
8868 (arg1)->SetSize((wxSize const &)*arg2);
8869 wxPyEndAllowThreads(__tstate);
8870 if (PyErr_Occurred()) SWIG_fail;
8871 }
8872 resultobj = SWIG_Py_Void();
8873 return resultobj;
8874 fail:
8875 return NULL;
8876 }
8877
8878
8879 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8880 PyObject *resultobj = 0;
8881 wxCaret *arg1 = (wxCaret *) 0 ;
8882 int arg2 = (int) true ;
8883 void *argp1 = 0 ;
8884 int res1 = 0 ;
8885 int val2 ;
8886 int ecode2 = 0 ;
8887 PyObject * obj0 = 0 ;
8888 PyObject * obj1 = 0 ;
8889 char * kwnames[] = {
8890 (char *) "self",(char *) "show", NULL
8891 };
8892
8893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8895 if (!SWIG_IsOK(res1)) {
8896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8897 }
8898 arg1 = reinterpret_cast< wxCaret * >(argp1);
8899 if (obj1) {
8900 ecode2 = SWIG_AsVal_int(obj1, &val2);
8901 if (!SWIG_IsOK(ecode2)) {
8902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8903 }
8904 arg2 = static_cast< int >(val2);
8905 }
8906 {
8907 PyThreadState* __tstate = wxPyBeginAllowThreads();
8908 (arg1)->Show(arg2);
8909 wxPyEndAllowThreads(__tstate);
8910 if (PyErr_Occurred()) SWIG_fail;
8911 }
8912 resultobj = SWIG_Py_Void();
8913 return resultobj;
8914 fail:
8915 return NULL;
8916 }
8917
8918
8919 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8920 PyObject *resultobj = 0;
8921 wxCaret *arg1 = (wxCaret *) 0 ;
8922 void *argp1 = 0 ;
8923 int res1 = 0 ;
8924 PyObject *swig_obj[1] ;
8925
8926 if (!args) SWIG_fail;
8927 swig_obj[0] = args;
8928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8929 if (!SWIG_IsOK(res1)) {
8930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8931 }
8932 arg1 = reinterpret_cast< wxCaret * >(argp1);
8933 {
8934 PyThreadState* __tstate = wxPyBeginAllowThreads();
8935 (arg1)->Hide();
8936 wxPyEndAllowThreads(__tstate);
8937 if (PyErr_Occurred()) SWIG_fail;
8938 }
8939 resultobj = SWIG_Py_Void();
8940 return resultobj;
8941 fail:
8942 return NULL;
8943 }
8944
8945
8946 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8947 PyObject *resultobj = 0;
8948 int result;
8949
8950 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8951 {
8952 PyThreadState* __tstate = wxPyBeginAllowThreads();
8953 result = (int)wxCaret::GetBlinkTime();
8954 wxPyEndAllowThreads(__tstate);
8955 if (PyErr_Occurred()) SWIG_fail;
8956 }
8957 resultobj = SWIG_From_int(static_cast< int >(result));
8958 return resultobj;
8959 fail:
8960 return NULL;
8961 }
8962
8963
8964 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8965 PyObject *resultobj = 0;
8966 int arg1 ;
8967 int val1 ;
8968 int ecode1 = 0 ;
8969 PyObject * obj0 = 0 ;
8970 char * kwnames[] = {
8971 (char *) "milliseconds", NULL
8972 };
8973
8974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8975 ecode1 = SWIG_AsVal_int(obj0, &val1);
8976 if (!SWIG_IsOK(ecode1)) {
8977 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8978 }
8979 arg1 = static_cast< int >(val1);
8980 {
8981 PyThreadState* __tstate = wxPyBeginAllowThreads();
8982 wxCaret::SetBlinkTime(arg1);
8983 wxPyEndAllowThreads(__tstate);
8984 if (PyErr_Occurred()) SWIG_fail;
8985 }
8986 resultobj = SWIG_Py_Void();
8987 return resultobj;
8988 fail:
8989 return NULL;
8990 }
8991
8992
8993 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8994 PyObject *obj;
8995 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8996 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8997 return SWIG_Py_Void();
8998 }
8999
9000 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9001 return SWIG_Python_InitShadowInstance(args);
9002 }
9003
9004 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9005 PyObject *resultobj = 0;
9006 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9007 wxBusyCursor *result = 0 ;
9008 void *argp1 = 0 ;
9009 int res1 = 0 ;
9010 PyObject * obj0 = 0 ;
9011 char * kwnames[] = {
9012 (char *) "cursor", NULL
9013 };
9014
9015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9016 if (obj0) {
9017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9018 if (!SWIG_IsOK(res1)) {
9019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9020 }
9021 arg1 = reinterpret_cast< wxCursor * >(argp1);
9022 }
9023 {
9024 if (!wxPyCheckForApp()) SWIG_fail;
9025 PyThreadState* __tstate = wxPyBeginAllowThreads();
9026 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9027 wxPyEndAllowThreads(__tstate);
9028 if (PyErr_Occurred()) SWIG_fail;
9029 }
9030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9031 return resultobj;
9032 fail:
9033 return NULL;
9034 }
9035
9036
9037 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9038 PyObject *resultobj = 0;
9039 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9040 void *argp1 = 0 ;
9041 int res1 = 0 ;
9042 PyObject *swig_obj[1] ;
9043
9044 if (!args) SWIG_fail;
9045 swig_obj[0] = args;
9046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9047 if (!SWIG_IsOK(res1)) {
9048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9049 }
9050 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9051 {
9052 PyThreadState* __tstate = wxPyBeginAllowThreads();
9053 delete arg1;
9054
9055 wxPyEndAllowThreads(__tstate);
9056 if (PyErr_Occurred()) SWIG_fail;
9057 }
9058 resultobj = SWIG_Py_Void();
9059 return resultobj;
9060 fail:
9061 return NULL;
9062 }
9063
9064
9065 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9066 PyObject *obj;
9067 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9068 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9069 return SWIG_Py_Void();
9070 }
9071
9072 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9073 return SWIG_Python_InitShadowInstance(args);
9074 }
9075
9076 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9077 PyObject *resultobj = 0;
9078 wxWindow *arg1 = (wxWindow *) NULL ;
9079 wxWindowDisabler *result = 0 ;
9080 void *argp1 = 0 ;
9081 int res1 = 0 ;
9082 PyObject * obj0 = 0 ;
9083 char * kwnames[] = {
9084 (char *) "winToSkip", NULL
9085 };
9086
9087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9088 if (obj0) {
9089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9090 if (!SWIG_IsOK(res1)) {
9091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9092 }
9093 arg1 = reinterpret_cast< wxWindow * >(argp1);
9094 }
9095 {
9096 if (!wxPyCheckForApp()) SWIG_fail;
9097 PyThreadState* __tstate = wxPyBeginAllowThreads();
9098 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9099 wxPyEndAllowThreads(__tstate);
9100 if (PyErr_Occurred()) SWIG_fail;
9101 }
9102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9103 return resultobj;
9104 fail:
9105 return NULL;
9106 }
9107
9108
9109 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9110 PyObject *resultobj = 0;
9111 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9112 void *argp1 = 0 ;
9113 int res1 = 0 ;
9114 PyObject *swig_obj[1] ;
9115
9116 if (!args) SWIG_fail;
9117 swig_obj[0] = args;
9118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9119 if (!SWIG_IsOK(res1)) {
9120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9121 }
9122 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9123 {
9124 PyThreadState* __tstate = wxPyBeginAllowThreads();
9125 delete arg1;
9126
9127 wxPyEndAllowThreads(__tstate);
9128 if (PyErr_Occurred()) SWIG_fail;
9129 }
9130 resultobj = SWIG_Py_Void();
9131 return resultobj;
9132 fail:
9133 return NULL;
9134 }
9135
9136
9137 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9138 PyObject *obj;
9139 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9140 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9141 return SWIG_Py_Void();
9142 }
9143
9144 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9145 return SWIG_Python_InitShadowInstance(args);
9146 }
9147
9148 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9149 PyObject *resultobj = 0;
9150 wxString *arg1 = 0 ;
9151 wxBusyInfo *result = 0 ;
9152 bool temp1 = false ;
9153 PyObject * obj0 = 0 ;
9154 char * kwnames[] = {
9155 (char *) "message", NULL
9156 };
9157
9158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9159 {
9160 arg1 = wxString_in_helper(obj0);
9161 if (arg1 == NULL) SWIG_fail;
9162 temp1 = true;
9163 }
9164 {
9165 if (!wxPyCheckForApp()) SWIG_fail;
9166 PyThreadState* __tstate = wxPyBeginAllowThreads();
9167 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9168 wxPyEndAllowThreads(__tstate);
9169 if (PyErr_Occurred()) SWIG_fail;
9170 }
9171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9172 {
9173 if (temp1)
9174 delete arg1;
9175 }
9176 return resultobj;
9177 fail:
9178 {
9179 if (temp1)
9180 delete arg1;
9181 }
9182 return NULL;
9183 }
9184
9185
9186 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9187 PyObject *resultobj = 0;
9188 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9189 void *argp1 = 0 ;
9190 int res1 = 0 ;
9191 PyObject *swig_obj[1] ;
9192
9193 if (!args) SWIG_fail;
9194 swig_obj[0] = args;
9195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9196 if (!SWIG_IsOK(res1)) {
9197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9198 }
9199 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9200 {
9201 PyThreadState* __tstate = wxPyBeginAllowThreads();
9202 delete arg1;
9203
9204 wxPyEndAllowThreads(__tstate);
9205 if (PyErr_Occurred()) SWIG_fail;
9206 }
9207 resultobj = SWIG_Py_Void();
9208 return resultobj;
9209 fail:
9210 return NULL;
9211 }
9212
9213
9214 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9215 PyObject *obj;
9216 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9217 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9218 return SWIG_Py_Void();
9219 }
9220
9221 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9222 return SWIG_Python_InitShadowInstance(args);
9223 }
9224
9225 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9226 PyObject *resultobj = 0;
9227 wxStopWatch *result = 0 ;
9228
9229 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9230 {
9231 PyThreadState* __tstate = wxPyBeginAllowThreads();
9232 result = (wxStopWatch *)new wxStopWatch();
9233 wxPyEndAllowThreads(__tstate);
9234 if (PyErr_Occurred()) SWIG_fail;
9235 }
9236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9237 return resultobj;
9238 fail:
9239 return NULL;
9240 }
9241
9242
9243 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9244 PyObject *resultobj = 0;
9245 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9246 long arg2 = (long) 0 ;
9247 void *argp1 = 0 ;
9248 int res1 = 0 ;
9249 long val2 ;
9250 int ecode2 = 0 ;
9251 PyObject * obj0 = 0 ;
9252 PyObject * obj1 = 0 ;
9253 char * kwnames[] = {
9254 (char *) "self",(char *) "t0", NULL
9255 };
9256
9257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9259 if (!SWIG_IsOK(res1)) {
9260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9261 }
9262 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9263 if (obj1) {
9264 ecode2 = SWIG_AsVal_long(obj1, &val2);
9265 if (!SWIG_IsOK(ecode2)) {
9266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9267 }
9268 arg2 = static_cast< long >(val2);
9269 }
9270 {
9271 PyThreadState* __tstate = wxPyBeginAllowThreads();
9272 (arg1)->Start(arg2);
9273 wxPyEndAllowThreads(__tstate);
9274 if (PyErr_Occurred()) SWIG_fail;
9275 }
9276 resultobj = SWIG_Py_Void();
9277 return resultobj;
9278 fail:
9279 return NULL;
9280 }
9281
9282
9283 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9284 PyObject *resultobj = 0;
9285 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9286 void *argp1 = 0 ;
9287 int res1 = 0 ;
9288 PyObject *swig_obj[1] ;
9289
9290 if (!args) SWIG_fail;
9291 swig_obj[0] = args;
9292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9293 if (!SWIG_IsOK(res1)) {
9294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9295 }
9296 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9297 {
9298 PyThreadState* __tstate = wxPyBeginAllowThreads();
9299 (arg1)->Pause();
9300 wxPyEndAllowThreads(__tstate);
9301 if (PyErr_Occurred()) SWIG_fail;
9302 }
9303 resultobj = SWIG_Py_Void();
9304 return resultobj;
9305 fail:
9306 return NULL;
9307 }
9308
9309
9310 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9311 PyObject *resultobj = 0;
9312 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9313 void *argp1 = 0 ;
9314 int res1 = 0 ;
9315 PyObject *swig_obj[1] ;
9316
9317 if (!args) SWIG_fail;
9318 swig_obj[0] = args;
9319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9320 if (!SWIG_IsOK(res1)) {
9321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9322 }
9323 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9324 {
9325 PyThreadState* __tstate = wxPyBeginAllowThreads();
9326 (arg1)->Resume();
9327 wxPyEndAllowThreads(__tstate);
9328 if (PyErr_Occurred()) SWIG_fail;
9329 }
9330 resultobj = SWIG_Py_Void();
9331 return resultobj;
9332 fail:
9333 return NULL;
9334 }
9335
9336
9337 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9338 PyObject *resultobj = 0;
9339 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9340 long result;
9341 void *argp1 = 0 ;
9342 int res1 = 0 ;
9343 PyObject *swig_obj[1] ;
9344
9345 if (!args) SWIG_fail;
9346 swig_obj[0] = args;
9347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9348 if (!SWIG_IsOK(res1)) {
9349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9350 }
9351 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9352 {
9353 PyThreadState* __tstate = wxPyBeginAllowThreads();
9354 result = (long)((wxStopWatch const *)arg1)->Time();
9355 wxPyEndAllowThreads(__tstate);
9356 if (PyErr_Occurred()) SWIG_fail;
9357 }
9358 resultobj = SWIG_From_long(static_cast< long >(result));
9359 return resultobj;
9360 fail:
9361 return NULL;
9362 }
9363
9364
9365 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9366 PyObject *obj;
9367 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9368 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9369 return SWIG_Py_Void();
9370 }
9371
9372 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9373 return SWIG_Python_InitShadowInstance(args);
9374 }
9375
9376 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9377 PyObject *resultobj = 0;
9378 int arg1 = (int) 9 ;
9379 int arg2 = (int) wxID_FILE1 ;
9380 wxFileHistory *result = 0 ;
9381 int val1 ;
9382 int ecode1 = 0 ;
9383 int val2 ;
9384 int ecode2 = 0 ;
9385 PyObject * obj0 = 0 ;
9386 PyObject * obj1 = 0 ;
9387 char * kwnames[] = {
9388 (char *) "maxFiles",(char *) "idBase", NULL
9389 };
9390
9391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9392 if (obj0) {
9393 ecode1 = SWIG_AsVal_int(obj0, &val1);
9394 if (!SWIG_IsOK(ecode1)) {
9395 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9396 }
9397 arg1 = static_cast< int >(val1);
9398 }
9399 if (obj1) {
9400 ecode2 = SWIG_AsVal_int(obj1, &val2);
9401 if (!SWIG_IsOK(ecode2)) {
9402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9403 }
9404 arg2 = static_cast< int >(val2);
9405 }
9406 {
9407 PyThreadState* __tstate = wxPyBeginAllowThreads();
9408 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9409 wxPyEndAllowThreads(__tstate);
9410 if (PyErr_Occurred()) SWIG_fail;
9411 }
9412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9413 return resultobj;
9414 fail:
9415 return NULL;
9416 }
9417
9418
9419 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9420 PyObject *resultobj = 0;
9421 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9422 void *argp1 = 0 ;
9423 int res1 = 0 ;
9424 PyObject *swig_obj[1] ;
9425
9426 if (!args) SWIG_fail;
9427 swig_obj[0] = args;
9428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9429 if (!SWIG_IsOK(res1)) {
9430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9431 }
9432 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9433 {
9434 PyThreadState* __tstate = wxPyBeginAllowThreads();
9435 delete arg1;
9436
9437 wxPyEndAllowThreads(__tstate);
9438 if (PyErr_Occurred()) SWIG_fail;
9439 }
9440 resultobj = SWIG_Py_Void();
9441 return resultobj;
9442 fail:
9443 return NULL;
9444 }
9445
9446
9447 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9448 PyObject *resultobj = 0;
9449 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9450 wxString *arg2 = 0 ;
9451 void *argp1 = 0 ;
9452 int res1 = 0 ;
9453 bool temp2 = false ;
9454 PyObject * obj0 = 0 ;
9455 PyObject * obj1 = 0 ;
9456 char * kwnames[] = {
9457 (char *) "self",(char *) "file", NULL
9458 };
9459
9460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9462 if (!SWIG_IsOK(res1)) {
9463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9464 }
9465 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9466 {
9467 arg2 = wxString_in_helper(obj1);
9468 if (arg2 == NULL) SWIG_fail;
9469 temp2 = true;
9470 }
9471 {
9472 PyThreadState* __tstate = wxPyBeginAllowThreads();
9473 (arg1)->AddFileToHistory((wxString const &)*arg2);
9474 wxPyEndAllowThreads(__tstate);
9475 if (PyErr_Occurred()) SWIG_fail;
9476 }
9477 resultobj = SWIG_Py_Void();
9478 {
9479 if (temp2)
9480 delete arg2;
9481 }
9482 return resultobj;
9483 fail:
9484 {
9485 if (temp2)
9486 delete arg2;
9487 }
9488 return NULL;
9489 }
9490
9491
9492 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9493 PyObject *resultobj = 0;
9494 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9495 int arg2 ;
9496 void *argp1 = 0 ;
9497 int res1 = 0 ;
9498 int val2 ;
9499 int ecode2 = 0 ;
9500 PyObject * obj0 = 0 ;
9501 PyObject * obj1 = 0 ;
9502 char * kwnames[] = {
9503 (char *) "self",(char *) "i", NULL
9504 };
9505
9506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9508 if (!SWIG_IsOK(res1)) {
9509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9510 }
9511 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9512 ecode2 = SWIG_AsVal_int(obj1, &val2);
9513 if (!SWIG_IsOK(ecode2)) {
9514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9515 }
9516 arg2 = static_cast< int >(val2);
9517 {
9518 PyThreadState* __tstate = wxPyBeginAllowThreads();
9519 (arg1)->RemoveFileFromHistory(arg2);
9520 wxPyEndAllowThreads(__tstate);
9521 if (PyErr_Occurred()) SWIG_fail;
9522 }
9523 resultobj = SWIG_Py_Void();
9524 return resultobj;
9525 fail:
9526 return NULL;
9527 }
9528
9529
9530 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9531 PyObject *resultobj = 0;
9532 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9533 int result;
9534 void *argp1 = 0 ;
9535 int res1 = 0 ;
9536 PyObject *swig_obj[1] ;
9537
9538 if (!args) SWIG_fail;
9539 swig_obj[0] = args;
9540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9541 if (!SWIG_IsOK(res1)) {
9542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9543 }
9544 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9545 {
9546 PyThreadState* __tstate = wxPyBeginAllowThreads();
9547 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9548 wxPyEndAllowThreads(__tstate);
9549 if (PyErr_Occurred()) SWIG_fail;
9550 }
9551 resultobj = SWIG_From_int(static_cast< int >(result));
9552 return resultobj;
9553 fail:
9554 return NULL;
9555 }
9556
9557
9558 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9559 PyObject *resultobj = 0;
9560 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9561 wxMenu *arg2 = (wxMenu *) 0 ;
9562 void *argp1 = 0 ;
9563 int res1 = 0 ;
9564 void *argp2 = 0 ;
9565 int res2 = 0 ;
9566 PyObject * obj0 = 0 ;
9567 PyObject * obj1 = 0 ;
9568 char * kwnames[] = {
9569 (char *) "self",(char *) "menu", NULL
9570 };
9571
9572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9574 if (!SWIG_IsOK(res1)) {
9575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9576 }
9577 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9578 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9579 if (!SWIG_IsOK(res2)) {
9580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9581 }
9582 arg2 = reinterpret_cast< wxMenu * >(argp2);
9583 {
9584 PyThreadState* __tstate = wxPyBeginAllowThreads();
9585 (arg1)->UseMenu(arg2);
9586 wxPyEndAllowThreads(__tstate);
9587 if (PyErr_Occurred()) SWIG_fail;
9588 }
9589 resultobj = SWIG_Py_Void();
9590 return resultobj;
9591 fail:
9592 return NULL;
9593 }
9594
9595
9596 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9597 PyObject *resultobj = 0;
9598 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9599 wxMenu *arg2 = (wxMenu *) 0 ;
9600 void *argp1 = 0 ;
9601 int res1 = 0 ;
9602 void *argp2 = 0 ;
9603 int res2 = 0 ;
9604 PyObject * obj0 = 0 ;
9605 PyObject * obj1 = 0 ;
9606 char * kwnames[] = {
9607 (char *) "self",(char *) "menu", NULL
9608 };
9609
9610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9612 if (!SWIG_IsOK(res1)) {
9613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9614 }
9615 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9616 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9617 if (!SWIG_IsOK(res2)) {
9618 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9619 }
9620 arg2 = reinterpret_cast< wxMenu * >(argp2);
9621 {
9622 PyThreadState* __tstate = wxPyBeginAllowThreads();
9623 (arg1)->RemoveMenu(arg2);
9624 wxPyEndAllowThreads(__tstate);
9625 if (PyErr_Occurred()) SWIG_fail;
9626 }
9627 resultobj = SWIG_Py_Void();
9628 return resultobj;
9629 fail:
9630 return NULL;
9631 }
9632
9633
9634 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9635 PyObject *resultobj = 0;
9636 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9637 wxConfigBase *arg2 = 0 ;
9638 void *argp1 = 0 ;
9639 int res1 = 0 ;
9640 void *argp2 = 0 ;
9641 int res2 = 0 ;
9642 PyObject * obj0 = 0 ;
9643 PyObject * obj1 = 0 ;
9644 char * kwnames[] = {
9645 (char *) "self",(char *) "config", NULL
9646 };
9647
9648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9650 if (!SWIG_IsOK(res1)) {
9651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9652 }
9653 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9654 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9655 if (!SWIG_IsOK(res2)) {
9656 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9657 }
9658 if (!argp2) {
9659 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9660 }
9661 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9662 {
9663 PyThreadState* __tstate = wxPyBeginAllowThreads();
9664 (arg1)->Load(*arg2);
9665 wxPyEndAllowThreads(__tstate);
9666 if (PyErr_Occurred()) SWIG_fail;
9667 }
9668 resultobj = SWIG_Py_Void();
9669 return resultobj;
9670 fail:
9671 return NULL;
9672 }
9673
9674
9675 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9676 PyObject *resultobj = 0;
9677 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9678 wxConfigBase *arg2 = 0 ;
9679 void *argp1 = 0 ;
9680 int res1 = 0 ;
9681 void *argp2 = 0 ;
9682 int res2 = 0 ;
9683 PyObject * obj0 = 0 ;
9684 PyObject * obj1 = 0 ;
9685 char * kwnames[] = {
9686 (char *) "self",(char *) "config", NULL
9687 };
9688
9689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9691 if (!SWIG_IsOK(res1)) {
9692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9693 }
9694 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9695 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9696 if (!SWIG_IsOK(res2)) {
9697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9698 }
9699 if (!argp2) {
9700 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9701 }
9702 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9703 {
9704 PyThreadState* __tstate = wxPyBeginAllowThreads();
9705 (arg1)->Save(*arg2);
9706 wxPyEndAllowThreads(__tstate);
9707 if (PyErr_Occurred()) SWIG_fail;
9708 }
9709 resultobj = SWIG_Py_Void();
9710 return resultobj;
9711 fail:
9712 return NULL;
9713 }
9714
9715
9716 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9717 PyObject *resultobj = 0;
9718 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9719 void *argp1 = 0 ;
9720 int res1 = 0 ;
9721 PyObject *swig_obj[1] ;
9722
9723 if (!args) SWIG_fail;
9724 swig_obj[0] = args;
9725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9726 if (!SWIG_IsOK(res1)) {
9727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9728 }
9729 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9730 {
9731 PyThreadState* __tstate = wxPyBeginAllowThreads();
9732 (arg1)->AddFilesToMenu();
9733 wxPyEndAllowThreads(__tstate);
9734 if (PyErr_Occurred()) SWIG_fail;
9735 }
9736 resultobj = SWIG_Py_Void();
9737 return resultobj;
9738 fail:
9739 return NULL;
9740 }
9741
9742
9743 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9744 PyObject *resultobj = 0;
9745 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9746 wxMenu *arg2 = (wxMenu *) 0 ;
9747 void *argp1 = 0 ;
9748 int res1 = 0 ;
9749 void *argp2 = 0 ;
9750 int res2 = 0 ;
9751 PyObject * obj0 = 0 ;
9752 PyObject * obj1 = 0 ;
9753 char * kwnames[] = {
9754 (char *) "self",(char *) "menu", NULL
9755 };
9756
9757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9759 if (!SWIG_IsOK(res1)) {
9760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9761 }
9762 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9763 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9764 if (!SWIG_IsOK(res2)) {
9765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9766 }
9767 arg2 = reinterpret_cast< wxMenu * >(argp2);
9768 {
9769 PyThreadState* __tstate = wxPyBeginAllowThreads();
9770 (arg1)->AddFilesToMenu(arg2);
9771 wxPyEndAllowThreads(__tstate);
9772 if (PyErr_Occurred()) SWIG_fail;
9773 }
9774 resultobj = SWIG_Py_Void();
9775 return resultobj;
9776 fail:
9777 return NULL;
9778 }
9779
9780
9781 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9782 PyObject *resultobj = 0;
9783 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9784 int arg2 ;
9785 wxString result;
9786 void *argp1 = 0 ;
9787 int res1 = 0 ;
9788 int val2 ;
9789 int ecode2 = 0 ;
9790 PyObject * obj0 = 0 ;
9791 PyObject * obj1 = 0 ;
9792 char * kwnames[] = {
9793 (char *) "self",(char *) "i", NULL
9794 };
9795
9796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9798 if (!SWIG_IsOK(res1)) {
9799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9800 }
9801 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9802 ecode2 = SWIG_AsVal_int(obj1, &val2);
9803 if (!SWIG_IsOK(ecode2)) {
9804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9805 }
9806 arg2 = static_cast< int >(val2);
9807 {
9808 PyThreadState* __tstate = wxPyBeginAllowThreads();
9809 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9810 wxPyEndAllowThreads(__tstate);
9811 if (PyErr_Occurred()) SWIG_fail;
9812 }
9813 {
9814 #if wxUSE_UNICODE
9815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9816 #else
9817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9818 #endif
9819 }
9820 return resultobj;
9821 fail:
9822 return NULL;
9823 }
9824
9825
9826 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9827 PyObject *resultobj = 0;
9828 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9829 int result;
9830 void *argp1 = 0 ;
9831 int res1 = 0 ;
9832 PyObject *swig_obj[1] ;
9833
9834 if (!args) SWIG_fail;
9835 swig_obj[0] = args;
9836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9837 if (!SWIG_IsOK(res1)) {
9838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9839 }
9840 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9841 {
9842 PyThreadState* __tstate = wxPyBeginAllowThreads();
9843 result = (int)((wxFileHistory const *)arg1)->GetCount();
9844 wxPyEndAllowThreads(__tstate);
9845 if (PyErr_Occurred()) SWIG_fail;
9846 }
9847 resultobj = SWIG_From_int(static_cast< int >(result));
9848 return resultobj;
9849 fail:
9850 return NULL;
9851 }
9852
9853
9854 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9855 PyObject *obj;
9856 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9857 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9858 return SWIG_Py_Void();
9859 }
9860
9861 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9862 return SWIG_Python_InitShadowInstance(args);
9863 }
9864
9865 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9866 PyObject *resultobj = 0;
9867 wxString *arg1 = 0 ;
9868 wxString const &arg2_defvalue = wxPyEmptyString ;
9869 wxString *arg2 = (wxString *) &arg2_defvalue ;
9870 wxSingleInstanceChecker *result = 0 ;
9871 bool temp1 = false ;
9872 bool temp2 = false ;
9873 PyObject * obj0 = 0 ;
9874 PyObject * obj1 = 0 ;
9875 char * kwnames[] = {
9876 (char *) "name",(char *) "path", NULL
9877 };
9878
9879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9880 {
9881 arg1 = wxString_in_helper(obj0);
9882 if (arg1 == NULL) SWIG_fail;
9883 temp1 = true;
9884 }
9885 if (obj1) {
9886 {
9887 arg2 = wxString_in_helper(obj1);
9888 if (arg2 == NULL) SWIG_fail;
9889 temp2 = true;
9890 }
9891 }
9892 {
9893 PyThreadState* __tstate = wxPyBeginAllowThreads();
9894 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9895 wxPyEndAllowThreads(__tstate);
9896 if (PyErr_Occurred()) SWIG_fail;
9897 }
9898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9899 {
9900 if (temp1)
9901 delete arg1;
9902 }
9903 {
9904 if (temp2)
9905 delete arg2;
9906 }
9907 return resultobj;
9908 fail:
9909 {
9910 if (temp1)
9911 delete arg1;
9912 }
9913 {
9914 if (temp2)
9915 delete arg2;
9916 }
9917 return NULL;
9918 }
9919
9920
9921 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9922 PyObject *resultobj = 0;
9923 wxSingleInstanceChecker *result = 0 ;
9924
9925 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9926 {
9927 PyThreadState* __tstate = wxPyBeginAllowThreads();
9928 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9929 wxPyEndAllowThreads(__tstate);
9930 if (PyErr_Occurred()) SWIG_fail;
9931 }
9932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9933 return resultobj;
9934 fail:
9935 return NULL;
9936 }
9937
9938
9939 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9940 PyObject *resultobj = 0;
9941 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9942 void *argp1 = 0 ;
9943 int res1 = 0 ;
9944 PyObject *swig_obj[1] ;
9945
9946 if (!args) SWIG_fail;
9947 swig_obj[0] = args;
9948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9949 if (!SWIG_IsOK(res1)) {
9950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9951 }
9952 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9953 {
9954 PyThreadState* __tstate = wxPyBeginAllowThreads();
9955 delete arg1;
9956
9957 wxPyEndAllowThreads(__tstate);
9958 if (PyErr_Occurred()) SWIG_fail;
9959 }
9960 resultobj = SWIG_Py_Void();
9961 return resultobj;
9962 fail:
9963 return NULL;
9964 }
9965
9966
9967 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9968 PyObject *resultobj = 0;
9969 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9970 wxString *arg2 = 0 ;
9971 wxString const &arg3_defvalue = wxPyEmptyString ;
9972 wxString *arg3 = (wxString *) &arg3_defvalue ;
9973 bool result;
9974 void *argp1 = 0 ;
9975 int res1 = 0 ;
9976 bool temp2 = false ;
9977 bool temp3 = false ;
9978 PyObject * obj0 = 0 ;
9979 PyObject * obj1 = 0 ;
9980 PyObject * obj2 = 0 ;
9981 char * kwnames[] = {
9982 (char *) "self",(char *) "name",(char *) "path", NULL
9983 };
9984
9985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9987 if (!SWIG_IsOK(res1)) {
9988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9989 }
9990 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9991 {
9992 arg2 = wxString_in_helper(obj1);
9993 if (arg2 == NULL) SWIG_fail;
9994 temp2 = true;
9995 }
9996 if (obj2) {
9997 {
9998 arg3 = wxString_in_helper(obj2);
9999 if (arg3 == NULL) SWIG_fail;
10000 temp3 = true;
10001 }
10002 }
10003 {
10004 PyThreadState* __tstate = wxPyBeginAllowThreads();
10005 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10006 wxPyEndAllowThreads(__tstate);
10007 if (PyErr_Occurred()) SWIG_fail;
10008 }
10009 {
10010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10011 }
10012 {
10013 if (temp2)
10014 delete arg2;
10015 }
10016 {
10017 if (temp3)
10018 delete arg3;
10019 }
10020 return resultobj;
10021 fail:
10022 {
10023 if (temp2)
10024 delete arg2;
10025 }
10026 {
10027 if (temp3)
10028 delete arg3;
10029 }
10030 return NULL;
10031 }
10032
10033
10034 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10035 PyObject *resultobj = 0;
10036 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10037 bool result;
10038 void *argp1 = 0 ;
10039 int res1 = 0 ;
10040 PyObject *swig_obj[1] ;
10041
10042 if (!args) SWIG_fail;
10043 swig_obj[0] = args;
10044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10045 if (!SWIG_IsOK(res1)) {
10046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10047 }
10048 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10049 {
10050 PyThreadState* __tstate = wxPyBeginAllowThreads();
10051 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10052 wxPyEndAllowThreads(__tstate);
10053 if (PyErr_Occurred()) SWIG_fail;
10054 }
10055 {
10056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10057 }
10058 return resultobj;
10059 fail:
10060 return NULL;
10061 }
10062
10063
10064 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10065 PyObject *obj;
10066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10067 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10068 return SWIG_Py_Void();
10069 }
10070
10071 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10072 return SWIG_Python_InitShadowInstance(args);
10073 }
10074
10075 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10076 PyObject *resultobj = 0;
10077 wxPlatformInfo *result = 0 ;
10078
10079 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10080 {
10081 PyThreadState* __tstate = wxPyBeginAllowThreads();
10082 result = (wxPlatformInfo *)new wxPlatformInfo();
10083 wxPyEndAllowThreads(__tstate);
10084 if (PyErr_Occurred()) SWIG_fail;
10085 }
10086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10087 return resultobj;
10088 fail:
10089 return NULL;
10090 }
10091
10092
10093 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10094 PyObject *resultobj = 0;
10095 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10096 wxPlatformInfo *arg2 = 0 ;
10097 bool result;
10098 void *argp1 = 0 ;
10099 int res1 = 0 ;
10100 void *argp2 = 0 ;
10101 int res2 = 0 ;
10102 PyObject * obj0 = 0 ;
10103 PyObject * obj1 = 0 ;
10104 char * kwnames[] = {
10105 (char *) "self",(char *) "t", NULL
10106 };
10107
10108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10110 if (!SWIG_IsOK(res1)) {
10111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10112 }
10113 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10114 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10115 if (!SWIG_IsOK(res2)) {
10116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10117 }
10118 if (!argp2) {
10119 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10120 }
10121 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10122 {
10123 PyThreadState* __tstate = wxPyBeginAllowThreads();
10124 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10125 wxPyEndAllowThreads(__tstate);
10126 if (PyErr_Occurred()) SWIG_fail;
10127 }
10128 {
10129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10130 }
10131 return resultobj;
10132 fail:
10133 return NULL;
10134 }
10135
10136
10137 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10138 PyObject *resultobj = 0;
10139 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10140 wxPlatformInfo *arg2 = 0 ;
10141 bool result;
10142 void *argp1 = 0 ;
10143 int res1 = 0 ;
10144 void *argp2 = 0 ;
10145 int res2 = 0 ;
10146 PyObject * obj0 = 0 ;
10147 PyObject * obj1 = 0 ;
10148 char * kwnames[] = {
10149 (char *) "self",(char *) "t", NULL
10150 };
10151
10152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10154 if (!SWIG_IsOK(res1)) {
10155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10156 }
10157 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10158 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10159 if (!SWIG_IsOK(res2)) {
10160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10161 }
10162 if (!argp2) {
10163 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10164 }
10165 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10166 {
10167 PyThreadState* __tstate = wxPyBeginAllowThreads();
10168 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10169 wxPyEndAllowThreads(__tstate);
10170 if (PyErr_Occurred()) SWIG_fail;
10171 }
10172 {
10173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10174 }
10175 return resultobj;
10176 fail:
10177 return NULL;
10178 }
10179
10180
10181 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10182 PyObject *resultobj = 0;
10183 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10184 int result;
10185 void *argp1 = 0 ;
10186 int res1 = 0 ;
10187 PyObject *swig_obj[1] ;
10188
10189 if (!args) SWIG_fail;
10190 swig_obj[0] = args;
10191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10192 if (!SWIG_IsOK(res1)) {
10193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10194 }
10195 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10196 {
10197 PyThreadState* __tstate = wxPyBeginAllowThreads();
10198 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10199 wxPyEndAllowThreads(__tstate);
10200 if (PyErr_Occurred()) SWIG_fail;
10201 }
10202 resultobj = SWIG_From_int(static_cast< int >(result));
10203 return resultobj;
10204 fail:
10205 return NULL;
10206 }
10207
10208
10209 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10210 PyObject *resultobj = 0;
10211 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10212 int result;
10213 void *argp1 = 0 ;
10214 int res1 = 0 ;
10215 PyObject *swig_obj[1] ;
10216
10217 if (!args) SWIG_fail;
10218 swig_obj[0] = args;
10219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10220 if (!SWIG_IsOK(res1)) {
10221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10222 }
10223 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10224 {
10225 PyThreadState* __tstate = wxPyBeginAllowThreads();
10226 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10227 wxPyEndAllowThreads(__tstate);
10228 if (PyErr_Occurred()) SWIG_fail;
10229 }
10230 resultobj = SWIG_From_int(static_cast< int >(result));
10231 return resultobj;
10232 fail:
10233 return NULL;
10234 }
10235
10236
10237 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10238 PyObject *resultobj = 0;
10239 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10240 int result;
10241 void *argp1 = 0 ;
10242 int res1 = 0 ;
10243 PyObject *swig_obj[1] ;
10244
10245 if (!args) SWIG_fail;
10246 swig_obj[0] = args;
10247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10248 if (!SWIG_IsOK(res1)) {
10249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10250 }
10251 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10252 {
10253 PyThreadState* __tstate = wxPyBeginAllowThreads();
10254 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10255 wxPyEndAllowThreads(__tstate);
10256 if (PyErr_Occurred()) SWIG_fail;
10257 }
10258 resultobj = SWIG_From_int(static_cast< int >(result));
10259 return resultobj;
10260 fail:
10261 return NULL;
10262 }
10263
10264
10265 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10266 PyObject *resultobj = 0;
10267 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10268 int result;
10269 void *argp1 = 0 ;
10270 int res1 = 0 ;
10271 PyObject *swig_obj[1] ;
10272
10273 if (!args) SWIG_fail;
10274 swig_obj[0] = args;
10275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10276 if (!SWIG_IsOK(res1)) {
10277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10278 }
10279 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10280 {
10281 PyThreadState* __tstate = wxPyBeginAllowThreads();
10282 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10283 wxPyEndAllowThreads(__tstate);
10284 if (PyErr_Occurred()) SWIG_fail;
10285 }
10286 resultobj = SWIG_From_int(static_cast< int >(result));
10287 return resultobj;
10288 fail:
10289 return NULL;
10290 }
10291
10292
10293 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10294 PyObject *resultobj = 0;
10295 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10296 bool result;
10297 void *argp1 = 0 ;
10298 int res1 = 0 ;
10299 PyObject *swig_obj[1] ;
10300
10301 if (!args) SWIG_fail;
10302 swig_obj[0] = args;
10303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10304 if (!SWIG_IsOK(res1)) {
10305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10306 }
10307 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10308 {
10309 PyThreadState* __tstate = wxPyBeginAllowThreads();
10310 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10311 wxPyEndAllowThreads(__tstate);
10312 if (PyErr_Occurred()) SWIG_fail;
10313 }
10314 {
10315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10316 }
10317 return resultobj;
10318 fail:
10319 return NULL;
10320 }
10321
10322
10323 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10324 PyObject *resultobj = 0;
10325 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10326 wxOperatingSystemId result;
10327 void *argp1 = 0 ;
10328 int res1 = 0 ;
10329 PyObject *swig_obj[1] ;
10330
10331 if (!args) SWIG_fail;
10332 swig_obj[0] = args;
10333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10334 if (!SWIG_IsOK(res1)) {
10335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10336 }
10337 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10338 {
10339 PyThreadState* __tstate = wxPyBeginAllowThreads();
10340 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10341 wxPyEndAllowThreads(__tstate);
10342 if (PyErr_Occurred()) SWIG_fail;
10343 }
10344 resultobj = SWIG_From_int(static_cast< int >(result));
10345 return resultobj;
10346 fail:
10347 return NULL;
10348 }
10349
10350
10351 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10352 PyObject *resultobj = 0;
10353 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10354 wxPortId result;
10355 void *argp1 = 0 ;
10356 int res1 = 0 ;
10357 PyObject *swig_obj[1] ;
10358
10359 if (!args) SWIG_fail;
10360 swig_obj[0] = args;
10361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10362 if (!SWIG_IsOK(res1)) {
10363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10364 }
10365 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10366 {
10367 PyThreadState* __tstate = wxPyBeginAllowThreads();
10368 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10369 wxPyEndAllowThreads(__tstate);
10370 if (PyErr_Occurred()) SWIG_fail;
10371 }
10372 resultobj = SWIG_From_int(static_cast< int >(result));
10373 return resultobj;
10374 fail:
10375 return NULL;
10376 }
10377
10378
10379 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10380 PyObject *resultobj = 0;
10381 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10382 wxArchitecture result;
10383 void *argp1 = 0 ;
10384 int res1 = 0 ;
10385 PyObject *swig_obj[1] ;
10386
10387 if (!args) SWIG_fail;
10388 swig_obj[0] = args;
10389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10390 if (!SWIG_IsOK(res1)) {
10391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10392 }
10393 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10394 {
10395 PyThreadState* __tstate = wxPyBeginAllowThreads();
10396 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10397 wxPyEndAllowThreads(__tstate);
10398 if (PyErr_Occurred()) SWIG_fail;
10399 }
10400 resultobj = SWIG_From_int(static_cast< int >(result));
10401 return resultobj;
10402 fail:
10403 return NULL;
10404 }
10405
10406
10407 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10408 PyObject *resultobj = 0;
10409 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10410 wxEndianness result;
10411 void *argp1 = 0 ;
10412 int res1 = 0 ;
10413 PyObject *swig_obj[1] ;
10414
10415 if (!args) SWIG_fail;
10416 swig_obj[0] = args;
10417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10418 if (!SWIG_IsOK(res1)) {
10419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10420 }
10421 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10422 {
10423 PyThreadState* __tstate = wxPyBeginAllowThreads();
10424 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10425 wxPyEndAllowThreads(__tstate);
10426 if (PyErr_Occurred()) SWIG_fail;
10427 }
10428 resultobj = SWIG_From_int(static_cast< int >(result));
10429 return resultobj;
10430 fail:
10431 return NULL;
10432 }
10433
10434
10435 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10436 PyObject *resultobj = 0;
10437 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10438 wxString result;
10439 void *argp1 = 0 ;
10440 int res1 = 0 ;
10441 PyObject *swig_obj[1] ;
10442
10443 if (!args) SWIG_fail;
10444 swig_obj[0] = args;
10445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10446 if (!SWIG_IsOK(res1)) {
10447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10448 }
10449 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10450 {
10451 PyThreadState* __tstate = wxPyBeginAllowThreads();
10452 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10453 wxPyEndAllowThreads(__tstate);
10454 if (PyErr_Occurred()) SWIG_fail;
10455 }
10456 {
10457 #if wxUSE_UNICODE
10458 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10459 #else
10460 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10461 #endif
10462 }
10463 return resultobj;
10464 fail:
10465 return NULL;
10466 }
10467
10468
10469 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10470 PyObject *resultobj = 0;
10471 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10472 wxString result;
10473 void *argp1 = 0 ;
10474 int res1 = 0 ;
10475 PyObject *swig_obj[1] ;
10476
10477 if (!args) SWIG_fail;
10478 swig_obj[0] = args;
10479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10480 if (!SWIG_IsOK(res1)) {
10481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10482 }
10483 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10484 {
10485 PyThreadState* __tstate = wxPyBeginAllowThreads();
10486 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10487 wxPyEndAllowThreads(__tstate);
10488 if (PyErr_Occurred()) SWIG_fail;
10489 }
10490 {
10491 #if wxUSE_UNICODE
10492 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10493 #else
10494 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10495 #endif
10496 }
10497 return resultobj;
10498 fail:
10499 return NULL;
10500 }
10501
10502
10503 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10504 PyObject *resultobj = 0;
10505 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10506 wxString result;
10507 void *argp1 = 0 ;
10508 int res1 = 0 ;
10509 PyObject *swig_obj[1] ;
10510
10511 if (!args) SWIG_fail;
10512 swig_obj[0] = args;
10513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10514 if (!SWIG_IsOK(res1)) {
10515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10516 }
10517 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10518 {
10519 PyThreadState* __tstate = wxPyBeginAllowThreads();
10520 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10521 wxPyEndAllowThreads(__tstate);
10522 if (PyErr_Occurred()) SWIG_fail;
10523 }
10524 {
10525 #if wxUSE_UNICODE
10526 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10527 #else
10528 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10529 #endif
10530 }
10531 return resultobj;
10532 fail:
10533 return NULL;
10534 }
10535
10536
10537 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10538 PyObject *resultobj = 0;
10539 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10540 wxString result;
10541 void *argp1 = 0 ;
10542 int res1 = 0 ;
10543 PyObject *swig_obj[1] ;
10544
10545 if (!args) SWIG_fail;
10546 swig_obj[0] = args;
10547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10548 if (!SWIG_IsOK(res1)) {
10549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10550 }
10551 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10552 {
10553 PyThreadState* __tstate = wxPyBeginAllowThreads();
10554 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10555 wxPyEndAllowThreads(__tstate);
10556 if (PyErr_Occurred()) SWIG_fail;
10557 }
10558 {
10559 #if wxUSE_UNICODE
10560 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10561 #else
10562 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10563 #endif
10564 }
10565 return resultobj;
10566 fail:
10567 return NULL;
10568 }
10569
10570
10571 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10572 PyObject *resultobj = 0;
10573 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10574 wxString result;
10575 void *argp1 = 0 ;
10576 int res1 = 0 ;
10577 PyObject *swig_obj[1] ;
10578
10579 if (!args) SWIG_fail;
10580 swig_obj[0] = args;
10581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10582 if (!SWIG_IsOK(res1)) {
10583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10584 }
10585 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10586 {
10587 PyThreadState* __tstate = wxPyBeginAllowThreads();
10588 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10589 wxPyEndAllowThreads(__tstate);
10590 if (PyErr_Occurred()) SWIG_fail;
10591 }
10592 {
10593 #if wxUSE_UNICODE
10594 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10595 #else
10596 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10597 #endif
10598 }
10599 return resultobj;
10600 fail:
10601 return NULL;
10602 }
10603
10604
10605 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10606 PyObject *resultobj = 0;
10607 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10608 wxString result;
10609 void *argp1 = 0 ;
10610 int res1 = 0 ;
10611 PyObject *swig_obj[1] ;
10612
10613 if (!args) SWIG_fail;
10614 swig_obj[0] = args;
10615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10616 if (!SWIG_IsOK(res1)) {
10617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10618 }
10619 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10620 {
10621 PyThreadState* __tstate = wxPyBeginAllowThreads();
10622 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10623 wxPyEndAllowThreads(__tstate);
10624 if (PyErr_Occurred()) SWIG_fail;
10625 }
10626 {
10627 #if wxUSE_UNICODE
10628 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10629 #else
10630 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10631 #endif
10632 }
10633 return resultobj;
10634 fail:
10635 return NULL;
10636 }
10637
10638
10639 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10640 PyObject *resultobj = 0;
10641 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10642 int arg2 ;
10643 int arg3 ;
10644 void *argp1 = 0 ;
10645 int res1 = 0 ;
10646 int val2 ;
10647 int ecode2 = 0 ;
10648 int val3 ;
10649 int ecode3 = 0 ;
10650 PyObject * obj0 = 0 ;
10651 PyObject * obj1 = 0 ;
10652 PyObject * obj2 = 0 ;
10653 char * kwnames[] = {
10654 (char *) "self",(char *) "major",(char *) "minor", NULL
10655 };
10656
10657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10659 if (!SWIG_IsOK(res1)) {
10660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10661 }
10662 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10663 ecode2 = SWIG_AsVal_int(obj1, &val2);
10664 if (!SWIG_IsOK(ecode2)) {
10665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10666 }
10667 arg2 = static_cast< int >(val2);
10668 ecode3 = SWIG_AsVal_int(obj2, &val3);
10669 if (!SWIG_IsOK(ecode3)) {
10670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10671 }
10672 arg3 = static_cast< int >(val3);
10673 {
10674 PyThreadState* __tstate = wxPyBeginAllowThreads();
10675 (arg1)->SetOSVersion(arg2,arg3);
10676 wxPyEndAllowThreads(__tstate);
10677 if (PyErr_Occurred()) SWIG_fail;
10678 }
10679 resultobj = SWIG_Py_Void();
10680 return resultobj;
10681 fail:
10682 return NULL;
10683 }
10684
10685
10686 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10687 PyObject *resultobj = 0;
10688 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10689 int arg2 ;
10690 int arg3 ;
10691 void *argp1 = 0 ;
10692 int res1 = 0 ;
10693 int val2 ;
10694 int ecode2 = 0 ;
10695 int val3 ;
10696 int ecode3 = 0 ;
10697 PyObject * obj0 = 0 ;
10698 PyObject * obj1 = 0 ;
10699 PyObject * obj2 = 0 ;
10700 char * kwnames[] = {
10701 (char *) "self",(char *) "major",(char *) "minor", NULL
10702 };
10703
10704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10706 if (!SWIG_IsOK(res1)) {
10707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10708 }
10709 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10710 ecode2 = SWIG_AsVal_int(obj1, &val2);
10711 if (!SWIG_IsOK(ecode2)) {
10712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10713 }
10714 arg2 = static_cast< int >(val2);
10715 ecode3 = SWIG_AsVal_int(obj2, &val3);
10716 if (!SWIG_IsOK(ecode3)) {
10717 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10718 }
10719 arg3 = static_cast< int >(val3);
10720 {
10721 PyThreadState* __tstate = wxPyBeginAllowThreads();
10722 (arg1)->SetToolkitVersion(arg2,arg3);
10723 wxPyEndAllowThreads(__tstate);
10724 if (PyErr_Occurred()) SWIG_fail;
10725 }
10726 resultobj = SWIG_Py_Void();
10727 return resultobj;
10728 fail:
10729 return NULL;
10730 }
10731
10732
10733 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10734 PyObject *resultobj = 0;
10735 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10736 wxOperatingSystemId arg2 ;
10737 void *argp1 = 0 ;
10738 int res1 = 0 ;
10739 int val2 ;
10740 int ecode2 = 0 ;
10741 PyObject * obj0 = 0 ;
10742 PyObject * obj1 = 0 ;
10743 char * kwnames[] = {
10744 (char *) "self",(char *) "n", NULL
10745 };
10746
10747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10749 if (!SWIG_IsOK(res1)) {
10750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10751 }
10752 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10753 ecode2 = SWIG_AsVal_int(obj1, &val2);
10754 if (!SWIG_IsOK(ecode2)) {
10755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10756 }
10757 arg2 = static_cast< wxOperatingSystemId >(val2);
10758 {
10759 PyThreadState* __tstate = wxPyBeginAllowThreads();
10760 (arg1)->SetOperatingSystemId(arg2);
10761 wxPyEndAllowThreads(__tstate);
10762 if (PyErr_Occurred()) SWIG_fail;
10763 }
10764 resultobj = SWIG_Py_Void();
10765 return resultobj;
10766 fail:
10767 return NULL;
10768 }
10769
10770
10771 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10772 PyObject *resultobj = 0;
10773 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10774 wxPortId arg2 ;
10775 void *argp1 = 0 ;
10776 int res1 = 0 ;
10777 int val2 ;
10778 int ecode2 = 0 ;
10779 PyObject * obj0 = 0 ;
10780 PyObject * obj1 = 0 ;
10781 char * kwnames[] = {
10782 (char *) "self",(char *) "n", NULL
10783 };
10784
10785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10787 if (!SWIG_IsOK(res1)) {
10788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10789 }
10790 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10791 ecode2 = SWIG_AsVal_int(obj1, &val2);
10792 if (!SWIG_IsOK(ecode2)) {
10793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10794 }
10795 arg2 = static_cast< wxPortId >(val2);
10796 {
10797 PyThreadState* __tstate = wxPyBeginAllowThreads();
10798 (arg1)->SetPortId(arg2);
10799 wxPyEndAllowThreads(__tstate);
10800 if (PyErr_Occurred()) SWIG_fail;
10801 }
10802 resultobj = SWIG_Py_Void();
10803 return resultobj;
10804 fail:
10805 return NULL;
10806 }
10807
10808
10809 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10810 PyObject *resultobj = 0;
10811 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10812 wxArchitecture arg2 ;
10813 void *argp1 = 0 ;
10814 int res1 = 0 ;
10815 int val2 ;
10816 int ecode2 = 0 ;
10817 PyObject * obj0 = 0 ;
10818 PyObject * obj1 = 0 ;
10819 char * kwnames[] = {
10820 (char *) "self",(char *) "n", NULL
10821 };
10822
10823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10825 if (!SWIG_IsOK(res1)) {
10826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10827 }
10828 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10829 ecode2 = SWIG_AsVal_int(obj1, &val2);
10830 if (!SWIG_IsOK(ecode2)) {
10831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
10832 }
10833 arg2 = static_cast< wxArchitecture >(val2);
10834 {
10835 PyThreadState* __tstate = wxPyBeginAllowThreads();
10836 (arg1)->SetArchitecture(arg2);
10837 wxPyEndAllowThreads(__tstate);
10838 if (PyErr_Occurred()) SWIG_fail;
10839 }
10840 resultobj = SWIG_Py_Void();
10841 return resultobj;
10842 fail:
10843 return NULL;
10844 }
10845
10846
10847 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10848 PyObject *resultobj = 0;
10849 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10850 wxEndianness arg2 ;
10851 void *argp1 = 0 ;
10852 int res1 = 0 ;
10853 int val2 ;
10854 int ecode2 = 0 ;
10855 PyObject * obj0 = 0 ;
10856 PyObject * obj1 = 0 ;
10857 char * kwnames[] = {
10858 (char *) "self",(char *) "n", NULL
10859 };
10860
10861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
10862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10863 if (!SWIG_IsOK(res1)) {
10864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10865 }
10866 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10867 ecode2 = SWIG_AsVal_int(obj1, &val2);
10868 if (!SWIG_IsOK(ecode2)) {
10869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
10870 }
10871 arg2 = static_cast< wxEndianness >(val2);
10872 {
10873 PyThreadState* __tstate = wxPyBeginAllowThreads();
10874 (arg1)->SetEndianness(arg2);
10875 wxPyEndAllowThreads(__tstate);
10876 if (PyErr_Occurred()) SWIG_fail;
10877 }
10878 resultobj = SWIG_Py_Void();
10879 return resultobj;
10880 fail:
10881 return NULL;
10882 }
10883
10884
10885 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10886 PyObject *resultobj = 0;
10887 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10888 bool result;
10889 void *argp1 = 0 ;
10890 int res1 = 0 ;
10891 PyObject *swig_obj[1] ;
10892
10893 if (!args) SWIG_fail;
10894 swig_obj[0] = args;
10895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10896 if (!SWIG_IsOK(res1)) {
10897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10898 }
10899 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10900 {
10901 PyThreadState* __tstate = wxPyBeginAllowThreads();
10902 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
10903 wxPyEndAllowThreads(__tstate);
10904 if (PyErr_Occurred()) SWIG_fail;
10905 }
10906 {
10907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10908 }
10909 return resultobj;
10910 fail:
10911 return NULL;
10912 }
10913
10914
10915 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10916 PyObject *obj;
10917 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10918 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
10919 return SWIG_Py_Void();
10920 }
10921
10922 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10923 return SWIG_Python_InitShadowInstance(args);
10924 }
10925
10926 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10927 PyObject *resultobj = 0;
10928 wxWindow *arg1 = (wxWindow *) 0 ;
10929 wxDC *arg2 = 0 ;
10930 bool result;
10931 void *argp1 = 0 ;
10932 int res1 = 0 ;
10933 void *argp2 = 0 ;
10934 int res2 = 0 ;
10935 PyObject * obj0 = 0 ;
10936 PyObject * obj1 = 0 ;
10937 char * kwnames[] = {
10938 (char *) "window",(char *) "dc", NULL
10939 };
10940
10941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
10942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10943 if (!SWIG_IsOK(res1)) {
10944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
10945 }
10946 arg1 = reinterpret_cast< wxWindow * >(argp1);
10947 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
10948 if (!SWIG_IsOK(res2)) {
10949 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10950 }
10951 if (!argp2) {
10952 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10953 }
10954 arg2 = reinterpret_cast< wxDC * >(argp2);
10955 {
10956 PyThreadState* __tstate = wxPyBeginAllowThreads();
10957 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
10958 wxPyEndAllowThreads(__tstate);
10959 if (PyErr_Occurred()) SWIG_fail;
10960 }
10961 {
10962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10963 }
10964 return resultobj;
10965 fail:
10966 return NULL;
10967 }
10968
10969
10970 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10971 PyObject *resultobj = 0;
10972 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10973 void *argp1 = 0 ;
10974 int res1 = 0 ;
10975 PyObject *swig_obj[1] ;
10976
10977 if (!args) SWIG_fail;
10978 swig_obj[0] = args;
10979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
10980 if (!SWIG_IsOK(res1)) {
10981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10982 }
10983 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10984 {
10985 PyThreadState* __tstate = wxPyBeginAllowThreads();
10986 delete arg1;
10987
10988 wxPyEndAllowThreads(__tstate);
10989 if (PyErr_Occurred()) SWIG_fail;
10990 }
10991 resultobj = SWIG_Py_Void();
10992 return resultobj;
10993 fail:
10994 return NULL;
10995 }
10996
10997
10998 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10999 PyObject *resultobj = 0;
11000 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11001 wxString result;
11002 void *argp1 = 0 ;
11003 int res1 = 0 ;
11004 PyObject *swig_obj[1] ;
11005
11006 if (!args) SWIG_fail;
11007 swig_obj[0] = args;
11008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11009 if (!SWIG_IsOK(res1)) {
11010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11011 }
11012 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11013 {
11014 PyThreadState* __tstate = wxPyBeginAllowThreads();
11015 result = (arg1)->GetTip();
11016 wxPyEndAllowThreads(__tstate);
11017 if (PyErr_Occurred()) SWIG_fail;
11018 }
11019 {
11020 #if wxUSE_UNICODE
11021 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11022 #else
11023 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11024 #endif
11025 }
11026 return resultobj;
11027 fail:
11028 return NULL;
11029 }
11030
11031
11032 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11033 PyObject *resultobj = 0;
11034 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11035 size_t result;
11036 void *argp1 = 0 ;
11037 int res1 = 0 ;
11038 PyObject *swig_obj[1] ;
11039
11040 if (!args) SWIG_fail;
11041 swig_obj[0] = args;
11042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11043 if (!SWIG_IsOK(res1)) {
11044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11045 }
11046 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11047 {
11048 PyThreadState* __tstate = wxPyBeginAllowThreads();
11049 result = (size_t)(arg1)->GetCurrentTip();
11050 wxPyEndAllowThreads(__tstate);
11051 if (PyErr_Occurred()) SWIG_fail;
11052 }
11053 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11054 return resultobj;
11055 fail:
11056 return NULL;
11057 }
11058
11059
11060 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11061 PyObject *resultobj = 0;
11062 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11063 wxString *arg2 = 0 ;
11064 wxString result;
11065 void *argp1 = 0 ;
11066 int res1 = 0 ;
11067 bool temp2 = false ;
11068 PyObject * obj0 = 0 ;
11069 PyObject * obj1 = 0 ;
11070 char * kwnames[] = {
11071 (char *) "self",(char *) "tip", NULL
11072 };
11073
11074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11076 if (!SWIG_IsOK(res1)) {
11077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11078 }
11079 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11080 {
11081 arg2 = wxString_in_helper(obj1);
11082 if (arg2 == NULL) SWIG_fail;
11083 temp2 = true;
11084 }
11085 {
11086 PyThreadState* __tstate = wxPyBeginAllowThreads();
11087 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11088 wxPyEndAllowThreads(__tstate);
11089 if (PyErr_Occurred()) SWIG_fail;
11090 }
11091 {
11092 #if wxUSE_UNICODE
11093 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11094 #else
11095 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11096 #endif
11097 }
11098 {
11099 if (temp2)
11100 delete arg2;
11101 }
11102 return resultobj;
11103 fail:
11104 {
11105 if (temp2)
11106 delete arg2;
11107 }
11108 return NULL;
11109 }
11110
11111
11112 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11113 PyObject *obj;
11114 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11115 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11116 return SWIG_Py_Void();
11117 }
11118
11119 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11120 PyObject *resultobj = 0;
11121 size_t arg1 ;
11122 wxPyTipProvider *result = 0 ;
11123 size_t val1 ;
11124 int ecode1 = 0 ;
11125 PyObject * obj0 = 0 ;
11126 char * kwnames[] = {
11127 (char *) "currentTip", NULL
11128 };
11129
11130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11131 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11132 if (!SWIG_IsOK(ecode1)) {
11133 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11134 }
11135 arg1 = static_cast< size_t >(val1);
11136 {
11137 PyThreadState* __tstate = wxPyBeginAllowThreads();
11138 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11139 wxPyEndAllowThreads(__tstate);
11140 if (PyErr_Occurred()) SWIG_fail;
11141 }
11142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11143 return resultobj;
11144 fail:
11145 return NULL;
11146 }
11147
11148
11149 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11150 PyObject *resultobj = 0;
11151 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11152 PyObject *arg2 = (PyObject *) 0 ;
11153 PyObject *arg3 = (PyObject *) 0 ;
11154 void *argp1 = 0 ;
11155 int res1 = 0 ;
11156 PyObject * obj0 = 0 ;
11157 PyObject * obj1 = 0 ;
11158 PyObject * obj2 = 0 ;
11159 char * kwnames[] = {
11160 (char *) "self",(char *) "self",(char *) "_class", NULL
11161 };
11162
11163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11165 if (!SWIG_IsOK(res1)) {
11166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11167 }
11168 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11169 arg2 = obj1;
11170 arg3 = obj2;
11171 {
11172 PyThreadState* __tstate = wxPyBeginAllowThreads();
11173 (arg1)->_setCallbackInfo(arg2,arg3);
11174 wxPyEndAllowThreads(__tstate);
11175 if (PyErr_Occurred()) SWIG_fail;
11176 }
11177 resultobj = SWIG_Py_Void();
11178 return resultobj;
11179 fail:
11180 return NULL;
11181 }
11182
11183
11184 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11185 PyObject *obj;
11186 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11187 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11188 return SWIG_Py_Void();
11189 }
11190
11191 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11192 return SWIG_Python_InitShadowInstance(args);
11193 }
11194
11195 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11196 PyObject *resultobj = 0;
11197 wxWindow *arg1 = (wxWindow *) 0 ;
11198 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11199 bool arg3 = (bool) true ;
11200 bool result;
11201 void *argp1 = 0 ;
11202 int res1 = 0 ;
11203 void *argp2 = 0 ;
11204 int res2 = 0 ;
11205 bool val3 ;
11206 int ecode3 = 0 ;
11207 PyObject * obj0 = 0 ;
11208 PyObject * obj1 = 0 ;
11209 PyObject * obj2 = 0 ;
11210 char * kwnames[] = {
11211 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11212 };
11213
11214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11216 if (!SWIG_IsOK(res1)) {
11217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11218 }
11219 arg1 = reinterpret_cast< wxWindow * >(argp1);
11220 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11221 if (!SWIG_IsOK(res2)) {
11222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11223 }
11224 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11225 if (obj2) {
11226 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11227 if (!SWIG_IsOK(ecode3)) {
11228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11229 }
11230 arg3 = static_cast< bool >(val3);
11231 }
11232 {
11233 if (!wxPyCheckForApp()) SWIG_fail;
11234 PyThreadState* __tstate = wxPyBeginAllowThreads();
11235 result = (bool)wxShowTip(arg1,arg2,arg3);
11236 wxPyEndAllowThreads(__tstate);
11237 if (PyErr_Occurred()) SWIG_fail;
11238 }
11239 {
11240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11241 }
11242 return resultobj;
11243 fail:
11244 return NULL;
11245 }
11246
11247
11248 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11249 PyObject *resultobj = 0;
11250 wxString *arg1 = 0 ;
11251 size_t arg2 ;
11252 wxTipProvider *result = 0 ;
11253 bool temp1 = false ;
11254 size_t val2 ;
11255 int ecode2 = 0 ;
11256 PyObject * obj0 = 0 ;
11257 PyObject * obj1 = 0 ;
11258 char * kwnames[] = {
11259 (char *) "filename",(char *) "currentTip", NULL
11260 };
11261
11262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11263 {
11264 arg1 = wxString_in_helper(obj0);
11265 if (arg1 == NULL) SWIG_fail;
11266 temp1 = true;
11267 }
11268 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11269 if (!SWIG_IsOK(ecode2)) {
11270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11271 }
11272 arg2 = static_cast< size_t >(val2);
11273 {
11274 if (!wxPyCheckForApp()) SWIG_fail;
11275 PyThreadState* __tstate = wxPyBeginAllowThreads();
11276 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11277 wxPyEndAllowThreads(__tstate);
11278 if (PyErr_Occurred()) SWIG_fail;
11279 }
11280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11281 {
11282 if (temp1)
11283 delete arg1;
11284 }
11285 return resultobj;
11286 fail:
11287 {
11288 if (temp1)
11289 delete arg1;
11290 }
11291 return NULL;
11292 }
11293
11294
11295 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11296 PyObject *resultobj = 0;
11297 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11298 int arg2 = (int) wxID_ANY ;
11299 wxPyTimer *result = 0 ;
11300 void *argp1 = 0 ;
11301 int res1 = 0 ;
11302 int val2 ;
11303 int ecode2 = 0 ;
11304 PyObject * obj0 = 0 ;
11305 PyObject * obj1 = 0 ;
11306 char * kwnames[] = {
11307 (char *) "owner",(char *) "id", NULL
11308 };
11309
11310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11311 if (obj0) {
11312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11313 if (!SWIG_IsOK(res1)) {
11314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11315 }
11316 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11317 }
11318 if (obj1) {
11319 ecode2 = SWIG_AsVal_int(obj1, &val2);
11320 if (!SWIG_IsOK(ecode2)) {
11321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11322 }
11323 arg2 = static_cast< int >(val2);
11324 }
11325 {
11326 if (!wxPyCheckForApp()) SWIG_fail;
11327 PyThreadState* __tstate = wxPyBeginAllowThreads();
11328 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11329 wxPyEndAllowThreads(__tstate);
11330 if (PyErr_Occurred()) SWIG_fail;
11331 }
11332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11333 return resultobj;
11334 fail:
11335 return NULL;
11336 }
11337
11338
11339 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11340 PyObject *resultobj = 0;
11341 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11342 void *argp1 = 0 ;
11343 int res1 = 0 ;
11344 PyObject *swig_obj[1] ;
11345
11346 if (!args) SWIG_fail;
11347 swig_obj[0] = args;
11348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11349 if (!SWIG_IsOK(res1)) {
11350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11351 }
11352 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11353 {
11354 PyThreadState* __tstate = wxPyBeginAllowThreads();
11355 delete arg1;
11356
11357 wxPyEndAllowThreads(__tstate);
11358 if (PyErr_Occurred()) SWIG_fail;
11359 }
11360 resultobj = SWIG_Py_Void();
11361 return resultobj;
11362 fail:
11363 return NULL;
11364 }
11365
11366
11367 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11368 PyObject *resultobj = 0;
11369 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11370 PyObject *arg2 = (PyObject *) 0 ;
11371 PyObject *arg3 = (PyObject *) 0 ;
11372 int arg4 = (int) 1 ;
11373 void *argp1 = 0 ;
11374 int res1 = 0 ;
11375 int val4 ;
11376 int ecode4 = 0 ;
11377 PyObject * obj0 = 0 ;
11378 PyObject * obj1 = 0 ;
11379 PyObject * obj2 = 0 ;
11380 PyObject * obj3 = 0 ;
11381 char * kwnames[] = {
11382 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11383 };
11384
11385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11387 if (!SWIG_IsOK(res1)) {
11388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11389 }
11390 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11391 arg2 = obj1;
11392 arg3 = obj2;
11393 if (obj3) {
11394 ecode4 = SWIG_AsVal_int(obj3, &val4);
11395 if (!SWIG_IsOK(ecode4)) {
11396 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11397 }
11398 arg4 = static_cast< int >(val4);
11399 }
11400 {
11401 PyThreadState* __tstate = wxPyBeginAllowThreads();
11402 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11403 wxPyEndAllowThreads(__tstate);
11404 if (PyErr_Occurred()) SWIG_fail;
11405 }
11406 resultobj = SWIG_Py_Void();
11407 return resultobj;
11408 fail:
11409 return NULL;
11410 }
11411
11412
11413 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11414 PyObject *resultobj = 0;
11415 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11416 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11417 int arg3 = (int) wxID_ANY ;
11418 void *argp1 = 0 ;
11419 int res1 = 0 ;
11420 void *argp2 = 0 ;
11421 int res2 = 0 ;
11422 int val3 ;
11423 int ecode3 = 0 ;
11424 PyObject * obj0 = 0 ;
11425 PyObject * obj1 = 0 ;
11426 PyObject * obj2 = 0 ;
11427 char * kwnames[] = {
11428 (char *) "self",(char *) "owner",(char *) "id", NULL
11429 };
11430
11431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11433 if (!SWIG_IsOK(res1)) {
11434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11435 }
11436 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11437 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11438 if (!SWIG_IsOK(res2)) {
11439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11440 }
11441 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11442 if (obj2) {
11443 ecode3 = SWIG_AsVal_int(obj2, &val3);
11444 if (!SWIG_IsOK(ecode3)) {
11445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11446 }
11447 arg3 = static_cast< int >(val3);
11448 }
11449 {
11450 PyThreadState* __tstate = wxPyBeginAllowThreads();
11451 (arg1)->SetOwner(arg2,arg3);
11452 wxPyEndAllowThreads(__tstate);
11453 if (PyErr_Occurred()) SWIG_fail;
11454 }
11455 resultobj = SWIG_Py_Void();
11456 return resultobj;
11457 fail:
11458 return NULL;
11459 }
11460
11461
11462 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11463 PyObject *resultobj = 0;
11464 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11465 wxEvtHandler *result = 0 ;
11466 void *argp1 = 0 ;
11467 int res1 = 0 ;
11468 PyObject *swig_obj[1] ;
11469
11470 if (!args) SWIG_fail;
11471 swig_obj[0] = args;
11472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11473 if (!SWIG_IsOK(res1)) {
11474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11475 }
11476 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11477 {
11478 PyThreadState* __tstate = wxPyBeginAllowThreads();
11479 result = (wxEvtHandler *)(arg1)->GetOwner();
11480 wxPyEndAllowThreads(__tstate);
11481 if (PyErr_Occurred()) SWIG_fail;
11482 }
11483 {
11484 resultobj = wxPyMake_wxObject(result, 0);
11485 }
11486 return resultobj;
11487 fail:
11488 return NULL;
11489 }
11490
11491
11492 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11493 PyObject *resultobj = 0;
11494 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11495 int arg2 = (int) -1 ;
11496 bool arg3 = (bool) false ;
11497 bool result;
11498 void *argp1 = 0 ;
11499 int res1 = 0 ;
11500 int val2 ;
11501 int ecode2 = 0 ;
11502 bool val3 ;
11503 int ecode3 = 0 ;
11504 PyObject * obj0 = 0 ;
11505 PyObject * obj1 = 0 ;
11506 PyObject * obj2 = 0 ;
11507 char * kwnames[] = {
11508 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11509 };
11510
11511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11513 if (!SWIG_IsOK(res1)) {
11514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11515 }
11516 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11517 if (obj1) {
11518 ecode2 = SWIG_AsVal_int(obj1, &val2);
11519 if (!SWIG_IsOK(ecode2)) {
11520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11521 }
11522 arg2 = static_cast< int >(val2);
11523 }
11524 if (obj2) {
11525 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11526 if (!SWIG_IsOK(ecode3)) {
11527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11528 }
11529 arg3 = static_cast< bool >(val3);
11530 }
11531 {
11532 PyThreadState* __tstate = wxPyBeginAllowThreads();
11533 result = (bool)(arg1)->Start(arg2,arg3);
11534 wxPyEndAllowThreads(__tstate);
11535 if (PyErr_Occurred()) SWIG_fail;
11536 }
11537 {
11538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11539 }
11540 return resultobj;
11541 fail:
11542 return NULL;
11543 }
11544
11545
11546 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11547 PyObject *resultobj = 0;
11548 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11549 void *argp1 = 0 ;
11550 int res1 = 0 ;
11551 PyObject *swig_obj[1] ;
11552
11553 if (!args) SWIG_fail;
11554 swig_obj[0] = args;
11555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11556 if (!SWIG_IsOK(res1)) {
11557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11558 }
11559 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11560 {
11561 PyThreadState* __tstate = wxPyBeginAllowThreads();
11562 (arg1)->Stop();
11563 wxPyEndAllowThreads(__tstate);
11564 if (PyErr_Occurred()) SWIG_fail;
11565 }
11566 resultobj = SWIG_Py_Void();
11567 return resultobj;
11568 fail:
11569 return NULL;
11570 }
11571
11572
11573 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11574 PyObject *resultobj = 0;
11575 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11576 void *argp1 = 0 ;
11577 int res1 = 0 ;
11578 PyObject *swig_obj[1] ;
11579
11580 if (!args) SWIG_fail;
11581 swig_obj[0] = args;
11582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11583 if (!SWIG_IsOK(res1)) {
11584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11585 }
11586 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11587 {
11588 PyThreadState* __tstate = wxPyBeginAllowThreads();
11589 (arg1)->Notify();
11590 wxPyEndAllowThreads(__tstate);
11591 if (PyErr_Occurred()) SWIG_fail;
11592 }
11593 resultobj = SWIG_Py_Void();
11594 return resultobj;
11595 fail:
11596 return NULL;
11597 }
11598
11599
11600 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11601 PyObject *resultobj = 0;
11602 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11603 bool result;
11604 void *argp1 = 0 ;
11605 int res1 = 0 ;
11606 PyObject *swig_obj[1] ;
11607
11608 if (!args) SWIG_fail;
11609 swig_obj[0] = args;
11610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11611 if (!SWIG_IsOK(res1)) {
11612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11613 }
11614 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11615 {
11616 PyThreadState* __tstate = wxPyBeginAllowThreads();
11617 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11618 wxPyEndAllowThreads(__tstate);
11619 if (PyErr_Occurred()) SWIG_fail;
11620 }
11621 {
11622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11623 }
11624 return resultobj;
11625 fail:
11626 return NULL;
11627 }
11628
11629
11630 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11631 PyObject *resultobj = 0;
11632 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11633 int result;
11634 void *argp1 = 0 ;
11635 int res1 = 0 ;
11636 PyObject *swig_obj[1] ;
11637
11638 if (!args) SWIG_fail;
11639 swig_obj[0] = args;
11640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11641 if (!SWIG_IsOK(res1)) {
11642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11643 }
11644 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11645 {
11646 PyThreadState* __tstate = wxPyBeginAllowThreads();
11647 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11648 wxPyEndAllowThreads(__tstate);
11649 if (PyErr_Occurred()) SWIG_fail;
11650 }
11651 resultobj = SWIG_From_int(static_cast< int >(result));
11652 return resultobj;
11653 fail:
11654 return NULL;
11655 }
11656
11657
11658 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11659 PyObject *resultobj = 0;
11660 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11661 int result;
11662 void *argp1 = 0 ;
11663 int res1 = 0 ;
11664 PyObject *swig_obj[1] ;
11665
11666 if (!args) SWIG_fail;
11667 swig_obj[0] = args;
11668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11669 if (!SWIG_IsOK(res1)) {
11670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11671 }
11672 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11673 {
11674 PyThreadState* __tstate = wxPyBeginAllowThreads();
11675 result = (int)((wxPyTimer const *)arg1)->GetId();
11676 wxPyEndAllowThreads(__tstate);
11677 if (PyErr_Occurred()) SWIG_fail;
11678 }
11679 resultobj = SWIG_From_int(static_cast< int >(result));
11680 return resultobj;
11681 fail:
11682 return NULL;
11683 }
11684
11685
11686 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11687 PyObject *resultobj = 0;
11688 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11689 bool result;
11690 void *argp1 = 0 ;
11691 int res1 = 0 ;
11692 PyObject *swig_obj[1] ;
11693
11694 if (!args) SWIG_fail;
11695 swig_obj[0] = args;
11696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11697 if (!SWIG_IsOK(res1)) {
11698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11699 }
11700 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11701 {
11702 PyThreadState* __tstate = wxPyBeginAllowThreads();
11703 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11704 wxPyEndAllowThreads(__tstate);
11705 if (PyErr_Occurred()) SWIG_fail;
11706 }
11707 {
11708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11709 }
11710 return resultobj;
11711 fail:
11712 return NULL;
11713 }
11714
11715
11716 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11717 PyObject *obj;
11718 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11719 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11720 return SWIG_Py_Void();
11721 }
11722
11723 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11724 return SWIG_Python_InitShadowInstance(args);
11725 }
11726
11727 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11728 PyObject *resultobj = 0;
11729 int arg1 = (int) 0 ;
11730 int arg2 = (int) 0 ;
11731 wxTimerEvent *result = 0 ;
11732 int val1 ;
11733 int ecode1 = 0 ;
11734 int val2 ;
11735 int ecode2 = 0 ;
11736 PyObject * obj0 = 0 ;
11737 PyObject * obj1 = 0 ;
11738 char * kwnames[] = {
11739 (char *) "timerid",(char *) "interval", NULL
11740 };
11741
11742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11743 if (obj0) {
11744 ecode1 = SWIG_AsVal_int(obj0, &val1);
11745 if (!SWIG_IsOK(ecode1)) {
11746 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11747 }
11748 arg1 = static_cast< int >(val1);
11749 }
11750 if (obj1) {
11751 ecode2 = SWIG_AsVal_int(obj1, &val2);
11752 if (!SWIG_IsOK(ecode2)) {
11753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11754 }
11755 arg2 = static_cast< int >(val2);
11756 }
11757 {
11758 PyThreadState* __tstate = wxPyBeginAllowThreads();
11759 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11760 wxPyEndAllowThreads(__tstate);
11761 if (PyErr_Occurred()) SWIG_fail;
11762 }
11763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11764 return resultobj;
11765 fail:
11766 return NULL;
11767 }
11768
11769
11770 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11771 PyObject *resultobj = 0;
11772 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11773 int result;
11774 void *argp1 = 0 ;
11775 int res1 = 0 ;
11776 PyObject *swig_obj[1] ;
11777
11778 if (!args) SWIG_fail;
11779 swig_obj[0] = args;
11780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11781 if (!SWIG_IsOK(res1)) {
11782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11783 }
11784 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11785 {
11786 PyThreadState* __tstate = wxPyBeginAllowThreads();
11787 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11788 wxPyEndAllowThreads(__tstate);
11789 if (PyErr_Occurred()) SWIG_fail;
11790 }
11791 resultobj = SWIG_From_int(static_cast< int >(result));
11792 return resultobj;
11793 fail:
11794 return NULL;
11795 }
11796
11797
11798 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11799 PyObject *obj;
11800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11801 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11802 return SWIG_Py_Void();
11803 }
11804
11805 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11806 return SWIG_Python_InitShadowInstance(args);
11807 }
11808
11809 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11810 PyObject *resultobj = 0;
11811 wxTimer *arg1 = 0 ;
11812 wxTimerRunner *result = 0 ;
11813 void *argp1 = 0 ;
11814 int res1 = 0 ;
11815
11816 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11818 if (!SWIG_IsOK(res1)) {
11819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11820 }
11821 if (!argp1) {
11822 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11823 }
11824 arg1 = reinterpret_cast< wxTimer * >(argp1);
11825 {
11826 if (!wxPyCheckForApp()) SWIG_fail;
11827 PyThreadState* __tstate = wxPyBeginAllowThreads();
11828 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11829 wxPyEndAllowThreads(__tstate);
11830 if (PyErr_Occurred()) SWIG_fail;
11831 }
11832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11833 return resultobj;
11834 fail:
11835 return NULL;
11836 }
11837
11838
11839 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11840 PyObject *resultobj = 0;
11841 wxTimer *arg1 = 0 ;
11842 int arg2 ;
11843 bool arg3 = (bool) false ;
11844 wxTimerRunner *result = 0 ;
11845 void *argp1 = 0 ;
11846 int res1 = 0 ;
11847 int val2 ;
11848 int ecode2 = 0 ;
11849 bool val3 ;
11850 int ecode3 = 0 ;
11851
11852 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
11853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11854 if (!SWIG_IsOK(res1)) {
11855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11856 }
11857 if (!argp1) {
11858 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11859 }
11860 arg1 = reinterpret_cast< wxTimer * >(argp1);
11861 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11862 if (!SWIG_IsOK(ecode2)) {
11863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
11864 }
11865 arg2 = static_cast< int >(val2);
11866 if (swig_obj[2]) {
11867 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
11868 if (!SWIG_IsOK(ecode3)) {
11869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
11870 }
11871 arg3 = static_cast< bool >(val3);
11872 }
11873 {
11874 if (!wxPyCheckForApp()) SWIG_fail;
11875 PyThreadState* __tstate = wxPyBeginAllowThreads();
11876 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
11877 wxPyEndAllowThreads(__tstate);
11878 if (PyErr_Occurred()) SWIG_fail;
11879 }
11880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11881 return resultobj;
11882 fail:
11883 return NULL;
11884 }
11885
11886
11887 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
11888 int argc;
11889 PyObject *argv[4];
11890
11891 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
11892 --argc;
11893 if (argc == 1) {
11894 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
11895 }
11896 if ((argc >= 2) && (argc <= 3)) {
11897 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
11898 }
11899
11900 fail:
11901 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
11902 return NULL;
11903 }
11904
11905
11906 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11907 PyObject *resultobj = 0;
11908 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11909 void *argp1 = 0 ;
11910 int res1 = 0 ;
11911 PyObject *swig_obj[1] ;
11912
11913 if (!args) SWIG_fail;
11914 swig_obj[0] = args;
11915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
11916 if (!SWIG_IsOK(res1)) {
11917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11918 }
11919 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11920 {
11921 PyThreadState* __tstate = wxPyBeginAllowThreads();
11922 delete arg1;
11923
11924 wxPyEndAllowThreads(__tstate);
11925 if (PyErr_Occurred()) SWIG_fail;
11926 }
11927 resultobj = SWIG_Py_Void();
11928 return resultobj;
11929 fail:
11930 return NULL;
11931 }
11932
11933
11934 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11935 PyObject *resultobj = 0;
11936 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11937 int arg2 ;
11938 bool arg3 = (bool) false ;
11939 void *argp1 = 0 ;
11940 int res1 = 0 ;
11941 int val2 ;
11942 int ecode2 = 0 ;
11943 bool val3 ;
11944 int ecode3 = 0 ;
11945 PyObject * obj0 = 0 ;
11946 PyObject * obj1 = 0 ;
11947 PyObject * obj2 = 0 ;
11948 char * kwnames[] = {
11949 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
11950 };
11951
11952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
11954 if (!SWIG_IsOK(res1)) {
11955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11956 }
11957 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11958 ecode2 = SWIG_AsVal_int(obj1, &val2);
11959 if (!SWIG_IsOK(ecode2)) {
11960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
11961 }
11962 arg2 = static_cast< int >(val2);
11963 if (obj2) {
11964 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11965 if (!SWIG_IsOK(ecode3)) {
11966 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
11967 }
11968 arg3 = static_cast< bool >(val3);
11969 }
11970 {
11971 PyThreadState* __tstate = wxPyBeginAllowThreads();
11972 (arg1)->Start(arg2,arg3);
11973 wxPyEndAllowThreads(__tstate);
11974 if (PyErr_Occurred()) SWIG_fail;
11975 }
11976 resultobj = SWIG_Py_Void();
11977 return resultobj;
11978 fail:
11979 return NULL;
11980 }
11981
11982
11983 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11984 PyObject *obj;
11985 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11986 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
11987 return SWIG_Py_Void();
11988 }
11989
11990 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11991 return SWIG_Python_InitShadowInstance(args);
11992 }
11993
11994 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11995 PyObject *resultobj = 0;
11996 wxLog *result = 0 ;
11997
11998 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
11999 {
12000 PyThreadState* __tstate = wxPyBeginAllowThreads();
12001 result = (wxLog *)new wxLog();
12002 wxPyEndAllowThreads(__tstate);
12003 if (PyErr_Occurred()) SWIG_fail;
12004 }
12005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12006 return resultobj;
12007 fail:
12008 return NULL;
12009 }
12010
12011
12012 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12013 PyObject *resultobj = 0;
12014 wxLog *arg1 = (wxLog *) 0 ;
12015 void *argp1 = 0 ;
12016 int res1 = 0 ;
12017 PyObject *swig_obj[1] ;
12018
12019 if (!args) SWIG_fail;
12020 swig_obj[0] = args;
12021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12022 if (!SWIG_IsOK(res1)) {
12023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12024 }
12025 arg1 = reinterpret_cast< wxLog * >(argp1);
12026 {
12027 PyThreadState* __tstate = wxPyBeginAllowThreads();
12028 delete arg1;
12029
12030 wxPyEndAllowThreads(__tstate);
12031 if (PyErr_Occurred()) SWIG_fail;
12032 }
12033 resultobj = SWIG_Py_Void();
12034 return resultobj;
12035 fail:
12036 return NULL;
12037 }
12038
12039
12040 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12041 PyObject *resultobj = 0;
12042 bool result;
12043
12044 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12045 {
12046 PyThreadState* __tstate = wxPyBeginAllowThreads();
12047 result = (bool)wxLog::IsEnabled();
12048 wxPyEndAllowThreads(__tstate);
12049 if (PyErr_Occurred()) SWIG_fail;
12050 }
12051 {
12052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12053 }
12054 return resultobj;
12055 fail:
12056 return NULL;
12057 }
12058
12059
12060 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12061 PyObject *resultobj = 0;
12062 bool arg1 = (bool) true ;
12063 bool result;
12064 bool val1 ;
12065 int ecode1 = 0 ;
12066 PyObject * obj0 = 0 ;
12067 char * kwnames[] = {
12068 (char *) "doIt", NULL
12069 };
12070
12071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12072 if (obj0) {
12073 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12074 if (!SWIG_IsOK(ecode1)) {
12075 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12076 }
12077 arg1 = static_cast< bool >(val1);
12078 }
12079 {
12080 PyThreadState* __tstate = wxPyBeginAllowThreads();
12081 result = (bool)wxLog::EnableLogging(arg1);
12082 wxPyEndAllowThreads(__tstate);
12083 if (PyErr_Occurred()) SWIG_fail;
12084 }
12085 {
12086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12087 }
12088 return resultobj;
12089 fail:
12090 return NULL;
12091 }
12092
12093
12094 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12095 PyObject *resultobj = 0;
12096 wxLogLevel arg1 ;
12097 wxChar *arg2 = (wxChar *) 0 ;
12098 time_t arg3 ;
12099 unsigned long val1 ;
12100 int ecode1 = 0 ;
12101 void *argp2 = 0 ;
12102 int res2 = 0 ;
12103 unsigned int val3 ;
12104 int ecode3 = 0 ;
12105 PyObject * obj0 = 0 ;
12106 PyObject * obj1 = 0 ;
12107 PyObject * obj2 = 0 ;
12108 char * kwnames[] = {
12109 (char *) "level",(char *) "szString",(char *) "t", NULL
12110 };
12111
12112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12113 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12114 if (!SWIG_IsOK(ecode1)) {
12115 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12116 }
12117 arg1 = static_cast< wxLogLevel >(val1);
12118 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12119 if (!SWIG_IsOK(res2)) {
12120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12121 }
12122 arg2 = reinterpret_cast< wxChar * >(argp2);
12123 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12124 if (!SWIG_IsOK(ecode3)) {
12125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12126 }
12127 arg3 = static_cast< time_t >(val3);
12128 {
12129 PyThreadState* __tstate = wxPyBeginAllowThreads();
12130 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12131 wxPyEndAllowThreads(__tstate);
12132 if (PyErr_Occurred()) SWIG_fail;
12133 }
12134 resultobj = SWIG_Py_Void();
12135 return resultobj;
12136 fail:
12137 return NULL;
12138 }
12139
12140
12141 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12142 PyObject *resultobj = 0;
12143 wxLog *arg1 = (wxLog *) 0 ;
12144 void *argp1 = 0 ;
12145 int res1 = 0 ;
12146 PyObject *swig_obj[1] ;
12147
12148 if (!args) SWIG_fail;
12149 swig_obj[0] = args;
12150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12151 if (!SWIG_IsOK(res1)) {
12152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12153 }
12154 arg1 = reinterpret_cast< wxLog * >(argp1);
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 (arg1)->Flush();
12158 wxPyEndAllowThreads(__tstate);
12159 if (PyErr_Occurred()) SWIG_fail;
12160 }
12161 resultobj = SWIG_Py_Void();
12162 return resultobj;
12163 fail:
12164 return NULL;
12165 }
12166
12167
12168 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12169 PyObject *resultobj = 0;
12170
12171 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12172 {
12173 PyThreadState* __tstate = wxPyBeginAllowThreads();
12174 wxLog::FlushActive();
12175 wxPyEndAllowThreads(__tstate);
12176 if (PyErr_Occurred()) SWIG_fail;
12177 }
12178 resultobj = SWIG_Py_Void();
12179 return resultobj;
12180 fail:
12181 return NULL;
12182 }
12183
12184
12185 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12186 PyObject *resultobj = 0;
12187 wxLog *result = 0 ;
12188
12189 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12190 {
12191 PyThreadState* __tstate = wxPyBeginAllowThreads();
12192 result = (wxLog *)wxLog::GetActiveTarget();
12193 wxPyEndAllowThreads(__tstate);
12194 if (PyErr_Occurred()) SWIG_fail;
12195 }
12196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12197 return resultobj;
12198 fail:
12199 return NULL;
12200 }
12201
12202
12203 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12204 PyObject *resultobj = 0;
12205 wxLog *arg1 = (wxLog *) 0 ;
12206 wxLog *result = 0 ;
12207 int res1 = 0 ;
12208 PyObject * obj0 = 0 ;
12209 char * kwnames[] = {
12210 (char *) "pLogger", NULL
12211 };
12212
12213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12214 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12215 if (!SWIG_IsOK(res1)) {
12216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12217 }
12218 {
12219 PyThreadState* __tstate = wxPyBeginAllowThreads();
12220 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12221 wxPyEndAllowThreads(__tstate);
12222 if (PyErr_Occurred()) SWIG_fail;
12223 }
12224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12225 return resultobj;
12226 fail:
12227 return NULL;
12228 }
12229
12230
12231 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12232 PyObject *resultobj = 0;
12233
12234 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12235 {
12236 PyThreadState* __tstate = wxPyBeginAllowThreads();
12237 wxLog::Suspend();
12238 wxPyEndAllowThreads(__tstate);
12239 if (PyErr_Occurred()) SWIG_fail;
12240 }
12241 resultobj = SWIG_Py_Void();
12242 return resultobj;
12243 fail:
12244 return NULL;
12245 }
12246
12247
12248 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12249 PyObject *resultobj = 0;
12250
12251 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12252 {
12253 PyThreadState* __tstate = wxPyBeginAllowThreads();
12254 wxLog::Resume();
12255 wxPyEndAllowThreads(__tstate);
12256 if (PyErr_Occurred()) SWIG_fail;
12257 }
12258 resultobj = SWIG_Py_Void();
12259 return resultobj;
12260 fail:
12261 return NULL;
12262 }
12263
12264
12265 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12266 PyObject *resultobj = 0;
12267 bool arg1 = (bool) true ;
12268 bool val1 ;
12269 int ecode1 = 0 ;
12270 PyObject * obj0 = 0 ;
12271 char * kwnames[] = {
12272 (char *) "bVerbose", NULL
12273 };
12274
12275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12276 if (obj0) {
12277 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12278 if (!SWIG_IsOK(ecode1)) {
12279 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12280 }
12281 arg1 = static_cast< bool >(val1);
12282 }
12283 {
12284 PyThreadState* __tstate = wxPyBeginAllowThreads();
12285 wxLog::SetVerbose(arg1);
12286 wxPyEndAllowThreads(__tstate);
12287 if (PyErr_Occurred()) SWIG_fail;
12288 }
12289 resultobj = SWIG_Py_Void();
12290 return resultobj;
12291 fail:
12292 return NULL;
12293 }
12294
12295
12296 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12297 PyObject *resultobj = 0;
12298 wxLogLevel arg1 ;
12299 unsigned long val1 ;
12300 int ecode1 = 0 ;
12301 PyObject * obj0 = 0 ;
12302 char * kwnames[] = {
12303 (char *) "logLevel", NULL
12304 };
12305
12306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12307 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12308 if (!SWIG_IsOK(ecode1)) {
12309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12310 }
12311 arg1 = static_cast< wxLogLevel >(val1);
12312 {
12313 PyThreadState* __tstate = wxPyBeginAllowThreads();
12314 wxLog::SetLogLevel(arg1);
12315 wxPyEndAllowThreads(__tstate);
12316 if (PyErr_Occurred()) SWIG_fail;
12317 }
12318 resultobj = SWIG_Py_Void();
12319 return resultobj;
12320 fail:
12321 return NULL;
12322 }
12323
12324
12325 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12326 PyObject *resultobj = 0;
12327
12328 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12329 {
12330 PyThreadState* __tstate = wxPyBeginAllowThreads();
12331 wxLog::DontCreateOnDemand();
12332 wxPyEndAllowThreads(__tstate);
12333 if (PyErr_Occurred()) SWIG_fail;
12334 }
12335 resultobj = SWIG_Py_Void();
12336 return resultobj;
12337 fail:
12338 return NULL;
12339 }
12340
12341
12342 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12343 PyObject *resultobj = 0;
12344 bool arg1 = (bool) true ;
12345 bool val1 ;
12346 int ecode1 = 0 ;
12347 PyObject * obj0 = 0 ;
12348 char * kwnames[] = {
12349 (char *) "bRepetCounting", NULL
12350 };
12351
12352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12353 if (obj0) {
12354 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12355 if (!SWIG_IsOK(ecode1)) {
12356 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12357 }
12358 arg1 = static_cast< bool >(val1);
12359 }
12360 {
12361 PyThreadState* __tstate = wxPyBeginAllowThreads();
12362 wxLog::SetRepetitionCounting(arg1);
12363 wxPyEndAllowThreads(__tstate);
12364 if (PyErr_Occurred()) SWIG_fail;
12365 }
12366 resultobj = SWIG_Py_Void();
12367 return resultobj;
12368 fail:
12369 return NULL;
12370 }
12371
12372
12373 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12374 PyObject *resultobj = 0;
12375 bool result;
12376
12377 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12378 {
12379 PyThreadState* __tstate = wxPyBeginAllowThreads();
12380 result = (bool)wxLog::GetRepetitionCounting();
12381 wxPyEndAllowThreads(__tstate);
12382 if (PyErr_Occurred()) SWIG_fail;
12383 }
12384 {
12385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12386 }
12387 return resultobj;
12388 fail:
12389 return NULL;
12390 }
12391
12392
12393 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12394 PyObject *resultobj = 0;
12395 wxTraceMask arg1 ;
12396 unsigned long val1 ;
12397 int ecode1 = 0 ;
12398 PyObject * obj0 = 0 ;
12399 char * kwnames[] = {
12400 (char *) "ulMask", NULL
12401 };
12402
12403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12404 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12405 if (!SWIG_IsOK(ecode1)) {
12406 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12407 }
12408 arg1 = static_cast< wxTraceMask >(val1);
12409 {
12410 PyThreadState* __tstate = wxPyBeginAllowThreads();
12411 wxLog::SetTraceMask(arg1);
12412 wxPyEndAllowThreads(__tstate);
12413 if (PyErr_Occurred()) SWIG_fail;
12414 }
12415 resultobj = SWIG_Py_Void();
12416 return resultobj;
12417 fail:
12418 return NULL;
12419 }
12420
12421
12422 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12423 PyObject *resultobj = 0;
12424 wxString *arg1 = 0 ;
12425 bool temp1 = false ;
12426 PyObject * obj0 = 0 ;
12427 char * kwnames[] = {
12428 (char *) "str", NULL
12429 };
12430
12431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12432 {
12433 arg1 = wxString_in_helper(obj0);
12434 if (arg1 == NULL) SWIG_fail;
12435 temp1 = true;
12436 }
12437 {
12438 PyThreadState* __tstate = wxPyBeginAllowThreads();
12439 wxLog::AddTraceMask((wxString const &)*arg1);
12440 wxPyEndAllowThreads(__tstate);
12441 if (PyErr_Occurred()) SWIG_fail;
12442 }
12443 resultobj = SWIG_Py_Void();
12444 {
12445 if (temp1)
12446 delete arg1;
12447 }
12448 return resultobj;
12449 fail:
12450 {
12451 if (temp1)
12452 delete arg1;
12453 }
12454 return NULL;
12455 }
12456
12457
12458 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12459 PyObject *resultobj = 0;
12460 wxString *arg1 = 0 ;
12461 bool temp1 = false ;
12462 PyObject * obj0 = 0 ;
12463 char * kwnames[] = {
12464 (char *) "str", NULL
12465 };
12466
12467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12468 {
12469 arg1 = wxString_in_helper(obj0);
12470 if (arg1 == NULL) SWIG_fail;
12471 temp1 = true;
12472 }
12473 {
12474 PyThreadState* __tstate = wxPyBeginAllowThreads();
12475 wxLog::RemoveTraceMask((wxString const &)*arg1);
12476 wxPyEndAllowThreads(__tstate);
12477 if (PyErr_Occurred()) SWIG_fail;
12478 }
12479 resultobj = SWIG_Py_Void();
12480 {
12481 if (temp1)
12482 delete arg1;
12483 }
12484 return resultobj;
12485 fail:
12486 {
12487 if (temp1)
12488 delete arg1;
12489 }
12490 return NULL;
12491 }
12492
12493
12494 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12495 PyObject *resultobj = 0;
12496
12497 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12498 {
12499 PyThreadState* __tstate = wxPyBeginAllowThreads();
12500 wxLog::ClearTraceMasks();
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_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12512 PyObject *resultobj = 0;
12513 wxArrayString *result = 0 ;
12514
12515 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12516 {
12517 PyThreadState* __tstate = wxPyBeginAllowThreads();
12518 {
12519 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12520 result = (wxArrayString *) &_result_ref;
12521 }
12522 wxPyEndAllowThreads(__tstate);
12523 if (PyErr_Occurred()) SWIG_fail;
12524 }
12525 {
12526 resultobj = wxArrayString2PyList_helper(*result);
12527 }
12528 return resultobj;
12529 fail:
12530 return NULL;
12531 }
12532
12533
12534 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12535 PyObject *resultobj = 0;
12536 wxChar *arg1 = (wxChar *) 0 ;
12537 void *argp1 = 0 ;
12538 int res1 = 0 ;
12539 PyObject * obj0 = 0 ;
12540 char * kwnames[] = {
12541 (char *) "ts", NULL
12542 };
12543
12544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12546 if (!SWIG_IsOK(res1)) {
12547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12548 }
12549 arg1 = reinterpret_cast< wxChar * >(argp1);
12550 {
12551 PyThreadState* __tstate = wxPyBeginAllowThreads();
12552 wxLog::SetTimestamp((wxChar const *)arg1);
12553 wxPyEndAllowThreads(__tstate);
12554 if (PyErr_Occurred()) SWIG_fail;
12555 }
12556 resultobj = SWIG_Py_Void();
12557 return resultobj;
12558 fail:
12559 return NULL;
12560 }
12561
12562
12563 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12564 PyObject *resultobj = 0;
12565 bool result;
12566
12567 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12568 {
12569 PyThreadState* __tstate = wxPyBeginAllowThreads();
12570 result = (bool)wxLog::GetVerbose();
12571 wxPyEndAllowThreads(__tstate);
12572 if (PyErr_Occurred()) SWIG_fail;
12573 }
12574 {
12575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12576 }
12577 return resultobj;
12578 fail:
12579 return NULL;
12580 }
12581
12582
12583 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12584 PyObject *resultobj = 0;
12585 wxTraceMask result;
12586
12587 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12588 {
12589 PyThreadState* __tstate = wxPyBeginAllowThreads();
12590 result = (wxTraceMask)wxLog::GetTraceMask();
12591 wxPyEndAllowThreads(__tstate);
12592 if (PyErr_Occurred()) SWIG_fail;
12593 }
12594 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12595 return resultobj;
12596 fail:
12597 return NULL;
12598 }
12599
12600
12601 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12602 PyObject *resultobj = 0;
12603 wxChar *arg1 = (wxChar *) 0 ;
12604 bool result;
12605 void *argp1 = 0 ;
12606 int res1 = 0 ;
12607 PyObject * obj0 = 0 ;
12608 char * kwnames[] = {
12609 (char *) "mask", NULL
12610 };
12611
12612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12614 if (!SWIG_IsOK(res1)) {
12615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12616 }
12617 arg1 = reinterpret_cast< wxChar * >(argp1);
12618 {
12619 PyThreadState* __tstate = wxPyBeginAllowThreads();
12620 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12621 wxPyEndAllowThreads(__tstate);
12622 if (PyErr_Occurred()) SWIG_fail;
12623 }
12624 {
12625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12626 }
12627 return resultobj;
12628 fail:
12629 return NULL;
12630 }
12631
12632
12633 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12634 PyObject *resultobj = 0;
12635 wxLogLevel result;
12636
12637 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12638 {
12639 PyThreadState* __tstate = wxPyBeginAllowThreads();
12640 result = (wxLogLevel)wxLog::GetLogLevel();
12641 wxPyEndAllowThreads(__tstate);
12642 if (PyErr_Occurred()) SWIG_fail;
12643 }
12644 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12645 return resultobj;
12646 fail:
12647 return NULL;
12648 }
12649
12650
12651 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12652 PyObject *resultobj = 0;
12653 wxChar *result = 0 ;
12654
12655 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12656 {
12657 PyThreadState* __tstate = wxPyBeginAllowThreads();
12658 result = (wxChar *)wxLog::GetTimestamp();
12659 wxPyEndAllowThreads(__tstate);
12660 if (PyErr_Occurred()) SWIG_fail;
12661 }
12662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12663 return resultobj;
12664 fail:
12665 return NULL;
12666 }
12667
12668
12669 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12670 PyObject *resultobj = 0;
12671 wxString result;
12672
12673 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12674 {
12675 PyThreadState* __tstate = wxPyBeginAllowThreads();
12676 result = wxLog_TimeStamp();
12677 wxPyEndAllowThreads(__tstate);
12678 if (PyErr_Occurred()) SWIG_fail;
12679 }
12680 {
12681 #if wxUSE_UNICODE
12682 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12683 #else
12684 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12685 #endif
12686 }
12687 return resultobj;
12688 fail:
12689 return NULL;
12690 }
12691
12692
12693 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12694 PyObject *resultobj = 0;
12695 wxLog *arg1 = (wxLog *) 0 ;
12696 void *argp1 = 0 ;
12697 int res1 = 0 ;
12698 PyObject *swig_obj[1] ;
12699
12700 if (!args) SWIG_fail;
12701 swig_obj[0] = args;
12702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12703 if (!SWIG_IsOK(res1)) {
12704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12705 }
12706 arg1 = reinterpret_cast< wxLog * >(argp1);
12707 {
12708 PyThreadState* __tstate = wxPyBeginAllowThreads();
12709 wxLog_Destroy(arg1);
12710 wxPyEndAllowThreads(__tstate);
12711 if (PyErr_Occurred()) SWIG_fail;
12712 }
12713 resultobj = SWIG_Py_Void();
12714 return resultobj;
12715 fail:
12716 return NULL;
12717 }
12718
12719
12720 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12721 PyObject *obj;
12722 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12723 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12724 return SWIG_Py_Void();
12725 }
12726
12727 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12728 return SWIG_Python_InitShadowInstance(args);
12729 }
12730
12731 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12732 PyObject *resultobj = 0;
12733 wxLogStderr *result = 0 ;
12734
12735 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12736 {
12737 PyThreadState* __tstate = wxPyBeginAllowThreads();
12738 result = (wxLogStderr *)new wxLogStderr();
12739 wxPyEndAllowThreads(__tstate);
12740 if (PyErr_Occurred()) SWIG_fail;
12741 }
12742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12743 return resultobj;
12744 fail:
12745 return NULL;
12746 }
12747
12748
12749 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12750 PyObject *obj;
12751 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12752 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12753 return SWIG_Py_Void();
12754 }
12755
12756 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12757 return SWIG_Python_InitShadowInstance(args);
12758 }
12759
12760 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12761 PyObject *resultobj = 0;
12762 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12763 wxLogTextCtrl *result = 0 ;
12764 void *argp1 = 0 ;
12765 int res1 = 0 ;
12766 PyObject * obj0 = 0 ;
12767 char * kwnames[] = {
12768 (char *) "pTextCtrl", NULL
12769 };
12770
12771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12773 if (!SWIG_IsOK(res1)) {
12774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12775 }
12776 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12777 {
12778 PyThreadState* __tstate = wxPyBeginAllowThreads();
12779 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12780 wxPyEndAllowThreads(__tstate);
12781 if (PyErr_Occurred()) SWIG_fail;
12782 }
12783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12784 return resultobj;
12785 fail:
12786 return NULL;
12787 }
12788
12789
12790 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12791 PyObject *obj;
12792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12793 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12794 return SWIG_Py_Void();
12795 }
12796
12797 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12798 return SWIG_Python_InitShadowInstance(args);
12799 }
12800
12801 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12802 PyObject *resultobj = 0;
12803 wxLogGui *result = 0 ;
12804
12805 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12806 {
12807 PyThreadState* __tstate = wxPyBeginAllowThreads();
12808 result = (wxLogGui *)new wxLogGui();
12809 wxPyEndAllowThreads(__tstate);
12810 if (PyErr_Occurred()) SWIG_fail;
12811 }
12812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12813 return resultobj;
12814 fail:
12815 return NULL;
12816 }
12817
12818
12819 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12820 PyObject *obj;
12821 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12822 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12823 return SWIG_Py_Void();
12824 }
12825
12826 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12827 return SWIG_Python_InitShadowInstance(args);
12828 }
12829
12830 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12831 PyObject *resultobj = 0;
12832 wxFrame *arg1 = (wxFrame *) 0 ;
12833 wxString *arg2 = 0 ;
12834 bool arg3 = (bool) true ;
12835 bool arg4 = (bool) true ;
12836 wxLogWindow *result = 0 ;
12837 void *argp1 = 0 ;
12838 int res1 = 0 ;
12839 bool temp2 = false ;
12840 bool val3 ;
12841 int ecode3 = 0 ;
12842 bool val4 ;
12843 int ecode4 = 0 ;
12844 PyObject * obj0 = 0 ;
12845 PyObject * obj1 = 0 ;
12846 PyObject * obj2 = 0 ;
12847 PyObject * obj3 = 0 ;
12848 char * kwnames[] = {
12849 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
12850 };
12851
12852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12854 if (!SWIG_IsOK(res1)) {
12855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
12856 }
12857 arg1 = reinterpret_cast< wxFrame * >(argp1);
12858 {
12859 arg2 = wxString_in_helper(obj1);
12860 if (arg2 == NULL) SWIG_fail;
12861 temp2 = true;
12862 }
12863 if (obj2) {
12864 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12865 if (!SWIG_IsOK(ecode3)) {
12866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
12867 }
12868 arg3 = static_cast< bool >(val3);
12869 }
12870 if (obj3) {
12871 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12872 if (!SWIG_IsOK(ecode4)) {
12873 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
12874 }
12875 arg4 = static_cast< bool >(val4);
12876 }
12877 {
12878 PyThreadState* __tstate = wxPyBeginAllowThreads();
12879 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
12880 wxPyEndAllowThreads(__tstate);
12881 if (PyErr_Occurred()) SWIG_fail;
12882 }
12883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
12884 {
12885 if (temp2)
12886 delete arg2;
12887 }
12888 return resultobj;
12889 fail:
12890 {
12891 if (temp2)
12892 delete arg2;
12893 }
12894 return NULL;
12895 }
12896
12897
12898 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12899 PyObject *resultobj = 0;
12900 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12901 bool arg2 = (bool) true ;
12902 void *argp1 = 0 ;
12903 int res1 = 0 ;
12904 bool val2 ;
12905 int ecode2 = 0 ;
12906 PyObject * obj0 = 0 ;
12907 PyObject * obj1 = 0 ;
12908 char * kwnames[] = {
12909 (char *) "self",(char *) "bShow", NULL
12910 };
12911
12912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
12913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12914 if (!SWIG_IsOK(res1)) {
12915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
12916 }
12917 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12918 if (obj1) {
12919 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12920 if (!SWIG_IsOK(ecode2)) {
12921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
12922 }
12923 arg2 = static_cast< bool >(val2);
12924 }
12925 {
12926 PyThreadState* __tstate = wxPyBeginAllowThreads();
12927 (arg1)->Show(arg2);
12928 wxPyEndAllowThreads(__tstate);
12929 if (PyErr_Occurred()) SWIG_fail;
12930 }
12931 resultobj = SWIG_Py_Void();
12932 return resultobj;
12933 fail:
12934 return NULL;
12935 }
12936
12937
12938 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12939 PyObject *resultobj = 0;
12940 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12941 wxFrame *result = 0 ;
12942 void *argp1 = 0 ;
12943 int res1 = 0 ;
12944 PyObject *swig_obj[1] ;
12945
12946 if (!args) SWIG_fail;
12947 swig_obj[0] = args;
12948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12949 if (!SWIG_IsOK(res1)) {
12950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12951 }
12952 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12953 {
12954 PyThreadState* __tstate = wxPyBeginAllowThreads();
12955 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
12956 wxPyEndAllowThreads(__tstate);
12957 if (PyErr_Occurred()) SWIG_fail;
12958 }
12959 {
12960 resultobj = wxPyMake_wxObject(result, (bool)0);
12961 }
12962 return resultobj;
12963 fail:
12964 return NULL;
12965 }
12966
12967
12968 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12969 PyObject *resultobj = 0;
12970 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12971 wxLog *result = 0 ;
12972 void *argp1 = 0 ;
12973 int res1 = 0 ;
12974 PyObject *swig_obj[1] ;
12975
12976 if (!args) SWIG_fail;
12977 swig_obj[0] = args;
12978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12979 if (!SWIG_IsOK(res1)) {
12980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12981 }
12982 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12983 {
12984 PyThreadState* __tstate = wxPyBeginAllowThreads();
12985 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
12986 wxPyEndAllowThreads(__tstate);
12987 if (PyErr_Occurred()) SWIG_fail;
12988 }
12989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12990 return resultobj;
12991 fail:
12992 return NULL;
12993 }
12994
12995
12996 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12997 PyObject *resultobj = 0;
12998 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12999 bool result;
13000 void *argp1 = 0 ;
13001 int res1 = 0 ;
13002 PyObject *swig_obj[1] ;
13003
13004 if (!args) SWIG_fail;
13005 swig_obj[0] = args;
13006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13007 if (!SWIG_IsOK(res1)) {
13008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13009 }
13010 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13011 {
13012 PyThreadState* __tstate = wxPyBeginAllowThreads();
13013 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13014 wxPyEndAllowThreads(__tstate);
13015 if (PyErr_Occurred()) SWIG_fail;
13016 }
13017 {
13018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13019 }
13020 return resultobj;
13021 fail:
13022 return NULL;
13023 }
13024
13025
13026 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13027 PyObject *resultobj = 0;
13028 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13029 bool arg2 ;
13030 void *argp1 = 0 ;
13031 int res1 = 0 ;
13032 bool val2 ;
13033 int ecode2 = 0 ;
13034 PyObject * obj0 = 0 ;
13035 PyObject * obj1 = 0 ;
13036 char * kwnames[] = {
13037 (char *) "self",(char *) "bDoPass", NULL
13038 };
13039
13040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13042 if (!SWIG_IsOK(res1)) {
13043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13044 }
13045 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13046 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13047 if (!SWIG_IsOK(ecode2)) {
13048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13049 }
13050 arg2 = static_cast< bool >(val2);
13051 {
13052 PyThreadState* __tstate = wxPyBeginAllowThreads();
13053 (arg1)->PassMessages(arg2);
13054 wxPyEndAllowThreads(__tstate);
13055 if (PyErr_Occurred()) SWIG_fail;
13056 }
13057 resultobj = SWIG_Py_Void();
13058 return resultobj;
13059 fail:
13060 return NULL;
13061 }
13062
13063
13064 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13065 PyObject *obj;
13066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13067 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13068 return SWIG_Py_Void();
13069 }
13070
13071 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13072 return SWIG_Python_InitShadowInstance(args);
13073 }
13074
13075 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13076 PyObject *resultobj = 0;
13077 wxLog *arg1 = (wxLog *) 0 ;
13078 wxLogChain *result = 0 ;
13079 void *argp1 = 0 ;
13080 int res1 = 0 ;
13081 PyObject * obj0 = 0 ;
13082 char * kwnames[] = {
13083 (char *) "logger", NULL
13084 };
13085
13086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13088 if (!SWIG_IsOK(res1)) {
13089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13090 }
13091 arg1 = reinterpret_cast< wxLog * >(argp1);
13092 {
13093 PyThreadState* __tstate = wxPyBeginAllowThreads();
13094 result = (wxLogChain *)new wxLogChain(arg1);
13095 wxPyEndAllowThreads(__tstate);
13096 if (PyErr_Occurred()) SWIG_fail;
13097 }
13098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13099 return resultobj;
13100 fail:
13101 return NULL;
13102 }
13103
13104
13105 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13106 PyObject *resultobj = 0;
13107 wxLogChain *arg1 = (wxLogChain *) 0 ;
13108 wxLog *arg2 = (wxLog *) 0 ;
13109 void *argp1 = 0 ;
13110 int res1 = 0 ;
13111 void *argp2 = 0 ;
13112 int res2 = 0 ;
13113 PyObject * obj0 = 0 ;
13114 PyObject * obj1 = 0 ;
13115 char * kwnames[] = {
13116 (char *) "self",(char *) "logger", NULL
13117 };
13118
13119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13121 if (!SWIG_IsOK(res1)) {
13122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13123 }
13124 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13125 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13126 if (!SWIG_IsOK(res2)) {
13127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13128 }
13129 arg2 = reinterpret_cast< wxLog * >(argp2);
13130 {
13131 PyThreadState* __tstate = wxPyBeginAllowThreads();
13132 (arg1)->SetLog(arg2);
13133 wxPyEndAllowThreads(__tstate);
13134 if (PyErr_Occurred()) SWIG_fail;
13135 }
13136 resultobj = SWIG_Py_Void();
13137 return resultobj;
13138 fail:
13139 return NULL;
13140 }
13141
13142
13143 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13144 PyObject *resultobj = 0;
13145 wxLogChain *arg1 = (wxLogChain *) 0 ;
13146 bool arg2 ;
13147 void *argp1 = 0 ;
13148 int res1 = 0 ;
13149 bool val2 ;
13150 int ecode2 = 0 ;
13151 PyObject * obj0 = 0 ;
13152 PyObject * obj1 = 0 ;
13153 char * kwnames[] = {
13154 (char *) "self",(char *) "bDoPass", NULL
13155 };
13156
13157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13159 if (!SWIG_IsOK(res1)) {
13160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13161 }
13162 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13163 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13164 if (!SWIG_IsOK(ecode2)) {
13165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13166 }
13167 arg2 = static_cast< bool >(val2);
13168 {
13169 PyThreadState* __tstate = wxPyBeginAllowThreads();
13170 (arg1)->PassMessages(arg2);
13171 wxPyEndAllowThreads(__tstate);
13172 if (PyErr_Occurred()) SWIG_fail;
13173 }
13174 resultobj = SWIG_Py_Void();
13175 return resultobj;
13176 fail:
13177 return NULL;
13178 }
13179
13180
13181 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13182 PyObject *resultobj = 0;
13183 wxLogChain *arg1 = (wxLogChain *) 0 ;
13184 bool result;
13185 void *argp1 = 0 ;
13186 int res1 = 0 ;
13187 PyObject *swig_obj[1] ;
13188
13189 if (!args) SWIG_fail;
13190 swig_obj[0] = args;
13191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13192 if (!SWIG_IsOK(res1)) {
13193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13194 }
13195 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13196 {
13197 PyThreadState* __tstate = wxPyBeginAllowThreads();
13198 result = (bool)(arg1)->IsPassingMessages();
13199 wxPyEndAllowThreads(__tstate);
13200 if (PyErr_Occurred()) SWIG_fail;
13201 }
13202 {
13203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13204 }
13205 return resultobj;
13206 fail:
13207 return NULL;
13208 }
13209
13210
13211 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13212 PyObject *resultobj = 0;
13213 wxLogChain *arg1 = (wxLogChain *) 0 ;
13214 wxLog *result = 0 ;
13215 void *argp1 = 0 ;
13216 int res1 = 0 ;
13217 PyObject *swig_obj[1] ;
13218
13219 if (!args) SWIG_fail;
13220 swig_obj[0] = args;
13221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13222 if (!SWIG_IsOK(res1)) {
13223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13224 }
13225 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13226 {
13227 PyThreadState* __tstate = wxPyBeginAllowThreads();
13228 result = (wxLog *)(arg1)->GetOldLog();
13229 wxPyEndAllowThreads(__tstate);
13230 if (PyErr_Occurred()) SWIG_fail;
13231 }
13232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13233 return resultobj;
13234 fail:
13235 return NULL;
13236 }
13237
13238
13239 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13240 PyObject *obj;
13241 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13242 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13243 return SWIG_Py_Void();
13244 }
13245
13246 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13247 return SWIG_Python_InitShadowInstance(args);
13248 }
13249
13250 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13251 PyObject *resultobj = 0;
13252 wxLogBuffer *result = 0 ;
13253
13254 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13255 {
13256 PyThreadState* __tstate = wxPyBeginAllowThreads();
13257 result = (wxLogBuffer *)new wxLogBuffer();
13258 wxPyEndAllowThreads(__tstate);
13259 if (PyErr_Occurred()) SWIG_fail;
13260 }
13261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13262 return resultobj;
13263 fail:
13264 return NULL;
13265 }
13266
13267
13268 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13269 PyObject *resultobj = 0;
13270 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13271 wxString *result = 0 ;
13272 void *argp1 = 0 ;
13273 int res1 = 0 ;
13274 PyObject *swig_obj[1] ;
13275
13276 if (!args) SWIG_fail;
13277 swig_obj[0] = args;
13278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13279 if (!SWIG_IsOK(res1)) {
13280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13281 }
13282 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13283 {
13284 PyThreadState* __tstate = wxPyBeginAllowThreads();
13285 {
13286 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13287 result = (wxString *) &_result_ref;
13288 }
13289 wxPyEndAllowThreads(__tstate);
13290 if (PyErr_Occurred()) SWIG_fail;
13291 }
13292 {
13293 #if wxUSE_UNICODE
13294 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13295 #else
13296 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13297 #endif
13298 }
13299 return resultobj;
13300 fail:
13301 return NULL;
13302 }
13303
13304
13305 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13306 PyObject *obj;
13307 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13308 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13309 return SWIG_Py_Void();
13310 }
13311
13312 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13313 return SWIG_Python_InitShadowInstance(args);
13314 }
13315
13316 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13317 PyObject *resultobj = 0;
13318 unsigned long result;
13319
13320 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13321 {
13322 PyThreadState* __tstate = wxPyBeginAllowThreads();
13323 result = (unsigned long)wxSysErrorCode();
13324 wxPyEndAllowThreads(__tstate);
13325 if (PyErr_Occurred()) SWIG_fail;
13326 }
13327 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13328 return resultobj;
13329 fail:
13330 return NULL;
13331 }
13332
13333
13334 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13335 PyObject *resultobj = 0;
13336 unsigned long arg1 = (unsigned long) 0 ;
13337 wxString result;
13338 unsigned long val1 ;
13339 int ecode1 = 0 ;
13340 PyObject * obj0 = 0 ;
13341 char * kwnames[] = {
13342 (char *) "nErrCode", NULL
13343 };
13344
13345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13346 if (obj0) {
13347 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13348 if (!SWIG_IsOK(ecode1)) {
13349 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13350 }
13351 arg1 = static_cast< unsigned long >(val1);
13352 }
13353 {
13354 PyThreadState* __tstate = wxPyBeginAllowThreads();
13355 result = wxSysErrorMsg(arg1);
13356 wxPyEndAllowThreads(__tstate);
13357 if (PyErr_Occurred()) SWIG_fail;
13358 }
13359 {
13360 #if wxUSE_UNICODE
13361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13362 #else
13363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13364 #endif
13365 }
13366 return resultobj;
13367 fail:
13368 return NULL;
13369 }
13370
13371
13372 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13373 PyObject *resultobj = 0;
13374 wxString *arg1 = 0 ;
13375 bool temp1 = false ;
13376 PyObject * obj0 = 0 ;
13377 char * kwnames[] = {
13378 (char *) "msg", NULL
13379 };
13380
13381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13382 {
13383 arg1 = wxString_in_helper(obj0);
13384 if (arg1 == NULL) SWIG_fail;
13385 temp1 = true;
13386 }
13387 {
13388 PyThreadState* __tstate = wxPyBeginAllowThreads();
13389 wxPyLogFatalError((wxString const &)*arg1);
13390 wxPyEndAllowThreads(__tstate);
13391 if (PyErr_Occurred()) SWIG_fail;
13392 }
13393 resultobj = SWIG_Py_Void();
13394 {
13395 if (temp1)
13396 delete arg1;
13397 }
13398 return resultobj;
13399 fail:
13400 {
13401 if (temp1)
13402 delete arg1;
13403 }
13404 return NULL;
13405 }
13406
13407
13408 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13409 PyObject *resultobj = 0;
13410 wxString *arg1 = 0 ;
13411 bool temp1 = false ;
13412 PyObject * obj0 = 0 ;
13413 char * kwnames[] = {
13414 (char *) "msg", NULL
13415 };
13416
13417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13418 {
13419 arg1 = wxString_in_helper(obj0);
13420 if (arg1 == NULL) SWIG_fail;
13421 temp1 = true;
13422 }
13423 {
13424 PyThreadState* __tstate = wxPyBeginAllowThreads();
13425 wxPyLogError((wxString const &)*arg1);
13426 wxPyEndAllowThreads(__tstate);
13427 if (PyErr_Occurred()) SWIG_fail;
13428 }
13429 resultobj = SWIG_Py_Void();
13430 {
13431 if (temp1)
13432 delete arg1;
13433 }
13434 return resultobj;
13435 fail:
13436 {
13437 if (temp1)
13438 delete arg1;
13439 }
13440 return NULL;
13441 }
13442
13443
13444 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13445 PyObject *resultobj = 0;
13446 wxString *arg1 = 0 ;
13447 bool temp1 = false ;
13448 PyObject * obj0 = 0 ;
13449 char * kwnames[] = {
13450 (char *) "msg", NULL
13451 };
13452
13453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13454 {
13455 arg1 = wxString_in_helper(obj0);
13456 if (arg1 == NULL) SWIG_fail;
13457 temp1 = true;
13458 }
13459 {
13460 PyThreadState* __tstate = wxPyBeginAllowThreads();
13461 wxPyLogWarning((wxString const &)*arg1);
13462 wxPyEndAllowThreads(__tstate);
13463 if (PyErr_Occurred()) SWIG_fail;
13464 }
13465 resultobj = SWIG_Py_Void();
13466 {
13467 if (temp1)
13468 delete arg1;
13469 }
13470 return resultobj;
13471 fail:
13472 {
13473 if (temp1)
13474 delete arg1;
13475 }
13476 return NULL;
13477 }
13478
13479
13480 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13481 PyObject *resultobj = 0;
13482 wxString *arg1 = 0 ;
13483 bool temp1 = false ;
13484 PyObject * obj0 = 0 ;
13485 char * kwnames[] = {
13486 (char *) "msg", NULL
13487 };
13488
13489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13490 {
13491 arg1 = wxString_in_helper(obj0);
13492 if (arg1 == NULL) SWIG_fail;
13493 temp1 = true;
13494 }
13495 {
13496 PyThreadState* __tstate = wxPyBeginAllowThreads();
13497 wxPyLogMessage((wxString const &)*arg1);
13498 wxPyEndAllowThreads(__tstate);
13499 if (PyErr_Occurred()) SWIG_fail;
13500 }
13501 resultobj = SWIG_Py_Void();
13502 {
13503 if (temp1)
13504 delete arg1;
13505 }
13506 return resultobj;
13507 fail:
13508 {
13509 if (temp1)
13510 delete arg1;
13511 }
13512 return NULL;
13513 }
13514
13515
13516 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13517 PyObject *resultobj = 0;
13518 wxString *arg1 = 0 ;
13519 bool temp1 = false ;
13520 PyObject * obj0 = 0 ;
13521 char * kwnames[] = {
13522 (char *) "msg", NULL
13523 };
13524
13525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13526 {
13527 arg1 = wxString_in_helper(obj0);
13528 if (arg1 == NULL) SWIG_fail;
13529 temp1 = true;
13530 }
13531 {
13532 PyThreadState* __tstate = wxPyBeginAllowThreads();
13533 wxPyLogInfo((wxString const &)*arg1);
13534 wxPyEndAllowThreads(__tstate);
13535 if (PyErr_Occurred()) SWIG_fail;
13536 }
13537 resultobj = SWIG_Py_Void();
13538 {
13539 if (temp1)
13540 delete arg1;
13541 }
13542 return resultobj;
13543 fail:
13544 {
13545 if (temp1)
13546 delete arg1;
13547 }
13548 return NULL;
13549 }
13550
13551
13552 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13553 PyObject *resultobj = 0;
13554 wxString *arg1 = 0 ;
13555 bool temp1 = false ;
13556 PyObject * obj0 = 0 ;
13557 char * kwnames[] = {
13558 (char *) "msg", NULL
13559 };
13560
13561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13562 {
13563 arg1 = wxString_in_helper(obj0);
13564 if (arg1 == NULL) SWIG_fail;
13565 temp1 = true;
13566 }
13567 {
13568 PyThreadState* __tstate = wxPyBeginAllowThreads();
13569 wxPyLogDebug((wxString const &)*arg1);
13570 wxPyEndAllowThreads(__tstate);
13571 if (PyErr_Occurred()) SWIG_fail;
13572 }
13573 resultobj = SWIG_Py_Void();
13574 {
13575 if (temp1)
13576 delete arg1;
13577 }
13578 return resultobj;
13579 fail:
13580 {
13581 if (temp1)
13582 delete arg1;
13583 }
13584 return NULL;
13585 }
13586
13587
13588 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13589 PyObject *resultobj = 0;
13590 wxString *arg1 = 0 ;
13591 bool temp1 = false ;
13592 PyObject * obj0 = 0 ;
13593 char * kwnames[] = {
13594 (char *) "msg", NULL
13595 };
13596
13597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13598 {
13599 arg1 = wxString_in_helper(obj0);
13600 if (arg1 == NULL) SWIG_fail;
13601 temp1 = true;
13602 }
13603 {
13604 PyThreadState* __tstate = wxPyBeginAllowThreads();
13605 wxPyLogVerbose((wxString const &)*arg1);
13606 wxPyEndAllowThreads(__tstate);
13607 if (PyErr_Occurred()) SWIG_fail;
13608 }
13609 resultobj = SWIG_Py_Void();
13610 {
13611 if (temp1)
13612 delete arg1;
13613 }
13614 return resultobj;
13615 fail:
13616 {
13617 if (temp1)
13618 delete arg1;
13619 }
13620 return NULL;
13621 }
13622
13623
13624 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13625 PyObject *resultobj = 0;
13626 wxString *arg1 = 0 ;
13627 bool temp1 = false ;
13628 PyObject * obj0 = 0 ;
13629 char * kwnames[] = {
13630 (char *) "msg", NULL
13631 };
13632
13633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13634 {
13635 arg1 = wxString_in_helper(obj0);
13636 if (arg1 == NULL) SWIG_fail;
13637 temp1 = true;
13638 }
13639 {
13640 PyThreadState* __tstate = wxPyBeginAllowThreads();
13641 wxPyLogStatus((wxString const &)*arg1);
13642 wxPyEndAllowThreads(__tstate);
13643 if (PyErr_Occurred()) SWIG_fail;
13644 }
13645 resultobj = SWIG_Py_Void();
13646 {
13647 if (temp1)
13648 delete arg1;
13649 }
13650 return resultobj;
13651 fail:
13652 {
13653 if (temp1)
13654 delete arg1;
13655 }
13656 return NULL;
13657 }
13658
13659
13660 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13661 PyObject *resultobj = 0;
13662 wxFrame *arg1 = (wxFrame *) 0 ;
13663 wxString *arg2 = 0 ;
13664 void *argp1 = 0 ;
13665 int res1 = 0 ;
13666 bool temp2 = false ;
13667 PyObject * obj0 = 0 ;
13668 PyObject * obj1 = 0 ;
13669 char * kwnames[] = {
13670 (char *) "pFrame",(char *) "msg", NULL
13671 };
13672
13673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13675 if (!SWIG_IsOK(res1)) {
13676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13677 }
13678 arg1 = reinterpret_cast< wxFrame * >(argp1);
13679 {
13680 arg2 = wxString_in_helper(obj1);
13681 if (arg2 == NULL) SWIG_fail;
13682 temp2 = true;
13683 }
13684 {
13685 PyThreadState* __tstate = wxPyBeginAllowThreads();
13686 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13687 wxPyEndAllowThreads(__tstate);
13688 if (PyErr_Occurred()) SWIG_fail;
13689 }
13690 resultobj = SWIG_Py_Void();
13691 {
13692 if (temp2)
13693 delete arg2;
13694 }
13695 return resultobj;
13696 fail:
13697 {
13698 if (temp2)
13699 delete arg2;
13700 }
13701 return NULL;
13702 }
13703
13704
13705 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13706 PyObject *resultobj = 0;
13707 wxString *arg1 = 0 ;
13708 bool temp1 = false ;
13709 PyObject * obj0 = 0 ;
13710 char * kwnames[] = {
13711 (char *) "msg", NULL
13712 };
13713
13714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13715 {
13716 arg1 = wxString_in_helper(obj0);
13717 if (arg1 == NULL) SWIG_fail;
13718 temp1 = true;
13719 }
13720 {
13721 PyThreadState* __tstate = wxPyBeginAllowThreads();
13722 wxPyLogSysError((wxString const &)*arg1);
13723 wxPyEndAllowThreads(__tstate);
13724 if (PyErr_Occurred()) SWIG_fail;
13725 }
13726 resultobj = SWIG_Py_Void();
13727 {
13728 if (temp1)
13729 delete arg1;
13730 }
13731 return resultobj;
13732 fail:
13733 {
13734 if (temp1)
13735 delete arg1;
13736 }
13737 return NULL;
13738 }
13739
13740
13741 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13742 PyObject *resultobj = 0;
13743 unsigned long arg1 ;
13744 wxString *arg2 = 0 ;
13745 unsigned long val1 ;
13746 int ecode1 = 0 ;
13747 bool temp2 = false ;
13748 PyObject * obj0 = 0 ;
13749 PyObject * obj1 = 0 ;
13750 char * kwnames[] = {
13751 (char *) "level",(char *) "msg", NULL
13752 };
13753
13754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13755 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13756 if (!SWIG_IsOK(ecode1)) {
13757 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13758 }
13759 arg1 = static_cast< unsigned long >(val1);
13760 {
13761 arg2 = wxString_in_helper(obj1);
13762 if (arg2 == NULL) SWIG_fail;
13763 temp2 = true;
13764 }
13765 {
13766 PyThreadState* __tstate = wxPyBeginAllowThreads();
13767 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13768 wxPyEndAllowThreads(__tstate);
13769 if (PyErr_Occurred()) SWIG_fail;
13770 }
13771 resultobj = SWIG_Py_Void();
13772 {
13773 if (temp2)
13774 delete arg2;
13775 }
13776 return resultobj;
13777 fail:
13778 {
13779 if (temp2)
13780 delete arg2;
13781 }
13782 return NULL;
13783 }
13784
13785
13786 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13787 PyObject *resultobj = 0;
13788 unsigned long arg1 ;
13789 wxString *arg2 = 0 ;
13790 unsigned long val1 ;
13791 int ecode1 = 0 ;
13792 bool temp2 = false ;
13793
13794 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13795 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13796 if (!SWIG_IsOK(ecode1)) {
13797 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13798 }
13799 arg1 = static_cast< unsigned long >(val1);
13800 {
13801 arg2 = wxString_in_helper(swig_obj[1]);
13802 if (arg2 == NULL) SWIG_fail;
13803 temp2 = true;
13804 }
13805 {
13806 PyThreadState* __tstate = wxPyBeginAllowThreads();
13807 wxPyLogTrace(arg1,(wxString const &)*arg2);
13808 wxPyEndAllowThreads(__tstate);
13809 if (PyErr_Occurred()) SWIG_fail;
13810 }
13811 resultobj = SWIG_Py_Void();
13812 {
13813 if (temp2)
13814 delete arg2;
13815 }
13816 return resultobj;
13817 fail:
13818 {
13819 if (temp2)
13820 delete arg2;
13821 }
13822 return NULL;
13823 }
13824
13825
13826 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13827 PyObject *resultobj = 0;
13828 wxString *arg1 = 0 ;
13829 wxString *arg2 = 0 ;
13830 bool temp1 = false ;
13831 bool temp2 = false ;
13832
13833 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13834 {
13835 arg1 = wxString_in_helper(swig_obj[0]);
13836 if (arg1 == NULL) SWIG_fail;
13837 temp1 = true;
13838 }
13839 {
13840 arg2 = wxString_in_helper(swig_obj[1]);
13841 if (arg2 == NULL) SWIG_fail;
13842 temp2 = true;
13843 }
13844 {
13845 PyThreadState* __tstate = wxPyBeginAllowThreads();
13846 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
13847 wxPyEndAllowThreads(__tstate);
13848 if (PyErr_Occurred()) SWIG_fail;
13849 }
13850 resultobj = SWIG_Py_Void();
13851 {
13852 if (temp1)
13853 delete arg1;
13854 }
13855 {
13856 if (temp2)
13857 delete arg2;
13858 }
13859 return resultobj;
13860 fail:
13861 {
13862 if (temp1)
13863 delete arg1;
13864 }
13865 {
13866 if (temp2)
13867 delete arg2;
13868 }
13869 return NULL;
13870 }
13871
13872
13873 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
13874 int argc;
13875 PyObject *argv[3];
13876
13877 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
13878 --argc;
13879 if (argc == 2) {
13880 int _v = 0;
13881 {
13882 {
13883 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
13884 }
13885 }
13886 if (!_v) goto check_1;
13887 return _wrap_LogTrace__SWIG_1(self, argc, argv);
13888 }
13889 check_1:
13890
13891 if (argc == 2) {
13892 return _wrap_LogTrace__SWIG_0(self, argc, argv);
13893 }
13894
13895 fail:
13896 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
13897 return NULL;
13898 }
13899
13900
13901 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13902 PyObject *resultobj = 0;
13903 wxString *arg1 = 0 ;
13904 wxString *arg2 = 0 ;
13905 bool temp1 = false ;
13906 bool temp2 = false ;
13907 PyObject * obj0 = 0 ;
13908 PyObject * obj1 = 0 ;
13909 char * kwnames[] = {
13910 (char *) "title",(char *) "text", NULL
13911 };
13912
13913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
13914 {
13915 arg1 = wxString_in_helper(obj0);
13916 if (arg1 == NULL) SWIG_fail;
13917 temp1 = true;
13918 }
13919 {
13920 arg2 = wxString_in_helper(obj1);
13921 if (arg2 == NULL) SWIG_fail;
13922 temp2 = true;
13923 }
13924 {
13925 PyThreadState* __tstate = wxPyBeginAllowThreads();
13926 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
13927 wxPyEndAllowThreads(__tstate);
13928 if (PyErr_Occurred()) SWIG_fail;
13929 }
13930 resultobj = SWIG_Py_Void();
13931 {
13932 if (temp1)
13933 delete arg1;
13934 }
13935 {
13936 if (temp2)
13937 delete arg2;
13938 }
13939 return resultobj;
13940 fail:
13941 {
13942 if (temp1)
13943 delete arg1;
13944 }
13945 {
13946 if (temp2)
13947 delete arg2;
13948 }
13949 return NULL;
13950 }
13951
13952
13953 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13954 PyObject *resultobj = 0;
13955 wxLogNull *result = 0 ;
13956
13957 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
13958 {
13959 PyThreadState* __tstate = wxPyBeginAllowThreads();
13960 result = (wxLogNull *)new wxLogNull();
13961 wxPyEndAllowThreads(__tstate);
13962 if (PyErr_Occurred()) SWIG_fail;
13963 }
13964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
13965 return resultobj;
13966 fail:
13967 return NULL;
13968 }
13969
13970
13971 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13972 PyObject *resultobj = 0;
13973 wxLogNull *arg1 = (wxLogNull *) 0 ;
13974 void *argp1 = 0 ;
13975 int res1 = 0 ;
13976 PyObject *swig_obj[1] ;
13977
13978 if (!args) SWIG_fail;
13979 swig_obj[0] = args;
13980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
13981 if (!SWIG_IsOK(res1)) {
13982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
13983 }
13984 arg1 = reinterpret_cast< wxLogNull * >(argp1);
13985 {
13986 PyThreadState* __tstate = wxPyBeginAllowThreads();
13987 delete arg1;
13988
13989 wxPyEndAllowThreads(__tstate);
13990 if (PyErr_Occurred()) SWIG_fail;
13991 }
13992 resultobj = SWIG_Py_Void();
13993 return resultobj;
13994 fail:
13995 return NULL;
13996 }
13997
13998
13999 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14000 PyObject *obj;
14001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14002 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14003 return SWIG_Py_Void();
14004 }
14005
14006 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14007 return SWIG_Python_InitShadowInstance(args);
14008 }
14009
14010 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14011 PyObject *resultobj = 0;
14012 wxPyLog *result = 0 ;
14013
14014 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14015 {
14016 PyThreadState* __tstate = wxPyBeginAllowThreads();
14017 result = (wxPyLog *)new wxPyLog();
14018 wxPyEndAllowThreads(__tstate);
14019 if (PyErr_Occurred()) SWIG_fail;
14020 }
14021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14022 return resultobj;
14023 fail:
14024 return NULL;
14025 }
14026
14027
14028 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14029 PyObject *resultobj = 0;
14030 wxPyLog *arg1 = (wxPyLog *) 0 ;
14031 PyObject *arg2 = (PyObject *) 0 ;
14032 PyObject *arg3 = (PyObject *) 0 ;
14033 void *argp1 = 0 ;
14034 int res1 = 0 ;
14035 PyObject * obj0 = 0 ;
14036 PyObject * obj1 = 0 ;
14037 PyObject * obj2 = 0 ;
14038 char * kwnames[] = {
14039 (char *) "self",(char *) "self",(char *) "_class", NULL
14040 };
14041
14042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14044 if (!SWIG_IsOK(res1)) {
14045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14046 }
14047 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14048 arg2 = obj1;
14049 arg3 = obj2;
14050 {
14051 PyThreadState* __tstate = wxPyBeginAllowThreads();
14052 (arg1)->_setCallbackInfo(arg2,arg3);
14053 wxPyEndAllowThreads(__tstate);
14054 if (PyErr_Occurred()) SWIG_fail;
14055 }
14056 resultobj = SWIG_Py_Void();
14057 return resultobj;
14058 fail:
14059 return NULL;
14060 }
14061
14062
14063 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14064 PyObject *obj;
14065 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14066 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14067 return SWIG_Py_Void();
14068 }
14069
14070 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14071 return SWIG_Python_InitShadowInstance(args);
14072 }
14073
14074 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14075 PyObject *resultobj = 0;
14076 int arg1 ;
14077 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14078 int arg3 = (int) wxKILL_NOCHILDREN ;
14079 wxKillError result;
14080 int val1 ;
14081 int ecode1 = 0 ;
14082 int val2 ;
14083 int ecode2 = 0 ;
14084 int val3 ;
14085 int ecode3 = 0 ;
14086 PyObject * obj0 = 0 ;
14087 PyObject * obj1 = 0 ;
14088 PyObject * obj2 = 0 ;
14089 char * kwnames[] = {
14090 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14091 };
14092
14093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14094 ecode1 = SWIG_AsVal_int(obj0, &val1);
14095 if (!SWIG_IsOK(ecode1)) {
14096 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14097 }
14098 arg1 = static_cast< int >(val1);
14099 if (obj1) {
14100 ecode2 = SWIG_AsVal_int(obj1, &val2);
14101 if (!SWIG_IsOK(ecode2)) {
14102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14103 }
14104 arg2 = static_cast< wxSignal >(val2);
14105 }
14106 if (obj2) {
14107 ecode3 = SWIG_AsVal_int(obj2, &val3);
14108 if (!SWIG_IsOK(ecode3)) {
14109 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14110 }
14111 arg3 = static_cast< int >(val3);
14112 }
14113 {
14114 PyThreadState* __tstate = wxPyBeginAllowThreads();
14115 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14116 wxPyEndAllowThreads(__tstate);
14117 if (PyErr_Occurred()) SWIG_fail;
14118 }
14119 resultobj = SWIG_From_int(static_cast< int >(result));
14120 return resultobj;
14121 fail:
14122 return NULL;
14123 }
14124
14125
14126 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14127 PyObject *resultobj = 0;
14128 int arg1 ;
14129 bool result;
14130 int val1 ;
14131 int ecode1 = 0 ;
14132 PyObject * obj0 = 0 ;
14133 char * kwnames[] = {
14134 (char *) "pid", NULL
14135 };
14136
14137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14138 ecode1 = SWIG_AsVal_int(obj0, &val1);
14139 if (!SWIG_IsOK(ecode1)) {
14140 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14141 }
14142 arg1 = static_cast< int >(val1);
14143 {
14144 PyThreadState* __tstate = wxPyBeginAllowThreads();
14145 result = (bool)wxPyProcess::Exists(arg1);
14146 wxPyEndAllowThreads(__tstate);
14147 if (PyErr_Occurred()) SWIG_fail;
14148 }
14149 {
14150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14151 }
14152 return resultobj;
14153 fail:
14154 return NULL;
14155 }
14156
14157
14158 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14159 PyObject *resultobj = 0;
14160 wxString *arg1 = 0 ;
14161 int arg2 = (int) wxEXEC_ASYNC ;
14162 wxPyProcess *result = 0 ;
14163 bool temp1 = false ;
14164 int val2 ;
14165 int ecode2 = 0 ;
14166 PyObject * obj0 = 0 ;
14167 PyObject * obj1 = 0 ;
14168 char * kwnames[] = {
14169 (char *) "cmd",(char *) "flags", NULL
14170 };
14171
14172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14173 {
14174 arg1 = wxString_in_helper(obj0);
14175 if (arg1 == NULL) SWIG_fail;
14176 temp1 = true;
14177 }
14178 if (obj1) {
14179 ecode2 = SWIG_AsVal_int(obj1, &val2);
14180 if (!SWIG_IsOK(ecode2)) {
14181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14182 }
14183 arg2 = static_cast< int >(val2);
14184 }
14185 {
14186 PyThreadState* __tstate = wxPyBeginAllowThreads();
14187 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14188 wxPyEndAllowThreads(__tstate);
14189 if (PyErr_Occurred()) SWIG_fail;
14190 }
14191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14192 {
14193 if (temp1)
14194 delete arg1;
14195 }
14196 return resultobj;
14197 fail:
14198 {
14199 if (temp1)
14200 delete arg1;
14201 }
14202 return NULL;
14203 }
14204
14205
14206 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14207 PyObject *resultobj = 0;
14208 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14209 int arg2 = (int) -1 ;
14210 wxPyProcess *result = 0 ;
14211 void *argp1 = 0 ;
14212 int res1 = 0 ;
14213 int val2 ;
14214 int ecode2 = 0 ;
14215 PyObject * obj0 = 0 ;
14216 PyObject * obj1 = 0 ;
14217 char * kwnames[] = {
14218 (char *) "parent",(char *) "id", NULL
14219 };
14220
14221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14222 if (obj0) {
14223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14224 if (!SWIG_IsOK(res1)) {
14225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14226 }
14227 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14228 }
14229 if (obj1) {
14230 ecode2 = SWIG_AsVal_int(obj1, &val2);
14231 if (!SWIG_IsOK(ecode2)) {
14232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14233 }
14234 arg2 = static_cast< int >(val2);
14235 }
14236 {
14237 PyThreadState* __tstate = wxPyBeginAllowThreads();
14238 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14239 wxPyEndAllowThreads(__tstate);
14240 if (PyErr_Occurred()) SWIG_fail;
14241 }
14242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14243 return resultobj;
14244 fail:
14245 return NULL;
14246 }
14247
14248
14249 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14250 PyObject *resultobj = 0;
14251 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14252 PyObject *arg2 = (PyObject *) 0 ;
14253 PyObject *arg3 = (PyObject *) 0 ;
14254 void *argp1 = 0 ;
14255 int res1 = 0 ;
14256 PyObject * obj0 = 0 ;
14257 PyObject * obj1 = 0 ;
14258 PyObject * obj2 = 0 ;
14259 char * kwnames[] = {
14260 (char *) "self",(char *) "self",(char *) "_class", NULL
14261 };
14262
14263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14265 if (!SWIG_IsOK(res1)) {
14266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14267 }
14268 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14269 arg2 = obj1;
14270 arg3 = obj2;
14271 {
14272 PyThreadState* __tstate = wxPyBeginAllowThreads();
14273 (arg1)->_setCallbackInfo(arg2,arg3);
14274 wxPyEndAllowThreads(__tstate);
14275 if (PyErr_Occurred()) SWIG_fail;
14276 }
14277 resultobj = SWIG_Py_Void();
14278 return resultobj;
14279 fail:
14280 return NULL;
14281 }
14282
14283
14284 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14285 PyObject *resultobj = 0;
14286 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14287 int arg2 ;
14288 int arg3 ;
14289 void *argp1 = 0 ;
14290 int res1 = 0 ;
14291 int val2 ;
14292 int ecode2 = 0 ;
14293 int val3 ;
14294 int ecode3 = 0 ;
14295 PyObject * obj0 = 0 ;
14296 PyObject * obj1 = 0 ;
14297 PyObject * obj2 = 0 ;
14298 char * kwnames[] = {
14299 (char *) "self",(char *) "pid",(char *) "status", NULL
14300 };
14301
14302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14304 if (!SWIG_IsOK(res1)) {
14305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14306 }
14307 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14308 ecode2 = SWIG_AsVal_int(obj1, &val2);
14309 if (!SWIG_IsOK(ecode2)) {
14310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14311 }
14312 arg2 = static_cast< int >(val2);
14313 ecode3 = SWIG_AsVal_int(obj2, &val3);
14314 if (!SWIG_IsOK(ecode3)) {
14315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14316 }
14317 arg3 = static_cast< int >(val3);
14318 {
14319 PyThreadState* __tstate = wxPyBeginAllowThreads();
14320 (arg1)->OnTerminate(arg2,arg3);
14321 wxPyEndAllowThreads(__tstate);
14322 if (PyErr_Occurred()) SWIG_fail;
14323 }
14324 resultobj = SWIG_Py_Void();
14325 return resultobj;
14326 fail:
14327 return NULL;
14328 }
14329
14330
14331 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14332 PyObject *resultobj = 0;
14333 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14334 void *argp1 = 0 ;
14335 int res1 = 0 ;
14336 PyObject *swig_obj[1] ;
14337
14338 if (!args) SWIG_fail;
14339 swig_obj[0] = args;
14340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14341 if (!SWIG_IsOK(res1)) {
14342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14343 }
14344 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14345 {
14346 PyThreadState* __tstate = wxPyBeginAllowThreads();
14347 (arg1)->Redirect();
14348 wxPyEndAllowThreads(__tstate);
14349 if (PyErr_Occurred()) SWIG_fail;
14350 }
14351 resultobj = SWIG_Py_Void();
14352 return resultobj;
14353 fail:
14354 return NULL;
14355 }
14356
14357
14358 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14359 PyObject *resultobj = 0;
14360 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14361 bool result;
14362 void *argp1 = 0 ;
14363 int res1 = 0 ;
14364 PyObject *swig_obj[1] ;
14365
14366 if (!args) SWIG_fail;
14367 swig_obj[0] = args;
14368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14369 if (!SWIG_IsOK(res1)) {
14370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14371 }
14372 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14373 {
14374 PyThreadState* __tstate = wxPyBeginAllowThreads();
14375 result = (bool)(arg1)->IsRedirected();
14376 wxPyEndAllowThreads(__tstate);
14377 if (PyErr_Occurred()) SWIG_fail;
14378 }
14379 {
14380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14381 }
14382 return resultobj;
14383 fail:
14384 return NULL;
14385 }
14386
14387
14388 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14389 PyObject *resultobj = 0;
14390 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14391 void *argp1 = 0 ;
14392 int res1 = 0 ;
14393 PyObject *swig_obj[1] ;
14394
14395 if (!args) SWIG_fail;
14396 swig_obj[0] = args;
14397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14398 if (!SWIG_IsOK(res1)) {
14399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14400 }
14401 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14402 {
14403 PyThreadState* __tstate = wxPyBeginAllowThreads();
14404 (arg1)->Detach();
14405 wxPyEndAllowThreads(__tstate);
14406 if (PyErr_Occurred()) SWIG_fail;
14407 }
14408 resultobj = SWIG_Py_Void();
14409 return resultobj;
14410 fail:
14411 return NULL;
14412 }
14413
14414
14415 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14416 PyObject *resultobj = 0;
14417 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14418 wxInputStream *result = 0 ;
14419 void *argp1 = 0 ;
14420 int res1 = 0 ;
14421 PyObject *swig_obj[1] ;
14422
14423 if (!args) SWIG_fail;
14424 swig_obj[0] = args;
14425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14426 if (!SWIG_IsOK(res1)) {
14427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14428 }
14429 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14430 {
14431 PyThreadState* __tstate = wxPyBeginAllowThreads();
14432 result = (wxInputStream *)(arg1)->GetInputStream();
14433 wxPyEndAllowThreads(__tstate);
14434 if (PyErr_Occurred()) SWIG_fail;
14435 }
14436 {
14437 wxPyInputStream * _ptr = NULL;
14438
14439 if (result) {
14440 _ptr = new wxPyInputStream(result);
14441 }
14442 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14443 }
14444 return resultobj;
14445 fail:
14446 return NULL;
14447 }
14448
14449
14450 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14451 PyObject *resultobj = 0;
14452 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14453 wxInputStream *result = 0 ;
14454 void *argp1 = 0 ;
14455 int res1 = 0 ;
14456 PyObject *swig_obj[1] ;
14457
14458 if (!args) SWIG_fail;
14459 swig_obj[0] = args;
14460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14461 if (!SWIG_IsOK(res1)) {
14462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14463 }
14464 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14465 {
14466 PyThreadState* __tstate = wxPyBeginAllowThreads();
14467 result = (wxInputStream *)(arg1)->GetErrorStream();
14468 wxPyEndAllowThreads(__tstate);
14469 if (PyErr_Occurred()) SWIG_fail;
14470 }
14471 {
14472 wxPyInputStream * _ptr = NULL;
14473
14474 if (result) {
14475 _ptr = new wxPyInputStream(result);
14476 }
14477 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14478 }
14479 return resultobj;
14480 fail:
14481 return NULL;
14482 }
14483
14484
14485 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14486 PyObject *resultobj = 0;
14487 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14488 wxOutputStream *result = 0 ;
14489 void *argp1 = 0 ;
14490 int res1 = 0 ;
14491 PyObject *swig_obj[1] ;
14492
14493 if (!args) SWIG_fail;
14494 swig_obj[0] = args;
14495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14496 if (!SWIG_IsOK(res1)) {
14497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14498 }
14499 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14500 {
14501 PyThreadState* __tstate = wxPyBeginAllowThreads();
14502 result = (wxOutputStream *)(arg1)->GetOutputStream();
14503 wxPyEndAllowThreads(__tstate);
14504 if (PyErr_Occurred()) SWIG_fail;
14505 }
14506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14507 return resultobj;
14508 fail:
14509 return NULL;
14510 }
14511
14512
14513 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14514 PyObject *resultobj = 0;
14515 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14516 void *argp1 = 0 ;
14517 int res1 = 0 ;
14518 PyObject *swig_obj[1] ;
14519
14520 if (!args) SWIG_fail;
14521 swig_obj[0] = args;
14522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14523 if (!SWIG_IsOK(res1)) {
14524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14525 }
14526 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14527 {
14528 PyThreadState* __tstate = wxPyBeginAllowThreads();
14529 (arg1)->CloseOutput();
14530 wxPyEndAllowThreads(__tstate);
14531 if (PyErr_Occurred()) SWIG_fail;
14532 }
14533 resultobj = SWIG_Py_Void();
14534 return resultobj;
14535 fail:
14536 return NULL;
14537 }
14538
14539
14540 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14541 PyObject *resultobj = 0;
14542 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14543 bool result;
14544 void *argp1 = 0 ;
14545 int res1 = 0 ;
14546 PyObject *swig_obj[1] ;
14547
14548 if (!args) SWIG_fail;
14549 swig_obj[0] = args;
14550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14551 if (!SWIG_IsOK(res1)) {
14552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14553 }
14554 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14555 {
14556 PyThreadState* __tstate = wxPyBeginAllowThreads();
14557 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14558 wxPyEndAllowThreads(__tstate);
14559 if (PyErr_Occurred()) SWIG_fail;
14560 }
14561 {
14562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14563 }
14564 return resultobj;
14565 fail:
14566 return NULL;
14567 }
14568
14569
14570 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14571 PyObject *resultobj = 0;
14572 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14573 bool result;
14574 void *argp1 = 0 ;
14575 int res1 = 0 ;
14576 PyObject *swig_obj[1] ;
14577
14578 if (!args) SWIG_fail;
14579 swig_obj[0] = args;
14580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14581 if (!SWIG_IsOK(res1)) {
14582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14583 }
14584 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14585 {
14586 PyThreadState* __tstate = wxPyBeginAllowThreads();
14587 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14588 wxPyEndAllowThreads(__tstate);
14589 if (PyErr_Occurred()) SWIG_fail;
14590 }
14591 {
14592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14593 }
14594 return resultobj;
14595 fail:
14596 return NULL;
14597 }
14598
14599
14600 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14601 PyObject *resultobj = 0;
14602 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14603 bool result;
14604 void *argp1 = 0 ;
14605 int res1 = 0 ;
14606 PyObject *swig_obj[1] ;
14607
14608 if (!args) SWIG_fail;
14609 swig_obj[0] = args;
14610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14611 if (!SWIG_IsOK(res1)) {
14612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14613 }
14614 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14615 {
14616 PyThreadState* __tstate = wxPyBeginAllowThreads();
14617 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14618 wxPyEndAllowThreads(__tstate);
14619 if (PyErr_Occurred()) SWIG_fail;
14620 }
14621 {
14622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14623 }
14624 return resultobj;
14625 fail:
14626 return NULL;
14627 }
14628
14629
14630 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14631 PyObject *obj;
14632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14633 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14634 return SWIG_Py_Void();
14635 }
14636
14637 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14638 return SWIG_Python_InitShadowInstance(args);
14639 }
14640
14641 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14642 PyObject *resultobj = 0;
14643 int arg1 = (int) 0 ;
14644 int arg2 = (int) 0 ;
14645 int arg3 = (int) 0 ;
14646 wxProcessEvent *result = 0 ;
14647 int val1 ;
14648 int ecode1 = 0 ;
14649 int val2 ;
14650 int ecode2 = 0 ;
14651 int val3 ;
14652 int ecode3 = 0 ;
14653 PyObject * obj0 = 0 ;
14654 PyObject * obj1 = 0 ;
14655 PyObject * obj2 = 0 ;
14656 char * kwnames[] = {
14657 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14658 };
14659
14660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14661 if (obj0) {
14662 ecode1 = SWIG_AsVal_int(obj0, &val1);
14663 if (!SWIG_IsOK(ecode1)) {
14664 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14665 }
14666 arg1 = static_cast< int >(val1);
14667 }
14668 if (obj1) {
14669 ecode2 = SWIG_AsVal_int(obj1, &val2);
14670 if (!SWIG_IsOK(ecode2)) {
14671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14672 }
14673 arg2 = static_cast< int >(val2);
14674 }
14675 if (obj2) {
14676 ecode3 = SWIG_AsVal_int(obj2, &val3);
14677 if (!SWIG_IsOK(ecode3)) {
14678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14679 }
14680 arg3 = static_cast< int >(val3);
14681 }
14682 {
14683 PyThreadState* __tstate = wxPyBeginAllowThreads();
14684 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14685 wxPyEndAllowThreads(__tstate);
14686 if (PyErr_Occurred()) SWIG_fail;
14687 }
14688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14689 return resultobj;
14690 fail:
14691 return NULL;
14692 }
14693
14694
14695 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14696 PyObject *resultobj = 0;
14697 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14698 int result;
14699 void *argp1 = 0 ;
14700 int res1 = 0 ;
14701 PyObject *swig_obj[1] ;
14702
14703 if (!args) SWIG_fail;
14704 swig_obj[0] = args;
14705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14706 if (!SWIG_IsOK(res1)) {
14707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14708 }
14709 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14710 {
14711 PyThreadState* __tstate = wxPyBeginAllowThreads();
14712 result = (int)(arg1)->GetPid();
14713 wxPyEndAllowThreads(__tstate);
14714 if (PyErr_Occurred()) SWIG_fail;
14715 }
14716 resultobj = SWIG_From_int(static_cast< int >(result));
14717 return resultobj;
14718 fail:
14719 return NULL;
14720 }
14721
14722
14723 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14724 PyObject *resultobj = 0;
14725 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14726 int result;
14727 void *argp1 = 0 ;
14728 int res1 = 0 ;
14729 PyObject *swig_obj[1] ;
14730
14731 if (!args) SWIG_fail;
14732 swig_obj[0] = args;
14733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14734 if (!SWIG_IsOK(res1)) {
14735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14736 }
14737 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14738 {
14739 PyThreadState* __tstate = wxPyBeginAllowThreads();
14740 result = (int)(arg1)->GetExitCode();
14741 wxPyEndAllowThreads(__tstate);
14742 if (PyErr_Occurred()) SWIG_fail;
14743 }
14744 resultobj = SWIG_From_int(static_cast< int >(result));
14745 return resultobj;
14746 fail:
14747 return NULL;
14748 }
14749
14750
14751 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14752 PyObject *resultobj = 0;
14753 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14754 int arg2 ;
14755 void *argp1 = 0 ;
14756 int res1 = 0 ;
14757 int val2 ;
14758 int ecode2 = 0 ;
14759 PyObject *swig_obj[2] ;
14760
14761 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14763 if (!SWIG_IsOK(res1)) {
14764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14765 }
14766 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14767 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14768 if (!SWIG_IsOK(ecode2)) {
14769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14770 }
14771 arg2 = static_cast< int >(val2);
14772 if (arg1) (arg1)->m_pid = arg2;
14773
14774 resultobj = SWIG_Py_Void();
14775 return resultobj;
14776 fail:
14777 return NULL;
14778 }
14779
14780
14781 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14782 PyObject *resultobj = 0;
14783 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14784 int result;
14785 void *argp1 = 0 ;
14786 int res1 = 0 ;
14787 PyObject *swig_obj[1] ;
14788
14789 if (!args) SWIG_fail;
14790 swig_obj[0] = args;
14791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14792 if (!SWIG_IsOK(res1)) {
14793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14794 }
14795 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14796 result = (int) ((arg1)->m_pid);
14797 resultobj = SWIG_From_int(static_cast< int >(result));
14798 return resultobj;
14799 fail:
14800 return NULL;
14801 }
14802
14803
14804 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14805 PyObject *resultobj = 0;
14806 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14807 int arg2 ;
14808 void *argp1 = 0 ;
14809 int res1 = 0 ;
14810 int val2 ;
14811 int ecode2 = 0 ;
14812 PyObject *swig_obj[2] ;
14813
14814 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
14815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14816 if (!SWIG_IsOK(res1)) {
14817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14818 }
14819 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14820 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14821 if (!SWIG_IsOK(ecode2)) {
14822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
14823 }
14824 arg2 = static_cast< int >(val2);
14825 if (arg1) (arg1)->m_exitcode = arg2;
14826
14827 resultobj = SWIG_Py_Void();
14828 return resultobj;
14829 fail:
14830 return NULL;
14831 }
14832
14833
14834 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14835 PyObject *resultobj = 0;
14836 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14837 int result;
14838 void *argp1 = 0 ;
14839 int res1 = 0 ;
14840 PyObject *swig_obj[1] ;
14841
14842 if (!args) SWIG_fail;
14843 swig_obj[0] = args;
14844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14845 if (!SWIG_IsOK(res1)) {
14846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14847 }
14848 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14849 result = (int) ((arg1)->m_exitcode);
14850 resultobj = SWIG_From_int(static_cast< int >(result));
14851 return resultobj;
14852 fail:
14853 return NULL;
14854 }
14855
14856
14857 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14858 PyObject *obj;
14859 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14860 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
14861 return SWIG_Py_Void();
14862 }
14863
14864 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14865 return SWIG_Python_InitShadowInstance(args);
14866 }
14867
14868 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14869 PyObject *resultobj = 0;
14870 wxString *arg1 = 0 ;
14871 int arg2 = (int) wxEXEC_ASYNC ;
14872 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
14873 long result;
14874 bool temp1 = false ;
14875 int val2 ;
14876 int ecode2 = 0 ;
14877 void *argp3 = 0 ;
14878 int res3 = 0 ;
14879 PyObject * obj0 = 0 ;
14880 PyObject * obj1 = 0 ;
14881 PyObject * obj2 = 0 ;
14882 char * kwnames[] = {
14883 (char *) "command",(char *) "flags",(char *) "process", NULL
14884 };
14885
14886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14887 {
14888 arg1 = wxString_in_helper(obj0);
14889 if (arg1 == NULL) SWIG_fail;
14890 temp1 = true;
14891 }
14892 if (obj1) {
14893 ecode2 = SWIG_AsVal_int(obj1, &val2);
14894 if (!SWIG_IsOK(ecode2)) {
14895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
14896 }
14897 arg2 = static_cast< int >(val2);
14898 }
14899 if (obj2) {
14900 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14901 if (!SWIG_IsOK(res3)) {
14902 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
14903 }
14904 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
14905 }
14906 {
14907 if (!wxPyCheckForApp()) SWIG_fail;
14908 PyThreadState* __tstate = wxPyBeginAllowThreads();
14909 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
14910 wxPyEndAllowThreads(__tstate);
14911 if (PyErr_Occurred()) SWIG_fail;
14912 }
14913 resultobj = SWIG_From_long(static_cast< long >(result));
14914 {
14915 if (temp1)
14916 delete arg1;
14917 }
14918 return resultobj;
14919 fail:
14920 {
14921 if (temp1)
14922 delete arg1;
14923 }
14924 return NULL;
14925 }
14926
14927
14928 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14929 PyObject *resultobj = 0;
14930 long arg1 ;
14931 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14932 wxKillError *arg3 = (wxKillError *) 0 ;
14933 int arg4 = (int) wxKILL_NOCHILDREN ;
14934 int result;
14935 long val1 ;
14936 int ecode1 = 0 ;
14937 int val2 ;
14938 int ecode2 = 0 ;
14939 wxKillError temp3 ;
14940 int val4 ;
14941 int ecode4 = 0 ;
14942 PyObject * obj0 = 0 ;
14943 PyObject * obj1 = 0 ;
14944 PyObject * obj2 = 0 ;
14945 char * kwnames[] = {
14946 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14947 };
14948
14949 {
14950 arg3 = &temp3;
14951 }
14952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14953 ecode1 = SWIG_AsVal_long(obj0, &val1);
14954 if (!SWIG_IsOK(ecode1)) {
14955 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
14956 }
14957 arg1 = static_cast< long >(val1);
14958 if (obj1) {
14959 ecode2 = SWIG_AsVal_int(obj1, &val2);
14960 if (!SWIG_IsOK(ecode2)) {
14961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14962 }
14963 arg2 = static_cast< wxSignal >(val2);
14964 }
14965 if (obj2) {
14966 ecode4 = SWIG_AsVal_int(obj2, &val4);
14967 if (!SWIG_IsOK(ecode4)) {
14968 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
14969 }
14970 arg4 = static_cast< int >(val4);
14971 }
14972 {
14973 PyThreadState* __tstate = wxPyBeginAllowThreads();
14974 result = (int)wxKill(arg1,arg2,arg3,arg4);
14975 wxPyEndAllowThreads(__tstate);
14976 if (PyErr_Occurred()) SWIG_fail;
14977 }
14978 resultobj = SWIG_From_int(static_cast< int >(result));
14979 {
14980 PyObject* o;
14981 o = PyInt_FromLong((long) (*arg3));
14982
14983
14984
14985 resultobj = SWIG_Python_AppendOutput(resultobj, o);
14986
14987 }
14988 return resultobj;
14989 fail:
14990 return NULL;
14991 }
14992
14993
14994 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14995 PyObject *resultobj = 0;
14996 int arg1 = (int) wxJOYSTICK1 ;
14997 wxJoystick *result = 0 ;
14998 int val1 ;
14999 int ecode1 = 0 ;
15000 PyObject * obj0 = 0 ;
15001 char * kwnames[] = {
15002 (char *) "joystick", NULL
15003 };
15004
15005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15006 if (obj0) {
15007 ecode1 = SWIG_AsVal_int(obj0, &val1);
15008 if (!SWIG_IsOK(ecode1)) {
15009 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15010 }
15011 arg1 = static_cast< int >(val1);
15012 }
15013 {
15014 if (!wxPyCheckForApp()) SWIG_fail;
15015 PyThreadState* __tstate = wxPyBeginAllowThreads();
15016 result = (wxJoystick *)new wxJoystick(arg1);
15017 wxPyEndAllowThreads(__tstate);
15018 if (PyErr_Occurred()) SWIG_fail;
15019 }
15020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15021 return resultobj;
15022 fail:
15023 return NULL;
15024 }
15025
15026
15027 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15028 PyObject *resultobj = 0;
15029 wxJoystick *arg1 = (wxJoystick *) 0 ;
15030 void *argp1 = 0 ;
15031 int res1 = 0 ;
15032 PyObject *swig_obj[1] ;
15033
15034 if (!args) SWIG_fail;
15035 swig_obj[0] = args;
15036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15037 if (!SWIG_IsOK(res1)) {
15038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15039 }
15040 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15041 {
15042 PyThreadState* __tstate = wxPyBeginAllowThreads();
15043 delete arg1;
15044
15045 wxPyEndAllowThreads(__tstate);
15046 if (PyErr_Occurred()) SWIG_fail;
15047 }
15048 resultobj = SWIG_Py_Void();
15049 return resultobj;
15050 fail:
15051 return NULL;
15052 }
15053
15054
15055 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15056 PyObject *resultobj = 0;
15057 wxJoystick *arg1 = (wxJoystick *) 0 ;
15058 wxPoint result;
15059 void *argp1 = 0 ;
15060 int res1 = 0 ;
15061 PyObject *swig_obj[1] ;
15062
15063 if (!args) SWIG_fail;
15064 swig_obj[0] = args;
15065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15066 if (!SWIG_IsOK(res1)) {
15067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15068 }
15069 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15070 {
15071 PyThreadState* __tstate = wxPyBeginAllowThreads();
15072 result = (arg1)->GetPosition();
15073 wxPyEndAllowThreads(__tstate);
15074 if (PyErr_Occurred()) SWIG_fail;
15075 }
15076 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15077 return resultobj;
15078 fail:
15079 return NULL;
15080 }
15081
15082
15083 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15084 PyObject *resultobj = 0;
15085 wxJoystick *arg1 = (wxJoystick *) 0 ;
15086 int result;
15087 void *argp1 = 0 ;
15088 int res1 = 0 ;
15089 PyObject *swig_obj[1] ;
15090
15091 if (!args) SWIG_fail;
15092 swig_obj[0] = args;
15093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15094 if (!SWIG_IsOK(res1)) {
15095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15096 }
15097 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15098 {
15099 PyThreadState* __tstate = wxPyBeginAllowThreads();
15100 result = (int)(arg1)->GetZPosition();
15101 wxPyEndAllowThreads(__tstate);
15102 if (PyErr_Occurred()) SWIG_fail;
15103 }
15104 resultobj = SWIG_From_int(static_cast< int >(result));
15105 return resultobj;
15106 fail:
15107 return NULL;
15108 }
15109
15110
15111 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15112 PyObject *resultobj = 0;
15113 wxJoystick *arg1 = (wxJoystick *) 0 ;
15114 int result;
15115 void *argp1 = 0 ;
15116 int res1 = 0 ;
15117 PyObject *swig_obj[1] ;
15118
15119 if (!args) SWIG_fail;
15120 swig_obj[0] = args;
15121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15122 if (!SWIG_IsOK(res1)) {
15123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15124 }
15125 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15126 {
15127 PyThreadState* __tstate = wxPyBeginAllowThreads();
15128 result = (int)(arg1)->GetButtonState();
15129 wxPyEndAllowThreads(__tstate);
15130 if (PyErr_Occurred()) SWIG_fail;
15131 }
15132 resultobj = SWIG_From_int(static_cast< int >(result));
15133 return resultobj;
15134 fail:
15135 return NULL;
15136 }
15137
15138
15139 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15140 PyObject *resultobj = 0;
15141 wxJoystick *arg1 = (wxJoystick *) 0 ;
15142 int result;
15143 void *argp1 = 0 ;
15144 int res1 = 0 ;
15145 PyObject *swig_obj[1] ;
15146
15147 if (!args) SWIG_fail;
15148 swig_obj[0] = args;
15149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15150 if (!SWIG_IsOK(res1)) {
15151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15152 }
15153 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15154 {
15155 PyThreadState* __tstate = wxPyBeginAllowThreads();
15156 result = (int)(arg1)->GetPOVPosition();
15157 wxPyEndAllowThreads(__tstate);
15158 if (PyErr_Occurred()) SWIG_fail;
15159 }
15160 resultobj = SWIG_From_int(static_cast< int >(result));
15161 return resultobj;
15162 fail:
15163 return NULL;
15164 }
15165
15166
15167 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15168 PyObject *resultobj = 0;
15169 wxJoystick *arg1 = (wxJoystick *) 0 ;
15170 int result;
15171 void *argp1 = 0 ;
15172 int res1 = 0 ;
15173 PyObject *swig_obj[1] ;
15174
15175 if (!args) SWIG_fail;
15176 swig_obj[0] = args;
15177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15178 if (!SWIG_IsOK(res1)) {
15179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15180 }
15181 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15182 {
15183 PyThreadState* __tstate = wxPyBeginAllowThreads();
15184 result = (int)(arg1)->GetPOVCTSPosition();
15185 wxPyEndAllowThreads(__tstate);
15186 if (PyErr_Occurred()) SWIG_fail;
15187 }
15188 resultobj = SWIG_From_int(static_cast< int >(result));
15189 return resultobj;
15190 fail:
15191 return NULL;
15192 }
15193
15194
15195 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15196 PyObject *resultobj = 0;
15197 wxJoystick *arg1 = (wxJoystick *) 0 ;
15198 int result;
15199 void *argp1 = 0 ;
15200 int res1 = 0 ;
15201 PyObject *swig_obj[1] ;
15202
15203 if (!args) SWIG_fail;
15204 swig_obj[0] = args;
15205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15206 if (!SWIG_IsOK(res1)) {
15207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15208 }
15209 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15210 {
15211 PyThreadState* __tstate = wxPyBeginAllowThreads();
15212 result = (int)(arg1)->GetRudderPosition();
15213 wxPyEndAllowThreads(__tstate);
15214 if (PyErr_Occurred()) SWIG_fail;
15215 }
15216 resultobj = SWIG_From_int(static_cast< int >(result));
15217 return resultobj;
15218 fail:
15219 return NULL;
15220 }
15221
15222
15223 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15224 PyObject *resultobj = 0;
15225 wxJoystick *arg1 = (wxJoystick *) 0 ;
15226 int result;
15227 void *argp1 = 0 ;
15228 int res1 = 0 ;
15229 PyObject *swig_obj[1] ;
15230
15231 if (!args) SWIG_fail;
15232 swig_obj[0] = args;
15233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15234 if (!SWIG_IsOK(res1)) {
15235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15236 }
15237 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15238 {
15239 PyThreadState* __tstate = wxPyBeginAllowThreads();
15240 result = (int)(arg1)->GetUPosition();
15241 wxPyEndAllowThreads(__tstate);
15242 if (PyErr_Occurred()) SWIG_fail;
15243 }
15244 resultobj = SWIG_From_int(static_cast< int >(result));
15245 return resultobj;
15246 fail:
15247 return NULL;
15248 }
15249
15250
15251 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15252 PyObject *resultobj = 0;
15253 wxJoystick *arg1 = (wxJoystick *) 0 ;
15254 int result;
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, 0 | 0 );
15262 if (!SWIG_IsOK(res1)) {
15263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15264 }
15265 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15266 {
15267 PyThreadState* __tstate = wxPyBeginAllowThreads();
15268 result = (int)(arg1)->GetVPosition();
15269 wxPyEndAllowThreads(__tstate);
15270 if (PyErr_Occurred()) SWIG_fail;
15271 }
15272 resultobj = SWIG_From_int(static_cast< int >(result));
15273 return resultobj;
15274 fail:
15275 return NULL;
15276 }
15277
15278
15279 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15280 PyObject *resultobj = 0;
15281 wxJoystick *arg1 = (wxJoystick *) 0 ;
15282 int result;
15283 void *argp1 = 0 ;
15284 int res1 = 0 ;
15285 PyObject *swig_obj[1] ;
15286
15287 if (!args) SWIG_fail;
15288 swig_obj[0] = args;
15289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15290 if (!SWIG_IsOK(res1)) {
15291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15292 }
15293 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15294 {
15295 PyThreadState* __tstate = wxPyBeginAllowThreads();
15296 result = (int)(arg1)->GetMovementThreshold();
15297 wxPyEndAllowThreads(__tstate);
15298 if (PyErr_Occurred()) SWIG_fail;
15299 }
15300 resultobj = SWIG_From_int(static_cast< int >(result));
15301 return resultobj;
15302 fail:
15303 return NULL;
15304 }
15305
15306
15307 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15308 PyObject *resultobj = 0;
15309 wxJoystick *arg1 = (wxJoystick *) 0 ;
15310 int arg2 ;
15311 void *argp1 = 0 ;
15312 int res1 = 0 ;
15313 int val2 ;
15314 int ecode2 = 0 ;
15315 PyObject * obj0 = 0 ;
15316 PyObject * obj1 = 0 ;
15317 char * kwnames[] = {
15318 (char *) "self",(char *) "threshold", NULL
15319 };
15320
15321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15323 if (!SWIG_IsOK(res1)) {
15324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15325 }
15326 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15327 ecode2 = SWIG_AsVal_int(obj1, &val2);
15328 if (!SWIG_IsOK(ecode2)) {
15329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15330 }
15331 arg2 = static_cast< int >(val2);
15332 {
15333 PyThreadState* __tstate = wxPyBeginAllowThreads();
15334 (arg1)->SetMovementThreshold(arg2);
15335 wxPyEndAllowThreads(__tstate);
15336 if (PyErr_Occurred()) SWIG_fail;
15337 }
15338 resultobj = SWIG_Py_Void();
15339 return resultobj;
15340 fail:
15341 return NULL;
15342 }
15343
15344
15345 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15346 PyObject *resultobj = 0;
15347 wxJoystick *arg1 = (wxJoystick *) 0 ;
15348 bool result;
15349 void *argp1 = 0 ;
15350 int res1 = 0 ;
15351 PyObject *swig_obj[1] ;
15352
15353 if (!args) SWIG_fail;
15354 swig_obj[0] = args;
15355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15356 if (!SWIG_IsOK(res1)) {
15357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15358 }
15359 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15360 {
15361 PyThreadState* __tstate = wxPyBeginAllowThreads();
15362 result = (bool)(arg1)->IsOk();
15363 wxPyEndAllowThreads(__tstate);
15364 if (PyErr_Occurred()) SWIG_fail;
15365 }
15366 {
15367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15368 }
15369 return resultobj;
15370 fail:
15371 return NULL;
15372 }
15373
15374
15375 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15376 PyObject *resultobj = 0;
15377 wxJoystick *arg1 = (wxJoystick *) 0 ;
15378 int result;
15379 void *argp1 = 0 ;
15380 int res1 = 0 ;
15381 PyObject *swig_obj[1] ;
15382
15383 if (!args) SWIG_fail;
15384 swig_obj[0] = args;
15385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15386 if (!SWIG_IsOK(res1)) {
15387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15388 }
15389 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15390 {
15391 PyThreadState* __tstate = wxPyBeginAllowThreads();
15392 result = (int)(arg1)->GetNumberJoysticks();
15393 wxPyEndAllowThreads(__tstate);
15394 if (PyErr_Occurred()) SWIG_fail;
15395 }
15396 resultobj = SWIG_From_int(static_cast< int >(result));
15397 return resultobj;
15398 fail:
15399 return NULL;
15400 }
15401
15402
15403 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15404 PyObject *resultobj = 0;
15405 wxJoystick *arg1 = (wxJoystick *) 0 ;
15406 int result;
15407 void *argp1 = 0 ;
15408 int res1 = 0 ;
15409 PyObject *swig_obj[1] ;
15410
15411 if (!args) SWIG_fail;
15412 swig_obj[0] = args;
15413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15414 if (!SWIG_IsOK(res1)) {
15415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15416 }
15417 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15418 {
15419 PyThreadState* __tstate = wxPyBeginAllowThreads();
15420 result = (int)(arg1)->GetManufacturerId();
15421 wxPyEndAllowThreads(__tstate);
15422 if (PyErr_Occurred()) SWIG_fail;
15423 }
15424 resultobj = SWIG_From_int(static_cast< int >(result));
15425 return resultobj;
15426 fail:
15427 return NULL;
15428 }
15429
15430
15431 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15432 PyObject *resultobj = 0;
15433 wxJoystick *arg1 = (wxJoystick *) 0 ;
15434 int result;
15435 void *argp1 = 0 ;
15436 int res1 = 0 ;
15437 PyObject *swig_obj[1] ;
15438
15439 if (!args) SWIG_fail;
15440 swig_obj[0] = args;
15441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15442 if (!SWIG_IsOK(res1)) {
15443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15444 }
15445 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15446 {
15447 PyThreadState* __tstate = wxPyBeginAllowThreads();
15448 result = (int)(arg1)->GetProductId();
15449 wxPyEndAllowThreads(__tstate);
15450 if (PyErr_Occurred()) SWIG_fail;
15451 }
15452 resultobj = SWIG_From_int(static_cast< int >(result));
15453 return resultobj;
15454 fail:
15455 return NULL;
15456 }
15457
15458
15459 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15460 PyObject *resultobj = 0;
15461 wxJoystick *arg1 = (wxJoystick *) 0 ;
15462 wxString result;
15463 void *argp1 = 0 ;
15464 int res1 = 0 ;
15465 PyObject *swig_obj[1] ;
15466
15467 if (!args) SWIG_fail;
15468 swig_obj[0] = args;
15469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15470 if (!SWIG_IsOK(res1)) {
15471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15472 }
15473 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15474 {
15475 PyThreadState* __tstate = wxPyBeginAllowThreads();
15476 result = (arg1)->GetProductName();
15477 wxPyEndAllowThreads(__tstate);
15478 if (PyErr_Occurred()) SWIG_fail;
15479 }
15480 {
15481 #if wxUSE_UNICODE
15482 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15483 #else
15484 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15485 #endif
15486 }
15487 return resultobj;
15488 fail:
15489 return NULL;
15490 }
15491
15492
15493 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15494 PyObject *resultobj = 0;
15495 wxJoystick *arg1 = (wxJoystick *) 0 ;
15496 int result;
15497 void *argp1 = 0 ;
15498 int res1 = 0 ;
15499 PyObject *swig_obj[1] ;
15500
15501 if (!args) SWIG_fail;
15502 swig_obj[0] = args;
15503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15504 if (!SWIG_IsOK(res1)) {
15505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15506 }
15507 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15508 {
15509 PyThreadState* __tstate = wxPyBeginAllowThreads();
15510 result = (int)(arg1)->GetXMin();
15511 wxPyEndAllowThreads(__tstate);
15512 if (PyErr_Occurred()) SWIG_fail;
15513 }
15514 resultobj = SWIG_From_int(static_cast< int >(result));
15515 return resultobj;
15516 fail:
15517 return NULL;
15518 }
15519
15520
15521 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15522 PyObject *resultobj = 0;
15523 wxJoystick *arg1 = (wxJoystick *) 0 ;
15524 int result;
15525 void *argp1 = 0 ;
15526 int res1 = 0 ;
15527 PyObject *swig_obj[1] ;
15528
15529 if (!args) SWIG_fail;
15530 swig_obj[0] = args;
15531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15532 if (!SWIG_IsOK(res1)) {
15533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15534 }
15535 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15536 {
15537 PyThreadState* __tstate = wxPyBeginAllowThreads();
15538 result = (int)(arg1)->GetYMin();
15539 wxPyEndAllowThreads(__tstate);
15540 if (PyErr_Occurred()) SWIG_fail;
15541 }
15542 resultobj = SWIG_From_int(static_cast< int >(result));
15543 return resultobj;
15544 fail:
15545 return NULL;
15546 }
15547
15548
15549 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15550 PyObject *resultobj = 0;
15551 wxJoystick *arg1 = (wxJoystick *) 0 ;
15552 int result;
15553 void *argp1 = 0 ;
15554 int res1 = 0 ;
15555 PyObject *swig_obj[1] ;
15556
15557 if (!args) SWIG_fail;
15558 swig_obj[0] = args;
15559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15560 if (!SWIG_IsOK(res1)) {
15561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15562 }
15563 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15564 {
15565 PyThreadState* __tstate = wxPyBeginAllowThreads();
15566 result = (int)(arg1)->GetZMin();
15567 wxPyEndAllowThreads(__tstate);
15568 if (PyErr_Occurred()) SWIG_fail;
15569 }
15570 resultobj = SWIG_From_int(static_cast< int >(result));
15571 return resultobj;
15572 fail:
15573 return NULL;
15574 }
15575
15576
15577 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15578 PyObject *resultobj = 0;
15579 wxJoystick *arg1 = (wxJoystick *) 0 ;
15580 int result;
15581 void *argp1 = 0 ;
15582 int res1 = 0 ;
15583 PyObject *swig_obj[1] ;
15584
15585 if (!args) SWIG_fail;
15586 swig_obj[0] = args;
15587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15588 if (!SWIG_IsOK(res1)) {
15589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15590 }
15591 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15592 {
15593 PyThreadState* __tstate = wxPyBeginAllowThreads();
15594 result = (int)(arg1)->GetXMax();
15595 wxPyEndAllowThreads(__tstate);
15596 if (PyErr_Occurred()) SWIG_fail;
15597 }
15598 resultobj = SWIG_From_int(static_cast< int >(result));
15599 return resultobj;
15600 fail:
15601 return NULL;
15602 }
15603
15604
15605 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15606 PyObject *resultobj = 0;
15607 wxJoystick *arg1 = (wxJoystick *) 0 ;
15608 int result;
15609 void *argp1 = 0 ;
15610 int res1 = 0 ;
15611 PyObject *swig_obj[1] ;
15612
15613 if (!args) SWIG_fail;
15614 swig_obj[0] = args;
15615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15616 if (!SWIG_IsOK(res1)) {
15617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15618 }
15619 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15620 {
15621 PyThreadState* __tstate = wxPyBeginAllowThreads();
15622 result = (int)(arg1)->GetYMax();
15623 wxPyEndAllowThreads(__tstate);
15624 if (PyErr_Occurred()) SWIG_fail;
15625 }
15626 resultobj = SWIG_From_int(static_cast< int >(result));
15627 return resultobj;
15628 fail:
15629 return NULL;
15630 }
15631
15632
15633 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15634 PyObject *resultobj = 0;
15635 wxJoystick *arg1 = (wxJoystick *) 0 ;
15636 int result;
15637 void *argp1 = 0 ;
15638 int res1 = 0 ;
15639 PyObject *swig_obj[1] ;
15640
15641 if (!args) SWIG_fail;
15642 swig_obj[0] = args;
15643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15644 if (!SWIG_IsOK(res1)) {
15645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15646 }
15647 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15648 {
15649 PyThreadState* __tstate = wxPyBeginAllowThreads();
15650 result = (int)(arg1)->GetZMax();
15651 wxPyEndAllowThreads(__tstate);
15652 if (PyErr_Occurred()) SWIG_fail;
15653 }
15654 resultobj = SWIG_From_int(static_cast< int >(result));
15655 return resultobj;
15656 fail:
15657 return NULL;
15658 }
15659
15660
15661 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15662 PyObject *resultobj = 0;
15663 wxJoystick *arg1 = (wxJoystick *) 0 ;
15664 int result;
15665 void *argp1 = 0 ;
15666 int res1 = 0 ;
15667 PyObject *swig_obj[1] ;
15668
15669 if (!args) SWIG_fail;
15670 swig_obj[0] = args;
15671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15672 if (!SWIG_IsOK(res1)) {
15673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15674 }
15675 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15676 {
15677 PyThreadState* __tstate = wxPyBeginAllowThreads();
15678 result = (int)(arg1)->GetNumberButtons();
15679 wxPyEndAllowThreads(__tstate);
15680 if (PyErr_Occurred()) SWIG_fail;
15681 }
15682 resultobj = SWIG_From_int(static_cast< int >(result));
15683 return resultobj;
15684 fail:
15685 return NULL;
15686 }
15687
15688
15689 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15690 PyObject *resultobj = 0;
15691 wxJoystick *arg1 = (wxJoystick *) 0 ;
15692 int result;
15693 void *argp1 = 0 ;
15694 int res1 = 0 ;
15695 PyObject *swig_obj[1] ;
15696
15697 if (!args) SWIG_fail;
15698 swig_obj[0] = args;
15699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15700 if (!SWIG_IsOK(res1)) {
15701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15702 }
15703 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15704 {
15705 PyThreadState* __tstate = wxPyBeginAllowThreads();
15706 result = (int)(arg1)->GetNumberAxes();
15707 wxPyEndAllowThreads(__tstate);
15708 if (PyErr_Occurred()) SWIG_fail;
15709 }
15710 resultobj = SWIG_From_int(static_cast< int >(result));
15711 return resultobj;
15712 fail:
15713 return NULL;
15714 }
15715
15716
15717 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15718 PyObject *resultobj = 0;
15719 wxJoystick *arg1 = (wxJoystick *) 0 ;
15720 int result;
15721 void *argp1 = 0 ;
15722 int res1 = 0 ;
15723 PyObject *swig_obj[1] ;
15724
15725 if (!args) SWIG_fail;
15726 swig_obj[0] = args;
15727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15728 if (!SWIG_IsOK(res1)) {
15729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15730 }
15731 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15732 {
15733 PyThreadState* __tstate = wxPyBeginAllowThreads();
15734 result = (int)(arg1)->GetMaxButtons();
15735 wxPyEndAllowThreads(__tstate);
15736 if (PyErr_Occurred()) SWIG_fail;
15737 }
15738 resultobj = SWIG_From_int(static_cast< int >(result));
15739 return resultobj;
15740 fail:
15741 return NULL;
15742 }
15743
15744
15745 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15746 PyObject *resultobj = 0;
15747 wxJoystick *arg1 = (wxJoystick *) 0 ;
15748 int result;
15749 void *argp1 = 0 ;
15750 int res1 = 0 ;
15751 PyObject *swig_obj[1] ;
15752
15753 if (!args) SWIG_fail;
15754 swig_obj[0] = args;
15755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15756 if (!SWIG_IsOK(res1)) {
15757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15758 }
15759 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15760 {
15761 PyThreadState* __tstate = wxPyBeginAllowThreads();
15762 result = (int)(arg1)->GetMaxAxes();
15763 wxPyEndAllowThreads(__tstate);
15764 if (PyErr_Occurred()) SWIG_fail;
15765 }
15766 resultobj = SWIG_From_int(static_cast< int >(result));
15767 return resultobj;
15768 fail:
15769 return NULL;
15770 }
15771
15772
15773 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15774 PyObject *resultobj = 0;
15775 wxJoystick *arg1 = (wxJoystick *) 0 ;
15776 int result;
15777 void *argp1 = 0 ;
15778 int res1 = 0 ;
15779 PyObject *swig_obj[1] ;
15780
15781 if (!args) SWIG_fail;
15782 swig_obj[0] = args;
15783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15784 if (!SWIG_IsOK(res1)) {
15785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15786 }
15787 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15788 {
15789 PyThreadState* __tstate = wxPyBeginAllowThreads();
15790 result = (int)(arg1)->GetPollingMin();
15791 wxPyEndAllowThreads(__tstate);
15792 if (PyErr_Occurred()) SWIG_fail;
15793 }
15794 resultobj = SWIG_From_int(static_cast< int >(result));
15795 return resultobj;
15796 fail:
15797 return NULL;
15798 }
15799
15800
15801 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15802 PyObject *resultobj = 0;
15803 wxJoystick *arg1 = (wxJoystick *) 0 ;
15804 int result;
15805 void *argp1 = 0 ;
15806 int res1 = 0 ;
15807 PyObject *swig_obj[1] ;
15808
15809 if (!args) SWIG_fail;
15810 swig_obj[0] = args;
15811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15812 if (!SWIG_IsOK(res1)) {
15813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15814 }
15815 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15816 {
15817 PyThreadState* __tstate = wxPyBeginAllowThreads();
15818 result = (int)(arg1)->GetPollingMax();
15819 wxPyEndAllowThreads(__tstate);
15820 if (PyErr_Occurred()) SWIG_fail;
15821 }
15822 resultobj = SWIG_From_int(static_cast< int >(result));
15823 return resultobj;
15824 fail:
15825 return NULL;
15826 }
15827
15828
15829 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15830 PyObject *resultobj = 0;
15831 wxJoystick *arg1 = (wxJoystick *) 0 ;
15832 int result;
15833 void *argp1 = 0 ;
15834 int res1 = 0 ;
15835 PyObject *swig_obj[1] ;
15836
15837 if (!args) SWIG_fail;
15838 swig_obj[0] = args;
15839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15840 if (!SWIG_IsOK(res1)) {
15841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15842 }
15843 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15844 {
15845 PyThreadState* __tstate = wxPyBeginAllowThreads();
15846 result = (int)(arg1)->GetRudderMin();
15847 wxPyEndAllowThreads(__tstate);
15848 if (PyErr_Occurred()) SWIG_fail;
15849 }
15850 resultobj = SWIG_From_int(static_cast< int >(result));
15851 return resultobj;
15852 fail:
15853 return NULL;
15854 }
15855
15856
15857 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15858 PyObject *resultobj = 0;
15859 wxJoystick *arg1 = (wxJoystick *) 0 ;
15860 int result;
15861 void *argp1 = 0 ;
15862 int res1 = 0 ;
15863 PyObject *swig_obj[1] ;
15864
15865 if (!args) SWIG_fail;
15866 swig_obj[0] = args;
15867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15868 if (!SWIG_IsOK(res1)) {
15869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15870 }
15871 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15872 {
15873 PyThreadState* __tstate = wxPyBeginAllowThreads();
15874 result = (int)(arg1)->GetRudderMax();
15875 wxPyEndAllowThreads(__tstate);
15876 if (PyErr_Occurred()) SWIG_fail;
15877 }
15878 resultobj = SWIG_From_int(static_cast< int >(result));
15879 return resultobj;
15880 fail:
15881 return NULL;
15882 }
15883
15884
15885 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15886 PyObject *resultobj = 0;
15887 wxJoystick *arg1 = (wxJoystick *) 0 ;
15888 int result;
15889 void *argp1 = 0 ;
15890 int res1 = 0 ;
15891 PyObject *swig_obj[1] ;
15892
15893 if (!args) SWIG_fail;
15894 swig_obj[0] = args;
15895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15896 if (!SWIG_IsOK(res1)) {
15897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15898 }
15899 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15900 {
15901 PyThreadState* __tstate = wxPyBeginAllowThreads();
15902 result = (int)(arg1)->GetUMin();
15903 wxPyEndAllowThreads(__tstate);
15904 if (PyErr_Occurred()) SWIG_fail;
15905 }
15906 resultobj = SWIG_From_int(static_cast< int >(result));
15907 return resultobj;
15908 fail:
15909 return NULL;
15910 }
15911
15912
15913 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15914 PyObject *resultobj = 0;
15915 wxJoystick *arg1 = (wxJoystick *) 0 ;
15916 int result;
15917 void *argp1 = 0 ;
15918 int res1 = 0 ;
15919 PyObject *swig_obj[1] ;
15920
15921 if (!args) SWIG_fail;
15922 swig_obj[0] = args;
15923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15924 if (!SWIG_IsOK(res1)) {
15925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15926 }
15927 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15928 {
15929 PyThreadState* __tstate = wxPyBeginAllowThreads();
15930 result = (int)(arg1)->GetUMax();
15931 wxPyEndAllowThreads(__tstate);
15932 if (PyErr_Occurred()) SWIG_fail;
15933 }
15934 resultobj = SWIG_From_int(static_cast< int >(result));
15935 return resultobj;
15936 fail:
15937 return NULL;
15938 }
15939
15940
15941 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15942 PyObject *resultobj = 0;
15943 wxJoystick *arg1 = (wxJoystick *) 0 ;
15944 int result;
15945 void *argp1 = 0 ;
15946 int res1 = 0 ;
15947 PyObject *swig_obj[1] ;
15948
15949 if (!args) SWIG_fail;
15950 swig_obj[0] = args;
15951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15952 if (!SWIG_IsOK(res1)) {
15953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15954 }
15955 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15956 {
15957 PyThreadState* __tstate = wxPyBeginAllowThreads();
15958 result = (int)(arg1)->GetVMin();
15959 wxPyEndAllowThreads(__tstate);
15960 if (PyErr_Occurred()) SWIG_fail;
15961 }
15962 resultobj = SWIG_From_int(static_cast< int >(result));
15963 return resultobj;
15964 fail:
15965 return NULL;
15966 }
15967
15968
15969 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15970 PyObject *resultobj = 0;
15971 wxJoystick *arg1 = (wxJoystick *) 0 ;
15972 int result;
15973 void *argp1 = 0 ;
15974 int res1 = 0 ;
15975 PyObject *swig_obj[1] ;
15976
15977 if (!args) SWIG_fail;
15978 swig_obj[0] = args;
15979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15980 if (!SWIG_IsOK(res1)) {
15981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15982 }
15983 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15984 {
15985 PyThreadState* __tstate = wxPyBeginAllowThreads();
15986 result = (int)(arg1)->GetVMax();
15987 wxPyEndAllowThreads(__tstate);
15988 if (PyErr_Occurred()) SWIG_fail;
15989 }
15990 resultobj = SWIG_From_int(static_cast< int >(result));
15991 return resultobj;
15992 fail:
15993 return NULL;
15994 }
15995
15996
15997 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15998 PyObject *resultobj = 0;
15999 wxJoystick *arg1 = (wxJoystick *) 0 ;
16000 bool result;
16001 void *argp1 = 0 ;
16002 int res1 = 0 ;
16003 PyObject *swig_obj[1] ;
16004
16005 if (!args) SWIG_fail;
16006 swig_obj[0] = args;
16007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16008 if (!SWIG_IsOK(res1)) {
16009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16010 }
16011 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16012 {
16013 PyThreadState* __tstate = wxPyBeginAllowThreads();
16014 result = (bool)(arg1)->HasRudder();
16015 wxPyEndAllowThreads(__tstate);
16016 if (PyErr_Occurred()) SWIG_fail;
16017 }
16018 {
16019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16020 }
16021 return resultobj;
16022 fail:
16023 return NULL;
16024 }
16025
16026
16027 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16028 PyObject *resultobj = 0;
16029 wxJoystick *arg1 = (wxJoystick *) 0 ;
16030 bool result;
16031 void *argp1 = 0 ;
16032 int res1 = 0 ;
16033 PyObject *swig_obj[1] ;
16034
16035 if (!args) SWIG_fail;
16036 swig_obj[0] = args;
16037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16038 if (!SWIG_IsOK(res1)) {
16039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16040 }
16041 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16042 {
16043 PyThreadState* __tstate = wxPyBeginAllowThreads();
16044 result = (bool)(arg1)->HasZ();
16045 wxPyEndAllowThreads(__tstate);
16046 if (PyErr_Occurred()) SWIG_fail;
16047 }
16048 {
16049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16050 }
16051 return resultobj;
16052 fail:
16053 return NULL;
16054 }
16055
16056
16057 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16058 PyObject *resultobj = 0;
16059 wxJoystick *arg1 = (wxJoystick *) 0 ;
16060 bool result;
16061 void *argp1 = 0 ;
16062 int res1 = 0 ;
16063 PyObject *swig_obj[1] ;
16064
16065 if (!args) SWIG_fail;
16066 swig_obj[0] = args;
16067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16068 if (!SWIG_IsOK(res1)) {
16069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16070 }
16071 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16072 {
16073 PyThreadState* __tstate = wxPyBeginAllowThreads();
16074 result = (bool)(arg1)->HasU();
16075 wxPyEndAllowThreads(__tstate);
16076 if (PyErr_Occurred()) SWIG_fail;
16077 }
16078 {
16079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16080 }
16081 return resultobj;
16082 fail:
16083 return NULL;
16084 }
16085
16086
16087 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16088 PyObject *resultobj = 0;
16089 wxJoystick *arg1 = (wxJoystick *) 0 ;
16090 bool result;
16091 void *argp1 = 0 ;
16092 int res1 = 0 ;
16093 PyObject *swig_obj[1] ;
16094
16095 if (!args) SWIG_fail;
16096 swig_obj[0] = args;
16097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16098 if (!SWIG_IsOK(res1)) {
16099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16100 }
16101 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16102 {
16103 PyThreadState* __tstate = wxPyBeginAllowThreads();
16104 result = (bool)(arg1)->HasV();
16105 wxPyEndAllowThreads(__tstate);
16106 if (PyErr_Occurred()) SWIG_fail;
16107 }
16108 {
16109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16110 }
16111 return resultobj;
16112 fail:
16113 return NULL;
16114 }
16115
16116
16117 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16118 PyObject *resultobj = 0;
16119 wxJoystick *arg1 = (wxJoystick *) 0 ;
16120 bool result;
16121 void *argp1 = 0 ;
16122 int res1 = 0 ;
16123 PyObject *swig_obj[1] ;
16124
16125 if (!args) SWIG_fail;
16126 swig_obj[0] = args;
16127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16128 if (!SWIG_IsOK(res1)) {
16129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16130 }
16131 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16132 {
16133 PyThreadState* __tstate = wxPyBeginAllowThreads();
16134 result = (bool)(arg1)->HasPOV();
16135 wxPyEndAllowThreads(__tstate);
16136 if (PyErr_Occurred()) SWIG_fail;
16137 }
16138 {
16139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16140 }
16141 return resultobj;
16142 fail:
16143 return NULL;
16144 }
16145
16146
16147 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16148 PyObject *resultobj = 0;
16149 wxJoystick *arg1 = (wxJoystick *) 0 ;
16150 bool result;
16151 void *argp1 = 0 ;
16152 int res1 = 0 ;
16153 PyObject *swig_obj[1] ;
16154
16155 if (!args) SWIG_fail;
16156 swig_obj[0] = args;
16157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16158 if (!SWIG_IsOK(res1)) {
16159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16160 }
16161 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16162 {
16163 PyThreadState* __tstate = wxPyBeginAllowThreads();
16164 result = (bool)(arg1)->HasPOV4Dir();
16165 wxPyEndAllowThreads(__tstate);
16166 if (PyErr_Occurred()) SWIG_fail;
16167 }
16168 {
16169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16170 }
16171 return resultobj;
16172 fail:
16173 return NULL;
16174 }
16175
16176
16177 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16178 PyObject *resultobj = 0;
16179 wxJoystick *arg1 = (wxJoystick *) 0 ;
16180 bool result;
16181 void *argp1 = 0 ;
16182 int res1 = 0 ;
16183 PyObject *swig_obj[1] ;
16184
16185 if (!args) SWIG_fail;
16186 swig_obj[0] = args;
16187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16188 if (!SWIG_IsOK(res1)) {
16189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16190 }
16191 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16192 {
16193 PyThreadState* __tstate = wxPyBeginAllowThreads();
16194 result = (bool)(arg1)->HasPOVCTS();
16195 wxPyEndAllowThreads(__tstate);
16196 if (PyErr_Occurred()) SWIG_fail;
16197 }
16198 {
16199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16200 }
16201 return resultobj;
16202 fail:
16203 return NULL;
16204 }
16205
16206
16207 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16208 PyObject *resultobj = 0;
16209 wxJoystick *arg1 = (wxJoystick *) 0 ;
16210 wxWindow *arg2 = (wxWindow *) 0 ;
16211 int arg3 = (int) 0 ;
16212 bool result;
16213 void *argp1 = 0 ;
16214 int res1 = 0 ;
16215 void *argp2 = 0 ;
16216 int res2 = 0 ;
16217 int val3 ;
16218 int ecode3 = 0 ;
16219 PyObject * obj0 = 0 ;
16220 PyObject * obj1 = 0 ;
16221 PyObject * obj2 = 0 ;
16222 char * kwnames[] = {
16223 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16224 };
16225
16226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16228 if (!SWIG_IsOK(res1)) {
16229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16230 }
16231 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16232 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16233 if (!SWIG_IsOK(res2)) {
16234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16235 }
16236 arg2 = reinterpret_cast< wxWindow * >(argp2);
16237 if (obj2) {
16238 ecode3 = SWIG_AsVal_int(obj2, &val3);
16239 if (!SWIG_IsOK(ecode3)) {
16240 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16241 }
16242 arg3 = static_cast< int >(val3);
16243 }
16244 {
16245 PyThreadState* __tstate = wxPyBeginAllowThreads();
16246 result = (bool)(arg1)->SetCapture(arg2,arg3);
16247 wxPyEndAllowThreads(__tstate);
16248 if (PyErr_Occurred()) SWIG_fail;
16249 }
16250 {
16251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16252 }
16253 return resultobj;
16254 fail:
16255 return NULL;
16256 }
16257
16258
16259 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16260 PyObject *resultobj = 0;
16261 wxJoystick *arg1 = (wxJoystick *) 0 ;
16262 bool result;
16263 void *argp1 = 0 ;
16264 int res1 = 0 ;
16265 PyObject *swig_obj[1] ;
16266
16267 if (!args) SWIG_fail;
16268 swig_obj[0] = args;
16269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16270 if (!SWIG_IsOK(res1)) {
16271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16272 }
16273 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16274 {
16275 PyThreadState* __tstate = wxPyBeginAllowThreads();
16276 result = (bool)(arg1)->ReleaseCapture();
16277 wxPyEndAllowThreads(__tstate);
16278 if (PyErr_Occurred()) SWIG_fail;
16279 }
16280 {
16281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16282 }
16283 return resultobj;
16284 fail:
16285 return NULL;
16286 }
16287
16288
16289 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16290 PyObject *obj;
16291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16292 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16293 return SWIG_Py_Void();
16294 }
16295
16296 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16297 return SWIG_Python_InitShadowInstance(args);
16298 }
16299
16300 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16301 PyObject *resultobj = 0;
16302 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16303 int arg2 = (int) 0 ;
16304 int arg3 = (int) wxJOYSTICK1 ;
16305 int arg4 = (int) 0 ;
16306 wxJoystickEvent *result = 0 ;
16307 int val1 ;
16308 int ecode1 = 0 ;
16309 int val2 ;
16310 int ecode2 = 0 ;
16311 int val3 ;
16312 int ecode3 = 0 ;
16313 int val4 ;
16314 int ecode4 = 0 ;
16315 PyObject * obj0 = 0 ;
16316 PyObject * obj1 = 0 ;
16317 PyObject * obj2 = 0 ;
16318 PyObject * obj3 = 0 ;
16319 char * kwnames[] = {
16320 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16321 };
16322
16323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16324 if (obj0) {
16325 ecode1 = SWIG_AsVal_int(obj0, &val1);
16326 if (!SWIG_IsOK(ecode1)) {
16327 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16328 }
16329 arg1 = static_cast< wxEventType >(val1);
16330 }
16331 if (obj1) {
16332 ecode2 = SWIG_AsVal_int(obj1, &val2);
16333 if (!SWIG_IsOK(ecode2)) {
16334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16335 }
16336 arg2 = static_cast< int >(val2);
16337 }
16338 if (obj2) {
16339 ecode3 = SWIG_AsVal_int(obj2, &val3);
16340 if (!SWIG_IsOK(ecode3)) {
16341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16342 }
16343 arg3 = static_cast< int >(val3);
16344 }
16345 if (obj3) {
16346 ecode4 = SWIG_AsVal_int(obj3, &val4);
16347 if (!SWIG_IsOK(ecode4)) {
16348 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16349 }
16350 arg4 = static_cast< int >(val4);
16351 }
16352 {
16353 PyThreadState* __tstate = wxPyBeginAllowThreads();
16354 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16355 wxPyEndAllowThreads(__tstate);
16356 if (PyErr_Occurred()) SWIG_fail;
16357 }
16358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16359 return resultobj;
16360 fail:
16361 return NULL;
16362 }
16363
16364
16365 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16366 PyObject *resultobj = 0;
16367 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16368 wxPoint result;
16369 void *argp1 = 0 ;
16370 int res1 = 0 ;
16371 PyObject *swig_obj[1] ;
16372
16373 if (!args) SWIG_fail;
16374 swig_obj[0] = args;
16375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16376 if (!SWIG_IsOK(res1)) {
16377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16378 }
16379 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16380 {
16381 PyThreadState* __tstate = wxPyBeginAllowThreads();
16382 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16383 wxPyEndAllowThreads(__tstate);
16384 if (PyErr_Occurred()) SWIG_fail;
16385 }
16386 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16387 return resultobj;
16388 fail:
16389 return NULL;
16390 }
16391
16392
16393 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16394 PyObject *resultobj = 0;
16395 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16396 int result;
16397 void *argp1 = 0 ;
16398 int res1 = 0 ;
16399 PyObject *swig_obj[1] ;
16400
16401 if (!args) SWIG_fail;
16402 swig_obj[0] = args;
16403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16404 if (!SWIG_IsOK(res1)) {
16405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16406 }
16407 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16408 {
16409 PyThreadState* __tstate = wxPyBeginAllowThreads();
16410 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16411 wxPyEndAllowThreads(__tstate);
16412 if (PyErr_Occurred()) SWIG_fail;
16413 }
16414 resultobj = SWIG_From_int(static_cast< int >(result));
16415 return resultobj;
16416 fail:
16417 return NULL;
16418 }
16419
16420
16421 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16422 PyObject *resultobj = 0;
16423 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16424 int result;
16425 void *argp1 = 0 ;
16426 int res1 = 0 ;
16427 PyObject *swig_obj[1] ;
16428
16429 if (!args) SWIG_fail;
16430 swig_obj[0] = args;
16431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16432 if (!SWIG_IsOK(res1)) {
16433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16434 }
16435 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16436 {
16437 PyThreadState* __tstate = wxPyBeginAllowThreads();
16438 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16439 wxPyEndAllowThreads(__tstate);
16440 if (PyErr_Occurred()) SWIG_fail;
16441 }
16442 resultobj = SWIG_From_int(static_cast< int >(result));
16443 return resultobj;
16444 fail:
16445 return NULL;
16446 }
16447
16448
16449 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16450 PyObject *resultobj = 0;
16451 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16452 int result;
16453 void *argp1 = 0 ;
16454 int res1 = 0 ;
16455 PyObject *swig_obj[1] ;
16456
16457 if (!args) SWIG_fail;
16458 swig_obj[0] = args;
16459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16460 if (!SWIG_IsOK(res1)) {
16461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16462 }
16463 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16464 {
16465 PyThreadState* __tstate = wxPyBeginAllowThreads();
16466 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16467 wxPyEndAllowThreads(__tstate);
16468 if (PyErr_Occurred()) SWIG_fail;
16469 }
16470 resultobj = SWIG_From_int(static_cast< int >(result));
16471 return resultobj;
16472 fail:
16473 return NULL;
16474 }
16475
16476
16477 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16478 PyObject *resultobj = 0;
16479 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16480 int result;
16481 void *argp1 = 0 ;
16482 int res1 = 0 ;
16483 PyObject *swig_obj[1] ;
16484
16485 if (!args) SWIG_fail;
16486 swig_obj[0] = args;
16487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16488 if (!SWIG_IsOK(res1)) {
16489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16490 }
16491 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16492 {
16493 PyThreadState* __tstate = wxPyBeginAllowThreads();
16494 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16495 wxPyEndAllowThreads(__tstate);
16496 if (PyErr_Occurred()) SWIG_fail;
16497 }
16498 resultobj = SWIG_From_int(static_cast< int >(result));
16499 return resultobj;
16500 fail:
16501 return NULL;
16502 }
16503
16504
16505 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16506 PyObject *resultobj = 0;
16507 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16508 int arg2 ;
16509 void *argp1 = 0 ;
16510 int res1 = 0 ;
16511 int val2 ;
16512 int ecode2 = 0 ;
16513 PyObject * obj0 = 0 ;
16514 PyObject * obj1 = 0 ;
16515 char * kwnames[] = {
16516 (char *) "self",(char *) "stick", NULL
16517 };
16518
16519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16521 if (!SWIG_IsOK(res1)) {
16522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16523 }
16524 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16525 ecode2 = SWIG_AsVal_int(obj1, &val2);
16526 if (!SWIG_IsOK(ecode2)) {
16527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16528 }
16529 arg2 = static_cast< int >(val2);
16530 {
16531 PyThreadState* __tstate = wxPyBeginAllowThreads();
16532 (arg1)->SetJoystick(arg2);
16533 wxPyEndAllowThreads(__tstate);
16534 if (PyErr_Occurred()) SWIG_fail;
16535 }
16536 resultobj = SWIG_Py_Void();
16537 return resultobj;
16538 fail:
16539 return NULL;
16540 }
16541
16542
16543 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16544 PyObject *resultobj = 0;
16545 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16546 int arg2 ;
16547 void *argp1 = 0 ;
16548 int res1 = 0 ;
16549 int val2 ;
16550 int ecode2 = 0 ;
16551 PyObject * obj0 = 0 ;
16552 PyObject * obj1 = 0 ;
16553 char * kwnames[] = {
16554 (char *) "self",(char *) "state", NULL
16555 };
16556
16557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16559 if (!SWIG_IsOK(res1)) {
16560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16561 }
16562 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16563 ecode2 = SWIG_AsVal_int(obj1, &val2);
16564 if (!SWIG_IsOK(ecode2)) {
16565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16566 }
16567 arg2 = static_cast< int >(val2);
16568 {
16569 PyThreadState* __tstate = wxPyBeginAllowThreads();
16570 (arg1)->SetButtonState(arg2);
16571 wxPyEndAllowThreads(__tstate);
16572 if (PyErr_Occurred()) SWIG_fail;
16573 }
16574 resultobj = SWIG_Py_Void();
16575 return resultobj;
16576 fail:
16577 return NULL;
16578 }
16579
16580
16581 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16582 PyObject *resultobj = 0;
16583 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16584 int arg2 ;
16585 void *argp1 = 0 ;
16586 int res1 = 0 ;
16587 int val2 ;
16588 int ecode2 = 0 ;
16589 PyObject * obj0 = 0 ;
16590 PyObject * obj1 = 0 ;
16591 char * kwnames[] = {
16592 (char *) "self",(char *) "change", NULL
16593 };
16594
16595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16597 if (!SWIG_IsOK(res1)) {
16598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16599 }
16600 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16601 ecode2 = SWIG_AsVal_int(obj1, &val2);
16602 if (!SWIG_IsOK(ecode2)) {
16603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16604 }
16605 arg2 = static_cast< int >(val2);
16606 {
16607 PyThreadState* __tstate = wxPyBeginAllowThreads();
16608 (arg1)->SetButtonChange(arg2);
16609 wxPyEndAllowThreads(__tstate);
16610 if (PyErr_Occurred()) SWIG_fail;
16611 }
16612 resultobj = SWIG_Py_Void();
16613 return resultobj;
16614 fail:
16615 return NULL;
16616 }
16617
16618
16619 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16620 PyObject *resultobj = 0;
16621 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16622 wxPoint *arg2 = 0 ;
16623 void *argp1 = 0 ;
16624 int res1 = 0 ;
16625 wxPoint temp2 ;
16626 PyObject * obj0 = 0 ;
16627 PyObject * obj1 = 0 ;
16628 char * kwnames[] = {
16629 (char *) "self",(char *) "pos", NULL
16630 };
16631
16632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16634 if (!SWIG_IsOK(res1)) {
16635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16636 }
16637 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16638 {
16639 arg2 = &temp2;
16640 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16641 }
16642 {
16643 PyThreadState* __tstate = wxPyBeginAllowThreads();
16644 (arg1)->SetPosition((wxPoint const &)*arg2);
16645 wxPyEndAllowThreads(__tstate);
16646 if (PyErr_Occurred()) SWIG_fail;
16647 }
16648 resultobj = SWIG_Py_Void();
16649 return resultobj;
16650 fail:
16651 return NULL;
16652 }
16653
16654
16655 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16656 PyObject *resultobj = 0;
16657 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16658 int arg2 ;
16659 void *argp1 = 0 ;
16660 int res1 = 0 ;
16661 int val2 ;
16662 int ecode2 = 0 ;
16663 PyObject * obj0 = 0 ;
16664 PyObject * obj1 = 0 ;
16665 char * kwnames[] = {
16666 (char *) "self",(char *) "zPos", NULL
16667 };
16668
16669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16671 if (!SWIG_IsOK(res1)) {
16672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16673 }
16674 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16675 ecode2 = SWIG_AsVal_int(obj1, &val2);
16676 if (!SWIG_IsOK(ecode2)) {
16677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16678 }
16679 arg2 = static_cast< int >(val2);
16680 {
16681 PyThreadState* __tstate = wxPyBeginAllowThreads();
16682 (arg1)->SetZPosition(arg2);
16683 wxPyEndAllowThreads(__tstate);
16684 if (PyErr_Occurred()) SWIG_fail;
16685 }
16686 resultobj = SWIG_Py_Void();
16687 return resultobj;
16688 fail:
16689 return NULL;
16690 }
16691
16692
16693 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16694 PyObject *resultobj = 0;
16695 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16696 bool result;
16697 void *argp1 = 0 ;
16698 int res1 = 0 ;
16699 PyObject *swig_obj[1] ;
16700
16701 if (!args) SWIG_fail;
16702 swig_obj[0] = args;
16703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16704 if (!SWIG_IsOK(res1)) {
16705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16706 }
16707 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16708 {
16709 PyThreadState* __tstate = wxPyBeginAllowThreads();
16710 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16711 wxPyEndAllowThreads(__tstate);
16712 if (PyErr_Occurred()) SWIG_fail;
16713 }
16714 {
16715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16716 }
16717 return resultobj;
16718 fail:
16719 return NULL;
16720 }
16721
16722
16723 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16724 PyObject *resultobj = 0;
16725 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16726 bool result;
16727 void *argp1 = 0 ;
16728 int res1 = 0 ;
16729 PyObject *swig_obj[1] ;
16730
16731 if (!args) SWIG_fail;
16732 swig_obj[0] = args;
16733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16734 if (!SWIG_IsOK(res1)) {
16735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16736 }
16737 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16738 {
16739 PyThreadState* __tstate = wxPyBeginAllowThreads();
16740 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16741 wxPyEndAllowThreads(__tstate);
16742 if (PyErr_Occurred()) SWIG_fail;
16743 }
16744 {
16745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16746 }
16747 return resultobj;
16748 fail:
16749 return NULL;
16750 }
16751
16752
16753 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16754 PyObject *resultobj = 0;
16755 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16756 bool result;
16757 void *argp1 = 0 ;
16758 int res1 = 0 ;
16759 PyObject *swig_obj[1] ;
16760
16761 if (!args) SWIG_fail;
16762 swig_obj[0] = args;
16763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16764 if (!SWIG_IsOK(res1)) {
16765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16766 }
16767 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16768 {
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16771 wxPyEndAllowThreads(__tstate);
16772 if (PyErr_Occurred()) SWIG_fail;
16773 }
16774 {
16775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16776 }
16777 return resultobj;
16778 fail:
16779 return NULL;
16780 }
16781
16782
16783 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16784 PyObject *resultobj = 0;
16785 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16786 int arg2 = (int) wxJOY_BUTTON_ANY ;
16787 bool result;
16788 void *argp1 = 0 ;
16789 int res1 = 0 ;
16790 int val2 ;
16791 int ecode2 = 0 ;
16792 PyObject * obj0 = 0 ;
16793 PyObject * obj1 = 0 ;
16794 char * kwnames[] = {
16795 (char *) "self",(char *) "but", NULL
16796 };
16797
16798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
16799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16800 if (!SWIG_IsOK(res1)) {
16801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16802 }
16803 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16804 if (obj1) {
16805 ecode2 = SWIG_AsVal_int(obj1, &val2);
16806 if (!SWIG_IsOK(ecode2)) {
16807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
16808 }
16809 arg2 = static_cast< int >(val2);
16810 }
16811 {
16812 PyThreadState* __tstate = wxPyBeginAllowThreads();
16813 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
16814 wxPyEndAllowThreads(__tstate);
16815 if (PyErr_Occurred()) SWIG_fail;
16816 }
16817 {
16818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16819 }
16820 return resultobj;
16821 fail:
16822 return NULL;
16823 }
16824
16825
16826 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16827 PyObject *resultobj = 0;
16828 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16829 int arg2 = (int) wxJOY_BUTTON_ANY ;
16830 bool result;
16831 void *argp1 = 0 ;
16832 int res1 = 0 ;
16833 int val2 ;
16834 int ecode2 = 0 ;
16835 PyObject * obj0 = 0 ;
16836 PyObject * obj1 = 0 ;
16837 char * kwnames[] = {
16838 (char *) "self",(char *) "but", NULL
16839 };
16840
16841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
16842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16843 if (!SWIG_IsOK(res1)) {
16844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16845 }
16846 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16847 if (obj1) {
16848 ecode2 = SWIG_AsVal_int(obj1, &val2);
16849 if (!SWIG_IsOK(ecode2)) {
16850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
16851 }
16852 arg2 = static_cast< int >(val2);
16853 }
16854 {
16855 PyThreadState* __tstate = wxPyBeginAllowThreads();
16856 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
16857 wxPyEndAllowThreads(__tstate);
16858 if (PyErr_Occurred()) SWIG_fail;
16859 }
16860 {
16861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16862 }
16863 return resultobj;
16864 fail:
16865 return NULL;
16866 }
16867
16868
16869 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16870 PyObject *resultobj = 0;
16871 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16872 int arg2 = (int) wxJOY_BUTTON_ANY ;
16873 bool result;
16874 void *argp1 = 0 ;
16875 int res1 = 0 ;
16876 int val2 ;
16877 int ecode2 = 0 ;
16878 PyObject * obj0 = 0 ;
16879 PyObject * obj1 = 0 ;
16880 char * kwnames[] = {
16881 (char *) "self",(char *) "but", NULL
16882 };
16883
16884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
16885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16886 if (!SWIG_IsOK(res1)) {
16887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16888 }
16889 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16890 if (obj1) {
16891 ecode2 = SWIG_AsVal_int(obj1, &val2);
16892 if (!SWIG_IsOK(ecode2)) {
16893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
16894 }
16895 arg2 = static_cast< int >(val2);
16896 }
16897 {
16898 PyThreadState* __tstate = wxPyBeginAllowThreads();
16899 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
16900 wxPyEndAllowThreads(__tstate);
16901 if (PyErr_Occurred()) SWIG_fail;
16902 }
16903 {
16904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16905 }
16906 return resultobj;
16907 fail:
16908 return NULL;
16909 }
16910
16911
16912 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16913 PyObject *obj;
16914 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16915 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
16916 return SWIG_Py_Void();
16917 }
16918
16919 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16920 return SWIG_Python_InitShadowInstance(args);
16921 }
16922
16923 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16924 PyObject *resultobj = 0;
16925 wxString const &arg1_defvalue = wxPyEmptyString ;
16926 wxString *arg1 = (wxString *) &arg1_defvalue ;
16927 wxSound *result = 0 ;
16928 bool temp1 = false ;
16929 PyObject * obj0 = 0 ;
16930 char * kwnames[] = {
16931 (char *) "fileName", NULL
16932 };
16933
16934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
16935 if (obj0) {
16936 {
16937 arg1 = wxString_in_helper(obj0);
16938 if (arg1 == NULL) SWIG_fail;
16939 temp1 = true;
16940 }
16941 }
16942 {
16943 if (!wxPyCheckForApp()) SWIG_fail;
16944 PyThreadState* __tstate = wxPyBeginAllowThreads();
16945 result = (wxSound *)new_wxSound((wxString const &)*arg1);
16946 wxPyEndAllowThreads(__tstate);
16947 if (PyErr_Occurred()) SWIG_fail;
16948 }
16949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
16950 {
16951 if (temp1)
16952 delete arg1;
16953 }
16954 return resultobj;
16955 fail:
16956 {
16957 if (temp1)
16958 delete arg1;
16959 }
16960 return NULL;
16961 }
16962
16963
16964 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16965 PyObject *resultobj = 0;
16966 PyObject *arg1 = (PyObject *) 0 ;
16967 wxSound *result = 0 ;
16968 PyObject * obj0 = 0 ;
16969 char * kwnames[] = {
16970 (char *) "data", NULL
16971 };
16972
16973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
16974 arg1 = obj0;
16975 {
16976 if (!wxPyCheckForApp()) SWIG_fail;
16977 PyThreadState* __tstate = wxPyBeginAllowThreads();
16978 result = (wxSound *)new_wxSound(arg1);
16979 wxPyEndAllowThreads(__tstate);
16980 if (PyErr_Occurred()) SWIG_fail;
16981 }
16982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
16983 return resultobj;
16984 fail:
16985 return NULL;
16986 }
16987
16988
16989 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16990 PyObject *resultobj = 0;
16991 wxSound *arg1 = (wxSound *) 0 ;
16992 void *argp1 = 0 ;
16993 int res1 = 0 ;
16994 PyObject *swig_obj[1] ;
16995
16996 if (!args) SWIG_fail;
16997 swig_obj[0] = args;
16998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
16999 if (!SWIG_IsOK(res1)) {
17000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17001 }
17002 arg1 = reinterpret_cast< wxSound * >(argp1);
17003 {
17004 PyThreadState* __tstate = wxPyBeginAllowThreads();
17005 delete arg1;
17006
17007 wxPyEndAllowThreads(__tstate);
17008 if (PyErr_Occurred()) SWIG_fail;
17009 }
17010 resultobj = SWIG_Py_Void();
17011 return resultobj;
17012 fail:
17013 return NULL;
17014 }
17015
17016
17017 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17018 PyObject *resultobj = 0;
17019 wxSound *arg1 = (wxSound *) 0 ;
17020 wxString *arg2 = 0 ;
17021 bool result;
17022 void *argp1 = 0 ;
17023 int res1 = 0 ;
17024 bool temp2 = false ;
17025 PyObject * obj0 = 0 ;
17026 PyObject * obj1 = 0 ;
17027 char * kwnames[] = {
17028 (char *) "self",(char *) "fileName", NULL
17029 };
17030
17031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17033 if (!SWIG_IsOK(res1)) {
17034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17035 }
17036 arg1 = reinterpret_cast< wxSound * >(argp1);
17037 {
17038 arg2 = wxString_in_helper(obj1);
17039 if (arg2 == NULL) SWIG_fail;
17040 temp2 = true;
17041 }
17042 {
17043 PyThreadState* __tstate = wxPyBeginAllowThreads();
17044 result = (bool)(arg1)->Create((wxString const &)*arg2);
17045 wxPyEndAllowThreads(__tstate);
17046 if (PyErr_Occurred()) SWIG_fail;
17047 }
17048 {
17049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17050 }
17051 {
17052 if (temp2)
17053 delete arg2;
17054 }
17055 return resultobj;
17056 fail:
17057 {
17058 if (temp2)
17059 delete arg2;
17060 }
17061 return NULL;
17062 }
17063
17064
17065 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17066 PyObject *resultobj = 0;
17067 wxSound *arg1 = (wxSound *) 0 ;
17068 PyObject *arg2 = (PyObject *) 0 ;
17069 bool result;
17070 void *argp1 = 0 ;
17071 int res1 = 0 ;
17072 PyObject * obj0 = 0 ;
17073 PyObject * obj1 = 0 ;
17074 char * kwnames[] = {
17075 (char *) "self",(char *) "data", NULL
17076 };
17077
17078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17080 if (!SWIG_IsOK(res1)) {
17081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17082 }
17083 arg1 = reinterpret_cast< wxSound * >(argp1);
17084 arg2 = obj1;
17085 {
17086 PyThreadState* __tstate = wxPyBeginAllowThreads();
17087 result = (bool)wxSound_CreateFromData(arg1,arg2);
17088 wxPyEndAllowThreads(__tstate);
17089 if (PyErr_Occurred()) SWIG_fail;
17090 }
17091 {
17092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17093 }
17094 return resultobj;
17095 fail:
17096 return NULL;
17097 }
17098
17099
17100 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17101 PyObject *resultobj = 0;
17102 wxSound *arg1 = (wxSound *) 0 ;
17103 bool result;
17104 void *argp1 = 0 ;
17105 int res1 = 0 ;
17106 PyObject *swig_obj[1] ;
17107
17108 if (!args) SWIG_fail;
17109 swig_obj[0] = args;
17110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17111 if (!SWIG_IsOK(res1)) {
17112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17113 }
17114 arg1 = reinterpret_cast< wxSound * >(argp1);
17115 {
17116 PyThreadState* __tstate = wxPyBeginAllowThreads();
17117 result = (bool)(arg1)->IsOk();
17118 wxPyEndAllowThreads(__tstate);
17119 if (PyErr_Occurred()) SWIG_fail;
17120 }
17121 {
17122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17123 }
17124 return resultobj;
17125 fail:
17126 return NULL;
17127 }
17128
17129
17130 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17131 PyObject *resultobj = 0;
17132 wxSound *arg1 = (wxSound *) 0 ;
17133 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17134 bool result;
17135 void *argp1 = 0 ;
17136 int res1 = 0 ;
17137 unsigned int val2 ;
17138 int ecode2 = 0 ;
17139 PyObject * obj0 = 0 ;
17140 PyObject * obj1 = 0 ;
17141 char * kwnames[] = {
17142 (char *) "self",(char *) "flags", NULL
17143 };
17144
17145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17147 if (!SWIG_IsOK(res1)) {
17148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17149 }
17150 arg1 = reinterpret_cast< wxSound * >(argp1);
17151 if (obj1) {
17152 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17153 if (!SWIG_IsOK(ecode2)) {
17154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17155 }
17156 arg2 = static_cast< unsigned int >(val2);
17157 }
17158 {
17159 if (!wxPyCheckForApp()) SWIG_fail;
17160 PyThreadState* __tstate = wxPyBeginAllowThreads();
17161 result = (bool)((wxSound const *)arg1)->Play(arg2);
17162 wxPyEndAllowThreads(__tstate);
17163 if (PyErr_Occurred()) SWIG_fail;
17164 }
17165 {
17166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17167 }
17168 return resultobj;
17169 fail:
17170 return NULL;
17171 }
17172
17173
17174 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17175 PyObject *resultobj = 0;
17176 wxString *arg1 = 0 ;
17177 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17178 bool result;
17179 bool temp1 = false ;
17180 unsigned int val2 ;
17181 int ecode2 = 0 ;
17182 PyObject * obj0 = 0 ;
17183 PyObject * obj1 = 0 ;
17184 char * kwnames[] = {
17185 (char *) "filename",(char *) "flags", NULL
17186 };
17187
17188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17189 {
17190 arg1 = wxString_in_helper(obj0);
17191 if (arg1 == NULL) SWIG_fail;
17192 temp1 = true;
17193 }
17194 if (obj1) {
17195 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17196 if (!SWIG_IsOK(ecode2)) {
17197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17198 }
17199 arg2 = static_cast< unsigned int >(val2);
17200 }
17201 {
17202 if (!wxPyCheckForApp()) SWIG_fail;
17203 PyThreadState* __tstate = wxPyBeginAllowThreads();
17204 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17205 wxPyEndAllowThreads(__tstate);
17206 if (PyErr_Occurred()) SWIG_fail;
17207 }
17208 {
17209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17210 }
17211 {
17212 if (temp1)
17213 delete arg1;
17214 }
17215 return resultobj;
17216 fail:
17217 {
17218 if (temp1)
17219 delete arg1;
17220 }
17221 return NULL;
17222 }
17223
17224
17225 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17226 PyObject *resultobj = 0;
17227
17228 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17229 {
17230 if (!wxPyCheckForApp()) SWIG_fail;
17231 PyThreadState* __tstate = wxPyBeginAllowThreads();
17232 wxSound::Stop();
17233 wxPyEndAllowThreads(__tstate);
17234 if (PyErr_Occurred()) SWIG_fail;
17235 }
17236 resultobj = SWIG_Py_Void();
17237 return resultobj;
17238 fail:
17239 return NULL;
17240 }
17241
17242
17243 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17244 PyObject *obj;
17245 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17246 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17247 return SWIG_Py_Void();
17248 }
17249
17250 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17251 return SWIG_Python_InitShadowInstance(args);
17252 }
17253
17254 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17255 PyObject *resultobj = 0;
17256 wxString *arg1 = 0 ;
17257 wxString *arg2 = 0 ;
17258 wxString *arg3 = 0 ;
17259 wxString *arg4 = 0 ;
17260 wxFileTypeInfo *result = 0 ;
17261 bool temp1 = false ;
17262 bool temp2 = false ;
17263 bool temp3 = false ;
17264 bool temp4 = false ;
17265 PyObject * obj0 = 0 ;
17266 PyObject * obj1 = 0 ;
17267 PyObject * obj2 = 0 ;
17268 PyObject * obj3 = 0 ;
17269 char * kwnames[] = {
17270 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17271 };
17272
17273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17274 {
17275 arg1 = wxString_in_helper(obj0);
17276 if (arg1 == NULL) SWIG_fail;
17277 temp1 = true;
17278 }
17279 {
17280 arg2 = wxString_in_helper(obj1);
17281 if (arg2 == NULL) SWIG_fail;
17282 temp2 = true;
17283 }
17284 {
17285 arg3 = wxString_in_helper(obj2);
17286 if (arg3 == NULL) SWIG_fail;
17287 temp3 = true;
17288 }
17289 {
17290 arg4 = wxString_in_helper(obj3);
17291 if (arg4 == NULL) SWIG_fail;
17292 temp4 = true;
17293 }
17294 {
17295 PyThreadState* __tstate = wxPyBeginAllowThreads();
17296 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17297 wxPyEndAllowThreads(__tstate);
17298 if (PyErr_Occurred()) SWIG_fail;
17299 }
17300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17301 {
17302 if (temp1)
17303 delete arg1;
17304 }
17305 {
17306 if (temp2)
17307 delete arg2;
17308 }
17309 {
17310 if (temp3)
17311 delete arg3;
17312 }
17313 {
17314 if (temp4)
17315 delete arg4;
17316 }
17317 return resultobj;
17318 fail:
17319 {
17320 if (temp1)
17321 delete arg1;
17322 }
17323 {
17324 if (temp2)
17325 delete arg2;
17326 }
17327 {
17328 if (temp3)
17329 delete arg3;
17330 }
17331 {
17332 if (temp4)
17333 delete arg4;
17334 }
17335 return NULL;
17336 }
17337
17338
17339 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17340 PyObject *resultobj = 0;
17341 wxArrayString *arg1 = 0 ;
17342 wxFileTypeInfo *result = 0 ;
17343 bool temp1 = false ;
17344 PyObject * obj0 = 0 ;
17345 char * kwnames[] = {
17346 (char *) "sArray", NULL
17347 };
17348
17349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17350 {
17351 if (! PySequence_Check(obj0)) {
17352 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17353 SWIG_fail;
17354 }
17355 arg1 = new wxArrayString;
17356 temp1 = true;
17357 int i, len=PySequence_Length(obj0);
17358 for (i=0; i<len; i++) {
17359 PyObject* item = PySequence_GetItem(obj0, i);
17360 wxString* s = wxString_in_helper(item);
17361 if (PyErr_Occurred()) SWIG_fail;
17362 arg1->Add(*s);
17363 delete s;
17364 Py_DECREF(item);
17365 }
17366 }
17367 {
17368 PyThreadState* __tstate = wxPyBeginAllowThreads();
17369 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17370 wxPyEndAllowThreads(__tstate);
17371 if (PyErr_Occurred()) SWIG_fail;
17372 }
17373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17374 {
17375 if (temp1) delete arg1;
17376 }
17377 return resultobj;
17378 fail:
17379 {
17380 if (temp1) delete arg1;
17381 }
17382 return NULL;
17383 }
17384
17385
17386 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17387 PyObject *resultobj = 0;
17388 wxFileTypeInfo *result = 0 ;
17389
17390 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17391 {
17392 PyThreadState* __tstate = wxPyBeginAllowThreads();
17393 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17394 wxPyEndAllowThreads(__tstate);
17395 if (PyErr_Occurred()) SWIG_fail;
17396 }
17397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17398 return resultobj;
17399 fail:
17400 return NULL;
17401 }
17402
17403
17404 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17405 PyObject *resultobj = 0;
17406 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17407 bool result;
17408 void *argp1 = 0 ;
17409 int res1 = 0 ;
17410 PyObject *swig_obj[1] ;
17411
17412 if (!args) SWIG_fail;
17413 swig_obj[0] = args;
17414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17415 if (!SWIG_IsOK(res1)) {
17416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17417 }
17418 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17419 {
17420 PyThreadState* __tstate = wxPyBeginAllowThreads();
17421 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17422 wxPyEndAllowThreads(__tstate);
17423 if (PyErr_Occurred()) SWIG_fail;
17424 }
17425 {
17426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17427 }
17428 return resultobj;
17429 fail:
17430 return NULL;
17431 }
17432
17433
17434 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17435 PyObject *resultobj = 0;
17436 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17437 wxString *arg2 = 0 ;
17438 int arg3 = (int) 0 ;
17439 void *argp1 = 0 ;
17440 int res1 = 0 ;
17441 bool temp2 = false ;
17442 int val3 ;
17443 int ecode3 = 0 ;
17444 PyObject * obj0 = 0 ;
17445 PyObject * obj1 = 0 ;
17446 PyObject * obj2 = 0 ;
17447 char * kwnames[] = {
17448 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17449 };
17450
17451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17453 if (!SWIG_IsOK(res1)) {
17454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17455 }
17456 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17457 {
17458 arg2 = wxString_in_helper(obj1);
17459 if (arg2 == NULL) SWIG_fail;
17460 temp2 = true;
17461 }
17462 if (obj2) {
17463 ecode3 = SWIG_AsVal_int(obj2, &val3);
17464 if (!SWIG_IsOK(ecode3)) {
17465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17466 }
17467 arg3 = static_cast< int >(val3);
17468 }
17469 {
17470 PyThreadState* __tstate = wxPyBeginAllowThreads();
17471 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17472 wxPyEndAllowThreads(__tstate);
17473 if (PyErr_Occurred()) SWIG_fail;
17474 }
17475 resultobj = SWIG_Py_Void();
17476 {
17477 if (temp2)
17478 delete arg2;
17479 }
17480 return resultobj;
17481 fail:
17482 {
17483 if (temp2)
17484 delete arg2;
17485 }
17486 return NULL;
17487 }
17488
17489
17490 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17491 PyObject *resultobj = 0;
17492 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17493 wxString *arg2 = 0 ;
17494 void *argp1 = 0 ;
17495 int res1 = 0 ;
17496 bool temp2 = false ;
17497 PyObject * obj0 = 0 ;
17498 PyObject * obj1 = 0 ;
17499 char * kwnames[] = {
17500 (char *) "self",(char *) "shortDesc", NULL
17501 };
17502
17503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17505 if (!SWIG_IsOK(res1)) {
17506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17507 }
17508 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17509 {
17510 arg2 = wxString_in_helper(obj1);
17511 if (arg2 == NULL) SWIG_fail;
17512 temp2 = true;
17513 }
17514 {
17515 PyThreadState* __tstate = wxPyBeginAllowThreads();
17516 (arg1)->SetShortDesc((wxString const &)*arg2);
17517 wxPyEndAllowThreads(__tstate);
17518 if (PyErr_Occurred()) SWIG_fail;
17519 }
17520 resultobj = SWIG_Py_Void();
17521 {
17522 if (temp2)
17523 delete arg2;
17524 }
17525 return resultobj;
17526 fail:
17527 {
17528 if (temp2)
17529 delete arg2;
17530 }
17531 return NULL;
17532 }
17533
17534
17535 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17536 PyObject *resultobj = 0;
17537 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17538 wxString *result = 0 ;
17539 void *argp1 = 0 ;
17540 int res1 = 0 ;
17541 PyObject *swig_obj[1] ;
17542
17543 if (!args) SWIG_fail;
17544 swig_obj[0] = args;
17545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17546 if (!SWIG_IsOK(res1)) {
17547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17548 }
17549 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17550 {
17551 PyThreadState* __tstate = wxPyBeginAllowThreads();
17552 {
17553 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17554 result = (wxString *) &_result_ref;
17555 }
17556 wxPyEndAllowThreads(__tstate);
17557 if (PyErr_Occurred()) SWIG_fail;
17558 }
17559 {
17560 #if wxUSE_UNICODE
17561 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17562 #else
17563 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17564 #endif
17565 }
17566 return resultobj;
17567 fail:
17568 return NULL;
17569 }
17570
17571
17572 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17573 PyObject *resultobj = 0;
17574 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17575 wxString *result = 0 ;
17576 void *argp1 = 0 ;
17577 int res1 = 0 ;
17578 PyObject *swig_obj[1] ;
17579
17580 if (!args) SWIG_fail;
17581 swig_obj[0] = args;
17582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17583 if (!SWIG_IsOK(res1)) {
17584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17585 }
17586 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17587 {
17588 PyThreadState* __tstate = wxPyBeginAllowThreads();
17589 {
17590 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17591 result = (wxString *) &_result_ref;
17592 }
17593 wxPyEndAllowThreads(__tstate);
17594 if (PyErr_Occurred()) SWIG_fail;
17595 }
17596 {
17597 #if wxUSE_UNICODE
17598 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17599 #else
17600 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17601 #endif
17602 }
17603 return resultobj;
17604 fail:
17605 return NULL;
17606 }
17607
17608
17609 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17610 PyObject *resultobj = 0;
17611 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17612 wxString *result = 0 ;
17613 void *argp1 = 0 ;
17614 int res1 = 0 ;
17615 PyObject *swig_obj[1] ;
17616
17617 if (!args) SWIG_fail;
17618 swig_obj[0] = args;
17619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17620 if (!SWIG_IsOK(res1)) {
17621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17622 }
17623 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17624 {
17625 PyThreadState* __tstate = wxPyBeginAllowThreads();
17626 {
17627 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17628 result = (wxString *) &_result_ref;
17629 }
17630 wxPyEndAllowThreads(__tstate);
17631 if (PyErr_Occurred()) SWIG_fail;
17632 }
17633 {
17634 #if wxUSE_UNICODE
17635 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17636 #else
17637 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17638 #endif
17639 }
17640 return resultobj;
17641 fail:
17642 return NULL;
17643 }
17644
17645
17646 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17647 PyObject *resultobj = 0;
17648 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17649 wxString *result = 0 ;
17650 void *argp1 = 0 ;
17651 int res1 = 0 ;
17652 PyObject *swig_obj[1] ;
17653
17654 if (!args) SWIG_fail;
17655 swig_obj[0] = args;
17656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17657 if (!SWIG_IsOK(res1)) {
17658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17659 }
17660 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17661 {
17662 PyThreadState* __tstate = wxPyBeginAllowThreads();
17663 {
17664 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17665 result = (wxString *) &_result_ref;
17666 }
17667 wxPyEndAllowThreads(__tstate);
17668 if (PyErr_Occurred()) SWIG_fail;
17669 }
17670 {
17671 #if wxUSE_UNICODE
17672 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17673 #else
17674 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17675 #endif
17676 }
17677 return resultobj;
17678 fail:
17679 return NULL;
17680 }
17681
17682
17683 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17684 PyObject *resultobj = 0;
17685 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17686 wxString *result = 0 ;
17687 void *argp1 = 0 ;
17688 int res1 = 0 ;
17689 PyObject *swig_obj[1] ;
17690
17691 if (!args) SWIG_fail;
17692 swig_obj[0] = args;
17693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17694 if (!SWIG_IsOK(res1)) {
17695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17696 }
17697 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17698 {
17699 PyThreadState* __tstate = wxPyBeginAllowThreads();
17700 {
17701 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17702 result = (wxString *) &_result_ref;
17703 }
17704 wxPyEndAllowThreads(__tstate);
17705 if (PyErr_Occurred()) SWIG_fail;
17706 }
17707 {
17708 #if wxUSE_UNICODE
17709 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17710 #else
17711 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17712 #endif
17713 }
17714 return resultobj;
17715 fail:
17716 return NULL;
17717 }
17718
17719
17720 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17721 PyObject *resultobj = 0;
17722 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17723 wxArrayString *result = 0 ;
17724 void *argp1 = 0 ;
17725 int res1 = 0 ;
17726 PyObject *swig_obj[1] ;
17727
17728 if (!args) SWIG_fail;
17729 swig_obj[0] = args;
17730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17731 if (!SWIG_IsOK(res1)) {
17732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17733 }
17734 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17735 {
17736 PyThreadState* __tstate = wxPyBeginAllowThreads();
17737 {
17738 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17739 result = (wxArrayString *) &_result_ref;
17740 }
17741 wxPyEndAllowThreads(__tstate);
17742 if (PyErr_Occurred()) SWIG_fail;
17743 }
17744 {
17745 resultobj = wxArrayString2PyList_helper(*result);
17746 }
17747 return resultobj;
17748 fail:
17749 return NULL;
17750 }
17751
17752
17753 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17754 PyObject *resultobj = 0;
17755 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17756 size_t result;
17757 void *argp1 = 0 ;
17758 int res1 = 0 ;
17759 PyObject *swig_obj[1] ;
17760
17761 if (!args) SWIG_fail;
17762 swig_obj[0] = args;
17763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17764 if (!SWIG_IsOK(res1)) {
17765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17766 }
17767 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17768 {
17769 PyThreadState* __tstate = wxPyBeginAllowThreads();
17770 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17771 wxPyEndAllowThreads(__tstate);
17772 if (PyErr_Occurred()) SWIG_fail;
17773 }
17774 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17775 return resultobj;
17776 fail:
17777 return NULL;
17778 }
17779
17780
17781 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17782 PyObject *resultobj = 0;
17783 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17784 wxString *result = 0 ;
17785 void *argp1 = 0 ;
17786 int res1 = 0 ;
17787 PyObject *swig_obj[1] ;
17788
17789 if (!args) SWIG_fail;
17790 swig_obj[0] = args;
17791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17792 if (!SWIG_IsOK(res1)) {
17793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17794 }
17795 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17796 {
17797 PyThreadState* __tstate = wxPyBeginAllowThreads();
17798 {
17799 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
17800 result = (wxString *) &_result_ref;
17801 }
17802 wxPyEndAllowThreads(__tstate);
17803 if (PyErr_Occurred()) SWIG_fail;
17804 }
17805 {
17806 #if wxUSE_UNICODE
17807 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17808 #else
17809 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17810 #endif
17811 }
17812 return resultobj;
17813 fail:
17814 return NULL;
17815 }
17816
17817
17818 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17819 PyObject *resultobj = 0;
17820 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17821 int result;
17822 void *argp1 = 0 ;
17823 int res1 = 0 ;
17824 PyObject *swig_obj[1] ;
17825
17826 if (!args) SWIG_fail;
17827 swig_obj[0] = args;
17828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17829 if (!SWIG_IsOK(res1)) {
17830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17831 }
17832 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17833 {
17834 PyThreadState* __tstate = wxPyBeginAllowThreads();
17835 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
17836 wxPyEndAllowThreads(__tstate);
17837 if (PyErr_Occurred()) SWIG_fail;
17838 }
17839 resultobj = SWIG_From_int(static_cast< int >(result));
17840 return resultobj;
17841 fail:
17842 return NULL;
17843 }
17844
17845
17846 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17847 PyObject *obj;
17848 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17849 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
17850 return SWIG_Py_Void();
17851 }
17852
17853 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17854 return SWIG_Python_InitShadowInstance(args);
17855 }
17856
17857 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17858 PyObject *resultobj = 0;
17859 wxFileTypeInfo *arg1 = 0 ;
17860 wxFileType *result = 0 ;
17861 void *argp1 = 0 ;
17862 int res1 = 0 ;
17863 PyObject * obj0 = 0 ;
17864 char * kwnames[] = {
17865 (char *) "ftInfo", NULL
17866 };
17867
17868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
17869 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17870 if (!SWIG_IsOK(res1)) {
17871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
17872 }
17873 if (!argp1) {
17874 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
17875 }
17876 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17877 {
17878 PyThreadState* __tstate = wxPyBeginAllowThreads();
17879 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
17880 wxPyEndAllowThreads(__tstate);
17881 if (PyErr_Occurred()) SWIG_fail;
17882 }
17883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
17884 return resultobj;
17885 fail:
17886 return NULL;
17887 }
17888
17889
17890 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17891 PyObject *resultobj = 0;
17892 wxFileType *arg1 = (wxFileType *) 0 ;
17893 void *argp1 = 0 ;
17894 int res1 = 0 ;
17895 PyObject *swig_obj[1] ;
17896
17897 if (!args) SWIG_fail;
17898 swig_obj[0] = args;
17899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
17900 if (!SWIG_IsOK(res1)) {
17901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
17902 }
17903 arg1 = reinterpret_cast< wxFileType * >(argp1);
17904 {
17905 PyThreadState* __tstate = wxPyBeginAllowThreads();
17906 delete arg1;
17907
17908 wxPyEndAllowThreads(__tstate);
17909 if (PyErr_Occurred()) SWIG_fail;
17910 }
17911 resultobj = SWIG_Py_Void();
17912 return resultobj;
17913 fail:
17914 return NULL;
17915 }
17916
17917
17918 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17919 PyObject *resultobj = 0;
17920 wxFileType *arg1 = (wxFileType *) 0 ;
17921 PyObject *result = 0 ;
17922 void *argp1 = 0 ;
17923 int res1 = 0 ;
17924 PyObject *swig_obj[1] ;
17925
17926 if (!args) SWIG_fail;
17927 swig_obj[0] = args;
17928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17929 if (!SWIG_IsOK(res1)) {
17930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
17931 }
17932 arg1 = reinterpret_cast< wxFileType * >(argp1);
17933 {
17934 PyThreadState* __tstate = wxPyBeginAllowThreads();
17935 result = (PyObject *)wxFileType_GetMimeType(arg1);
17936 wxPyEndAllowThreads(__tstate);
17937 if (PyErr_Occurred()) SWIG_fail;
17938 }
17939 resultobj = result;
17940 return resultobj;
17941 fail:
17942 return NULL;
17943 }
17944
17945
17946 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17947 PyObject *resultobj = 0;
17948 wxFileType *arg1 = (wxFileType *) 0 ;
17949 PyObject *result = 0 ;
17950 void *argp1 = 0 ;
17951 int res1 = 0 ;
17952 PyObject *swig_obj[1] ;
17953
17954 if (!args) SWIG_fail;
17955 swig_obj[0] = args;
17956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17957 if (!SWIG_IsOK(res1)) {
17958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
17959 }
17960 arg1 = reinterpret_cast< wxFileType * >(argp1);
17961 {
17962 PyThreadState* __tstate = wxPyBeginAllowThreads();
17963 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
17964 wxPyEndAllowThreads(__tstate);
17965 if (PyErr_Occurred()) SWIG_fail;
17966 }
17967 resultobj = result;
17968 return resultobj;
17969 fail:
17970 return NULL;
17971 }
17972
17973
17974 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17975 PyObject *resultobj = 0;
17976 wxFileType *arg1 = (wxFileType *) 0 ;
17977 PyObject *result = 0 ;
17978 void *argp1 = 0 ;
17979 int res1 = 0 ;
17980 PyObject *swig_obj[1] ;
17981
17982 if (!args) SWIG_fail;
17983 swig_obj[0] = args;
17984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17985 if (!SWIG_IsOK(res1)) {
17986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
17987 }
17988 arg1 = reinterpret_cast< wxFileType * >(argp1);
17989 {
17990 PyThreadState* __tstate = wxPyBeginAllowThreads();
17991 result = (PyObject *)wxFileType_GetExtensions(arg1);
17992 wxPyEndAllowThreads(__tstate);
17993 if (PyErr_Occurred()) SWIG_fail;
17994 }
17995 resultobj = result;
17996 return resultobj;
17997 fail:
17998 return NULL;
17999 }
18000
18001
18002 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18003 PyObject *resultobj = 0;
18004 wxFileType *arg1 = (wxFileType *) 0 ;
18005 wxIcon *result = 0 ;
18006 void *argp1 = 0 ;
18007 int res1 = 0 ;
18008 PyObject *swig_obj[1] ;
18009
18010 if (!args) SWIG_fail;
18011 swig_obj[0] = args;
18012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18013 if (!SWIG_IsOK(res1)) {
18014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18015 }
18016 arg1 = reinterpret_cast< wxFileType * >(argp1);
18017 {
18018 PyThreadState* __tstate = wxPyBeginAllowThreads();
18019 result = (wxIcon *)wxFileType_GetIcon(arg1);
18020 wxPyEndAllowThreads(__tstate);
18021 if (PyErr_Occurred()) SWIG_fail;
18022 }
18023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18024 return resultobj;
18025 fail:
18026 return NULL;
18027 }
18028
18029
18030 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18031 PyObject *resultobj = 0;
18032 wxFileType *arg1 = (wxFileType *) 0 ;
18033 PyObject *result = 0 ;
18034 void *argp1 = 0 ;
18035 int res1 = 0 ;
18036 PyObject *swig_obj[1] ;
18037
18038 if (!args) SWIG_fail;
18039 swig_obj[0] = args;
18040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18041 if (!SWIG_IsOK(res1)) {
18042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18043 }
18044 arg1 = reinterpret_cast< wxFileType * >(argp1);
18045 {
18046 PyThreadState* __tstate = wxPyBeginAllowThreads();
18047 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18048 wxPyEndAllowThreads(__tstate);
18049 if (PyErr_Occurred()) SWIG_fail;
18050 }
18051 resultobj = result;
18052 return resultobj;
18053 fail:
18054 return NULL;
18055 }
18056
18057
18058 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18059 PyObject *resultobj = 0;
18060 wxFileType *arg1 = (wxFileType *) 0 ;
18061 PyObject *result = 0 ;
18062 void *argp1 = 0 ;
18063 int res1 = 0 ;
18064 PyObject *swig_obj[1] ;
18065
18066 if (!args) SWIG_fail;
18067 swig_obj[0] = args;
18068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18069 if (!SWIG_IsOK(res1)) {
18070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18071 }
18072 arg1 = reinterpret_cast< wxFileType * >(argp1);
18073 {
18074 PyThreadState* __tstate = wxPyBeginAllowThreads();
18075 result = (PyObject *)wxFileType_GetDescription(arg1);
18076 wxPyEndAllowThreads(__tstate);
18077 if (PyErr_Occurred()) SWIG_fail;
18078 }
18079 resultobj = result;
18080 return resultobj;
18081 fail:
18082 return NULL;
18083 }
18084
18085
18086 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18087 PyObject *resultobj = 0;
18088 wxFileType *arg1 = (wxFileType *) 0 ;
18089 wxString *arg2 = 0 ;
18090 wxString const &arg3_defvalue = wxPyEmptyString ;
18091 wxString *arg3 = (wxString *) &arg3_defvalue ;
18092 PyObject *result = 0 ;
18093 void *argp1 = 0 ;
18094 int res1 = 0 ;
18095 bool temp2 = false ;
18096 bool temp3 = false ;
18097 PyObject * obj0 = 0 ;
18098 PyObject * obj1 = 0 ;
18099 PyObject * obj2 = 0 ;
18100 char * kwnames[] = {
18101 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18102 };
18103
18104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18106 if (!SWIG_IsOK(res1)) {
18107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18108 }
18109 arg1 = reinterpret_cast< wxFileType * >(argp1);
18110 {
18111 arg2 = wxString_in_helper(obj1);
18112 if (arg2 == NULL) SWIG_fail;
18113 temp2 = true;
18114 }
18115 if (obj2) {
18116 {
18117 arg3 = wxString_in_helper(obj2);
18118 if (arg3 == NULL) SWIG_fail;
18119 temp3 = true;
18120 }
18121 }
18122 {
18123 PyThreadState* __tstate = wxPyBeginAllowThreads();
18124 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18125 wxPyEndAllowThreads(__tstate);
18126 if (PyErr_Occurred()) SWIG_fail;
18127 }
18128 resultobj = result;
18129 {
18130 if (temp2)
18131 delete arg2;
18132 }
18133 {
18134 if (temp3)
18135 delete arg3;
18136 }
18137 return resultobj;
18138 fail:
18139 {
18140 if (temp2)
18141 delete arg2;
18142 }
18143 {
18144 if (temp3)
18145 delete arg3;
18146 }
18147 return NULL;
18148 }
18149
18150
18151 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18152 PyObject *resultobj = 0;
18153 wxFileType *arg1 = (wxFileType *) 0 ;
18154 wxString *arg2 = 0 ;
18155 wxString const &arg3_defvalue = wxPyEmptyString ;
18156 wxString *arg3 = (wxString *) &arg3_defvalue ;
18157 PyObject *result = 0 ;
18158 void *argp1 = 0 ;
18159 int res1 = 0 ;
18160 bool temp2 = false ;
18161 bool temp3 = false ;
18162 PyObject * obj0 = 0 ;
18163 PyObject * obj1 = 0 ;
18164 PyObject * obj2 = 0 ;
18165 char * kwnames[] = {
18166 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18167 };
18168
18169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18171 if (!SWIG_IsOK(res1)) {
18172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18173 }
18174 arg1 = reinterpret_cast< wxFileType * >(argp1);
18175 {
18176 arg2 = wxString_in_helper(obj1);
18177 if (arg2 == NULL) SWIG_fail;
18178 temp2 = true;
18179 }
18180 if (obj2) {
18181 {
18182 arg3 = wxString_in_helper(obj2);
18183 if (arg3 == NULL) SWIG_fail;
18184 temp3 = true;
18185 }
18186 }
18187 {
18188 PyThreadState* __tstate = wxPyBeginAllowThreads();
18189 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18190 wxPyEndAllowThreads(__tstate);
18191 if (PyErr_Occurred()) SWIG_fail;
18192 }
18193 resultobj = result;
18194 {
18195 if (temp2)
18196 delete arg2;
18197 }
18198 {
18199 if (temp3)
18200 delete arg3;
18201 }
18202 return resultobj;
18203 fail:
18204 {
18205 if (temp2)
18206 delete arg2;
18207 }
18208 {
18209 if (temp3)
18210 delete arg3;
18211 }
18212 return NULL;
18213 }
18214
18215
18216 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18217 PyObject *resultobj = 0;
18218 wxFileType *arg1 = (wxFileType *) 0 ;
18219 wxString *arg2 = 0 ;
18220 wxString const &arg3_defvalue = wxPyEmptyString ;
18221 wxString *arg3 = (wxString *) &arg3_defvalue ;
18222 PyObject *result = 0 ;
18223 void *argp1 = 0 ;
18224 int res1 = 0 ;
18225 bool temp2 = false ;
18226 bool temp3 = false ;
18227 PyObject * obj0 = 0 ;
18228 PyObject * obj1 = 0 ;
18229 PyObject * obj2 = 0 ;
18230 char * kwnames[] = {
18231 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18232 };
18233
18234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18236 if (!SWIG_IsOK(res1)) {
18237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18238 }
18239 arg1 = reinterpret_cast< wxFileType * >(argp1);
18240 {
18241 arg2 = wxString_in_helper(obj1);
18242 if (arg2 == NULL) SWIG_fail;
18243 temp2 = true;
18244 }
18245 if (obj2) {
18246 {
18247 arg3 = wxString_in_helper(obj2);
18248 if (arg3 == NULL) SWIG_fail;
18249 temp3 = true;
18250 }
18251 }
18252 {
18253 PyThreadState* __tstate = wxPyBeginAllowThreads();
18254 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18255 wxPyEndAllowThreads(__tstate);
18256 if (PyErr_Occurred()) SWIG_fail;
18257 }
18258 resultobj = result;
18259 {
18260 if (temp2)
18261 delete arg2;
18262 }
18263 {
18264 if (temp3)
18265 delete arg3;
18266 }
18267 return resultobj;
18268 fail:
18269 {
18270 if (temp2)
18271 delete arg2;
18272 }
18273 {
18274 if (temp3)
18275 delete arg3;
18276 }
18277 return NULL;
18278 }
18279
18280
18281 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18282 PyObject *resultobj = 0;
18283 wxFileType *arg1 = (wxFileType *) 0 ;
18284 wxString *arg2 = 0 ;
18285 wxString *arg3 = 0 ;
18286 bool arg4 = (bool) true ;
18287 bool result;
18288 void *argp1 = 0 ;
18289 int res1 = 0 ;
18290 bool temp2 = false ;
18291 bool temp3 = false ;
18292 bool val4 ;
18293 int ecode4 = 0 ;
18294 PyObject * obj0 = 0 ;
18295 PyObject * obj1 = 0 ;
18296 PyObject * obj2 = 0 ;
18297 PyObject * obj3 = 0 ;
18298 char * kwnames[] = {
18299 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18300 };
18301
18302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18304 if (!SWIG_IsOK(res1)) {
18305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18306 }
18307 arg1 = reinterpret_cast< wxFileType * >(argp1);
18308 {
18309 arg2 = wxString_in_helper(obj1);
18310 if (arg2 == NULL) SWIG_fail;
18311 temp2 = true;
18312 }
18313 {
18314 arg3 = wxString_in_helper(obj2);
18315 if (arg3 == NULL) SWIG_fail;
18316 temp3 = true;
18317 }
18318 if (obj3) {
18319 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18320 if (!SWIG_IsOK(ecode4)) {
18321 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18322 }
18323 arg4 = static_cast< bool >(val4);
18324 }
18325 {
18326 PyThreadState* __tstate = wxPyBeginAllowThreads();
18327 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18328 wxPyEndAllowThreads(__tstate);
18329 if (PyErr_Occurred()) SWIG_fail;
18330 }
18331 {
18332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18333 }
18334 {
18335 if (temp2)
18336 delete arg2;
18337 }
18338 {
18339 if (temp3)
18340 delete arg3;
18341 }
18342 return resultobj;
18343 fail:
18344 {
18345 if (temp2)
18346 delete arg2;
18347 }
18348 {
18349 if (temp3)
18350 delete arg3;
18351 }
18352 return NULL;
18353 }
18354
18355
18356 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18357 PyObject *resultobj = 0;
18358 wxFileType *arg1 = (wxFileType *) 0 ;
18359 wxString const &arg2_defvalue = wxPyEmptyString ;
18360 wxString *arg2 = (wxString *) &arg2_defvalue ;
18361 int arg3 = (int) 0 ;
18362 bool result;
18363 void *argp1 = 0 ;
18364 int res1 = 0 ;
18365 bool temp2 = false ;
18366 int val3 ;
18367 int ecode3 = 0 ;
18368 PyObject * obj0 = 0 ;
18369 PyObject * obj1 = 0 ;
18370 PyObject * obj2 = 0 ;
18371 char * kwnames[] = {
18372 (char *) "self",(char *) "cmd",(char *) "index", NULL
18373 };
18374
18375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18377 if (!SWIG_IsOK(res1)) {
18378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18379 }
18380 arg1 = reinterpret_cast< wxFileType * >(argp1);
18381 if (obj1) {
18382 {
18383 arg2 = wxString_in_helper(obj1);
18384 if (arg2 == NULL) SWIG_fail;
18385 temp2 = true;
18386 }
18387 }
18388 if (obj2) {
18389 ecode3 = SWIG_AsVal_int(obj2, &val3);
18390 if (!SWIG_IsOK(ecode3)) {
18391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18392 }
18393 arg3 = static_cast< int >(val3);
18394 }
18395 {
18396 PyThreadState* __tstate = wxPyBeginAllowThreads();
18397 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18398 wxPyEndAllowThreads(__tstate);
18399 if (PyErr_Occurred()) SWIG_fail;
18400 }
18401 {
18402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18403 }
18404 {
18405 if (temp2)
18406 delete arg2;
18407 }
18408 return resultobj;
18409 fail:
18410 {
18411 if (temp2)
18412 delete arg2;
18413 }
18414 return NULL;
18415 }
18416
18417
18418 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18419 PyObject *resultobj = 0;
18420 wxFileType *arg1 = (wxFileType *) 0 ;
18421 bool result;
18422 void *argp1 = 0 ;
18423 int res1 = 0 ;
18424 PyObject *swig_obj[1] ;
18425
18426 if (!args) SWIG_fail;
18427 swig_obj[0] = args;
18428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18429 if (!SWIG_IsOK(res1)) {
18430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18431 }
18432 arg1 = reinterpret_cast< wxFileType * >(argp1);
18433 {
18434 PyThreadState* __tstate = wxPyBeginAllowThreads();
18435 result = (bool)(arg1)->Unassociate();
18436 wxPyEndAllowThreads(__tstate);
18437 if (PyErr_Occurred()) SWIG_fail;
18438 }
18439 {
18440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18441 }
18442 return resultobj;
18443 fail:
18444 return NULL;
18445 }
18446
18447
18448 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18449 PyObject *resultobj = 0;
18450 wxString *arg1 = 0 ;
18451 wxString *arg2 = 0 ;
18452 wxString const &arg3_defvalue = wxPyEmptyString ;
18453 wxString *arg3 = (wxString *) &arg3_defvalue ;
18454 wxString result;
18455 bool temp1 = false ;
18456 bool temp2 = false ;
18457 bool temp3 = false ;
18458 PyObject * obj0 = 0 ;
18459 PyObject * obj1 = 0 ;
18460 PyObject * obj2 = 0 ;
18461 char * kwnames[] = {
18462 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18463 };
18464
18465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18466 {
18467 arg1 = wxString_in_helper(obj0);
18468 if (arg1 == NULL) SWIG_fail;
18469 temp1 = true;
18470 }
18471 {
18472 arg2 = wxString_in_helper(obj1);
18473 if (arg2 == NULL) SWIG_fail;
18474 temp2 = true;
18475 }
18476 if (obj2) {
18477 {
18478 arg3 = wxString_in_helper(obj2);
18479 if (arg3 == NULL) SWIG_fail;
18480 temp3 = true;
18481 }
18482 }
18483 {
18484 PyThreadState* __tstate = wxPyBeginAllowThreads();
18485 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18486 wxPyEndAllowThreads(__tstate);
18487 if (PyErr_Occurred()) SWIG_fail;
18488 }
18489 {
18490 #if wxUSE_UNICODE
18491 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18492 #else
18493 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18494 #endif
18495 }
18496 {
18497 if (temp1)
18498 delete arg1;
18499 }
18500 {
18501 if (temp2)
18502 delete arg2;
18503 }
18504 {
18505 if (temp3)
18506 delete arg3;
18507 }
18508 return resultobj;
18509 fail:
18510 {
18511 if (temp1)
18512 delete arg1;
18513 }
18514 {
18515 if (temp2)
18516 delete arg2;
18517 }
18518 {
18519 if (temp3)
18520 delete arg3;
18521 }
18522 return NULL;
18523 }
18524
18525
18526 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18527 PyObject *obj;
18528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18529 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18530 return SWIG_Py_Void();
18531 }
18532
18533 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18534 return SWIG_Python_InitShadowInstance(args);
18535 }
18536
18537 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18538 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18539 return 1;
18540 }
18541
18542
18543 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18544 PyObject *pyobj = 0;
18545
18546 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18547 return pyobj;
18548 }
18549
18550
18551 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18552 PyObject *resultobj = 0;
18553 wxString *arg1 = 0 ;
18554 wxString *arg2 = 0 ;
18555 bool result;
18556 bool temp1 = false ;
18557 bool temp2 = false ;
18558 PyObject * obj0 = 0 ;
18559 PyObject * obj1 = 0 ;
18560 char * kwnames[] = {
18561 (char *) "mimeType",(char *) "wildcard", NULL
18562 };
18563
18564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18565 {
18566 arg1 = wxString_in_helper(obj0);
18567 if (arg1 == NULL) SWIG_fail;
18568 temp1 = true;
18569 }
18570 {
18571 arg2 = wxString_in_helper(obj1);
18572 if (arg2 == NULL) SWIG_fail;
18573 temp2 = true;
18574 }
18575 {
18576 PyThreadState* __tstate = wxPyBeginAllowThreads();
18577 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18578 wxPyEndAllowThreads(__tstate);
18579 if (PyErr_Occurred()) SWIG_fail;
18580 }
18581 {
18582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18583 }
18584 {
18585 if (temp1)
18586 delete arg1;
18587 }
18588 {
18589 if (temp2)
18590 delete arg2;
18591 }
18592 return resultobj;
18593 fail:
18594 {
18595 if (temp1)
18596 delete arg1;
18597 }
18598 {
18599 if (temp2)
18600 delete arg2;
18601 }
18602 return NULL;
18603 }
18604
18605
18606 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18607 PyObject *resultobj = 0;
18608 wxMimeTypesManager *result = 0 ;
18609
18610 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18611 {
18612 PyThreadState* __tstate = wxPyBeginAllowThreads();
18613 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18614 wxPyEndAllowThreads(__tstate);
18615 if (PyErr_Occurred()) SWIG_fail;
18616 }
18617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18618 return resultobj;
18619 fail:
18620 return NULL;
18621 }
18622
18623
18624 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18625 PyObject *resultobj = 0;
18626 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18627 int arg2 = (int) wxMAILCAP_ALL ;
18628 wxString const &arg3_defvalue = wxPyEmptyString ;
18629 wxString *arg3 = (wxString *) &arg3_defvalue ;
18630 void *argp1 = 0 ;
18631 int res1 = 0 ;
18632 int val2 ;
18633 int ecode2 = 0 ;
18634 bool temp3 = false ;
18635 PyObject * obj0 = 0 ;
18636 PyObject * obj1 = 0 ;
18637 PyObject * obj2 = 0 ;
18638 char * kwnames[] = {
18639 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18640 };
18641
18642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18644 if (!SWIG_IsOK(res1)) {
18645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18646 }
18647 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18648 if (obj1) {
18649 ecode2 = SWIG_AsVal_int(obj1, &val2);
18650 if (!SWIG_IsOK(ecode2)) {
18651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18652 }
18653 arg2 = static_cast< int >(val2);
18654 }
18655 if (obj2) {
18656 {
18657 arg3 = wxString_in_helper(obj2);
18658 if (arg3 == NULL) SWIG_fail;
18659 temp3 = true;
18660 }
18661 }
18662 {
18663 PyThreadState* __tstate = wxPyBeginAllowThreads();
18664 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18665 wxPyEndAllowThreads(__tstate);
18666 if (PyErr_Occurred()) SWIG_fail;
18667 }
18668 resultobj = SWIG_Py_Void();
18669 {
18670 if (temp3)
18671 delete arg3;
18672 }
18673 return resultobj;
18674 fail:
18675 {
18676 if (temp3)
18677 delete arg3;
18678 }
18679 return NULL;
18680 }
18681
18682
18683 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18684 PyObject *resultobj = 0;
18685 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18686 void *argp1 = 0 ;
18687 int res1 = 0 ;
18688 PyObject *swig_obj[1] ;
18689
18690 if (!args) SWIG_fail;
18691 swig_obj[0] = args;
18692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18693 if (!SWIG_IsOK(res1)) {
18694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18695 }
18696 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18697 {
18698 PyThreadState* __tstate = wxPyBeginAllowThreads();
18699 (arg1)->ClearData();
18700 wxPyEndAllowThreads(__tstate);
18701 if (PyErr_Occurred()) SWIG_fail;
18702 }
18703 resultobj = SWIG_Py_Void();
18704 return resultobj;
18705 fail:
18706 return NULL;
18707 }
18708
18709
18710 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18711 PyObject *resultobj = 0;
18712 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18713 wxString *arg2 = 0 ;
18714 wxFileType *result = 0 ;
18715 void *argp1 = 0 ;
18716 int res1 = 0 ;
18717 bool temp2 = false ;
18718 PyObject * obj0 = 0 ;
18719 PyObject * obj1 = 0 ;
18720 char * kwnames[] = {
18721 (char *) "self",(char *) "ext", NULL
18722 };
18723
18724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18726 if (!SWIG_IsOK(res1)) {
18727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18728 }
18729 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18730 {
18731 arg2 = wxString_in_helper(obj1);
18732 if (arg2 == NULL) SWIG_fail;
18733 temp2 = true;
18734 }
18735 {
18736 PyThreadState* __tstate = wxPyBeginAllowThreads();
18737 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18738 wxPyEndAllowThreads(__tstate);
18739 if (PyErr_Occurred()) SWIG_fail;
18740 }
18741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18742 {
18743 if (temp2)
18744 delete arg2;
18745 }
18746 return resultobj;
18747 fail:
18748 {
18749 if (temp2)
18750 delete arg2;
18751 }
18752 return NULL;
18753 }
18754
18755
18756 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18757 PyObject *resultobj = 0;
18758 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18759 wxString *arg2 = 0 ;
18760 wxFileType *result = 0 ;
18761 void *argp1 = 0 ;
18762 int res1 = 0 ;
18763 bool temp2 = false ;
18764 PyObject * obj0 = 0 ;
18765 PyObject * obj1 = 0 ;
18766 char * kwnames[] = {
18767 (char *) "self",(char *) "mimeType", NULL
18768 };
18769
18770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18772 if (!SWIG_IsOK(res1)) {
18773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18774 }
18775 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18776 {
18777 arg2 = wxString_in_helper(obj1);
18778 if (arg2 == NULL) SWIG_fail;
18779 temp2 = true;
18780 }
18781 {
18782 PyThreadState* __tstate = wxPyBeginAllowThreads();
18783 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
18784 wxPyEndAllowThreads(__tstate);
18785 if (PyErr_Occurred()) SWIG_fail;
18786 }
18787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18788 {
18789 if (temp2)
18790 delete arg2;
18791 }
18792 return resultobj;
18793 fail:
18794 {
18795 if (temp2)
18796 delete arg2;
18797 }
18798 return NULL;
18799 }
18800
18801
18802 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18803 PyObject *resultobj = 0;
18804 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18805 wxString *arg2 = 0 ;
18806 bool arg3 = (bool) false ;
18807 bool result;
18808 void *argp1 = 0 ;
18809 int res1 = 0 ;
18810 bool temp2 = false ;
18811 bool val3 ;
18812 int ecode3 = 0 ;
18813 PyObject * obj0 = 0 ;
18814 PyObject * obj1 = 0 ;
18815 PyObject * obj2 = 0 ;
18816 char * kwnames[] = {
18817 (char *) "self",(char *) "filename",(char *) "fallback", NULL
18818 };
18819
18820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18822 if (!SWIG_IsOK(res1)) {
18823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18824 }
18825 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18826 {
18827 arg2 = wxString_in_helper(obj1);
18828 if (arg2 == NULL) SWIG_fail;
18829 temp2 = true;
18830 }
18831 if (obj2) {
18832 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18833 if (!SWIG_IsOK(ecode3)) {
18834 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
18835 }
18836 arg3 = static_cast< bool >(val3);
18837 }
18838 {
18839 PyThreadState* __tstate = wxPyBeginAllowThreads();
18840 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
18841 wxPyEndAllowThreads(__tstate);
18842 if (PyErr_Occurred()) SWIG_fail;
18843 }
18844 {
18845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18846 }
18847 {
18848 if (temp2)
18849 delete arg2;
18850 }
18851 return resultobj;
18852 fail:
18853 {
18854 if (temp2)
18855 delete arg2;
18856 }
18857 return NULL;
18858 }
18859
18860
18861 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18862 PyObject *resultobj = 0;
18863 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18864 wxString *arg2 = 0 ;
18865 bool result;
18866 void *argp1 = 0 ;
18867 int res1 = 0 ;
18868 bool temp2 = false ;
18869 PyObject * obj0 = 0 ;
18870 PyObject * obj1 = 0 ;
18871 char * kwnames[] = {
18872 (char *) "self",(char *) "filename", NULL
18873 };
18874
18875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
18876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18877 if (!SWIG_IsOK(res1)) {
18878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18879 }
18880 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18881 {
18882 arg2 = wxString_in_helper(obj1);
18883 if (arg2 == NULL) SWIG_fail;
18884 temp2 = true;
18885 }
18886 {
18887 PyThreadState* __tstate = wxPyBeginAllowThreads();
18888 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
18889 wxPyEndAllowThreads(__tstate);
18890 if (PyErr_Occurred()) SWIG_fail;
18891 }
18892 {
18893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18894 }
18895 {
18896 if (temp2)
18897 delete arg2;
18898 }
18899 return resultobj;
18900 fail:
18901 {
18902 if (temp2)
18903 delete arg2;
18904 }
18905 return NULL;
18906 }
18907
18908
18909 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18910 PyObject *resultobj = 0;
18911 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18912 PyObject *result = 0 ;
18913 void *argp1 = 0 ;
18914 int res1 = 0 ;
18915 PyObject *swig_obj[1] ;
18916
18917 if (!args) SWIG_fail;
18918 swig_obj[0] = args;
18919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18920 if (!SWIG_IsOK(res1)) {
18921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18922 }
18923 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18924 {
18925 PyThreadState* __tstate = wxPyBeginAllowThreads();
18926 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
18927 wxPyEndAllowThreads(__tstate);
18928 if (PyErr_Occurred()) SWIG_fail;
18929 }
18930 resultobj = result;
18931 return resultobj;
18932 fail:
18933 return NULL;
18934 }
18935
18936
18937 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18938 PyObject *resultobj = 0;
18939 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18940 wxFileTypeInfo *arg2 = 0 ;
18941 void *argp1 = 0 ;
18942 int res1 = 0 ;
18943 void *argp2 = 0 ;
18944 int res2 = 0 ;
18945 PyObject * obj0 = 0 ;
18946 PyObject * obj1 = 0 ;
18947 char * kwnames[] = {
18948 (char *) "self",(char *) "ft", NULL
18949 };
18950
18951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
18952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18953 if (!SWIG_IsOK(res1)) {
18954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18955 }
18956 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18957 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18958 if (!SWIG_IsOK(res2)) {
18959 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18960 }
18961 if (!argp2) {
18962 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18963 }
18964 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18965 {
18966 PyThreadState* __tstate = wxPyBeginAllowThreads();
18967 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
18968 wxPyEndAllowThreads(__tstate);
18969 if (PyErr_Occurred()) SWIG_fail;
18970 }
18971 resultobj = SWIG_Py_Void();
18972 return resultobj;
18973 fail:
18974 return NULL;
18975 }
18976
18977
18978 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18979 PyObject *resultobj = 0;
18980 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18981 wxFileTypeInfo *arg2 = 0 ;
18982 wxFileType *result = 0 ;
18983 void *argp1 = 0 ;
18984 int res1 = 0 ;
18985 void *argp2 = 0 ;
18986 int res2 = 0 ;
18987 PyObject * obj0 = 0 ;
18988 PyObject * obj1 = 0 ;
18989 char * kwnames[] = {
18990 (char *) "self",(char *) "ftInfo", NULL
18991 };
18992
18993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
18994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18995 if (!SWIG_IsOK(res1)) {
18996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18997 }
18998 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18999 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19000 if (!SWIG_IsOK(res2)) {
19001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19002 }
19003 if (!argp2) {
19004 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19005 }
19006 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19007 {
19008 PyThreadState* __tstate = wxPyBeginAllowThreads();
19009 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19010 wxPyEndAllowThreads(__tstate);
19011 if (PyErr_Occurred()) SWIG_fail;
19012 }
19013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19014 return resultobj;
19015 fail:
19016 return NULL;
19017 }
19018
19019
19020 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19021 PyObject *resultobj = 0;
19022 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19023 wxFileType *arg2 = (wxFileType *) 0 ;
19024 bool result;
19025 void *argp1 = 0 ;
19026 int res1 = 0 ;
19027 void *argp2 = 0 ;
19028 int res2 = 0 ;
19029 PyObject * obj0 = 0 ;
19030 PyObject * obj1 = 0 ;
19031 char * kwnames[] = {
19032 (char *) "self",(char *) "ft", NULL
19033 };
19034
19035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19037 if (!SWIG_IsOK(res1)) {
19038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19039 }
19040 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19041 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19042 if (!SWIG_IsOK(res2)) {
19043 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19044 }
19045 arg2 = reinterpret_cast< wxFileType * >(argp2);
19046 {
19047 PyThreadState* __tstate = wxPyBeginAllowThreads();
19048 result = (bool)(arg1)->Unassociate(arg2);
19049 wxPyEndAllowThreads(__tstate);
19050 if (PyErr_Occurred()) SWIG_fail;
19051 }
19052 {
19053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19054 }
19055 return resultobj;
19056 fail:
19057 return NULL;
19058 }
19059
19060
19061 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19062 PyObject *resultobj = 0;
19063 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19064 void *argp1 = 0 ;
19065 int res1 = 0 ;
19066 PyObject *swig_obj[1] ;
19067
19068 if (!args) SWIG_fail;
19069 swig_obj[0] = args;
19070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19071 if (!SWIG_IsOK(res1)) {
19072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19073 }
19074 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19075 {
19076 PyThreadState* __tstate = wxPyBeginAllowThreads();
19077 delete arg1;
19078
19079 wxPyEndAllowThreads(__tstate);
19080 if (PyErr_Occurred()) SWIG_fail;
19081 }
19082 resultobj = SWIG_Py_Void();
19083 return resultobj;
19084 fail:
19085 return NULL;
19086 }
19087
19088
19089 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19090 PyObject *obj;
19091 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19092 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19093 return SWIG_Py_Void();
19094 }
19095
19096 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19097 return SWIG_Python_InitShadowInstance(args);
19098 }
19099
19100 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19101 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19102 return 1;
19103 }
19104
19105
19106 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19107 PyObject *pyobj = 0;
19108
19109 {
19110 #if wxUSE_UNICODE
19111 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19112 #else
19113 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19114 #endif
19115 }
19116 return pyobj;
19117 }
19118
19119
19120 SWIGINTERN int ART_MENU_set(PyObject *) {
19121 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19122 return 1;
19123 }
19124
19125
19126 SWIGINTERN PyObject *ART_MENU_get(void) {
19127 PyObject *pyobj = 0;
19128
19129 {
19130 #if wxUSE_UNICODE
19131 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19132 #else
19133 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19134 #endif
19135 }
19136 return pyobj;
19137 }
19138
19139
19140 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19141 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19142 return 1;
19143 }
19144
19145
19146 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19147 PyObject *pyobj = 0;
19148
19149 {
19150 #if wxUSE_UNICODE
19151 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19152 #else
19153 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19154 #endif
19155 }
19156 return pyobj;
19157 }
19158
19159
19160 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19161 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19162 return 1;
19163 }
19164
19165
19166 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19167 PyObject *pyobj = 0;
19168
19169 {
19170 #if wxUSE_UNICODE
19171 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19172 #else
19173 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19174 #endif
19175 }
19176 return pyobj;
19177 }
19178
19179
19180 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19181 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19182 return 1;
19183 }
19184
19185
19186 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19187 PyObject *pyobj = 0;
19188
19189 {
19190 #if wxUSE_UNICODE
19191 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19192 #else
19193 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19194 #endif
19195 }
19196 return pyobj;
19197 }
19198
19199
19200 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19201 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19202 return 1;
19203 }
19204
19205
19206 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19207 PyObject *pyobj = 0;
19208
19209 {
19210 #if wxUSE_UNICODE
19211 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19212 #else
19213 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19214 #endif
19215 }
19216 return pyobj;
19217 }
19218
19219
19220 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19221 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19222 return 1;
19223 }
19224
19225
19226 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19227 PyObject *pyobj = 0;
19228
19229 {
19230 #if wxUSE_UNICODE
19231 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19232 #else
19233 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19234 #endif
19235 }
19236 return pyobj;
19237 }
19238
19239
19240 SWIGINTERN int ART_OTHER_set(PyObject *) {
19241 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19242 return 1;
19243 }
19244
19245
19246 SWIGINTERN PyObject *ART_OTHER_get(void) {
19247 PyObject *pyobj = 0;
19248
19249 {
19250 #if wxUSE_UNICODE
19251 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19252 #else
19253 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19254 #endif
19255 }
19256 return pyobj;
19257 }
19258
19259
19260 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19261 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19262 return 1;
19263 }
19264
19265
19266 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19267 PyObject *pyobj = 0;
19268
19269 {
19270 #if wxUSE_UNICODE
19271 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19272 #else
19273 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19274 #endif
19275 }
19276 return pyobj;
19277 }
19278
19279
19280 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19281 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19282 return 1;
19283 }
19284
19285
19286 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19287 PyObject *pyobj = 0;
19288
19289 {
19290 #if wxUSE_UNICODE
19291 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19292 #else
19293 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19294 #endif
19295 }
19296 return pyobj;
19297 }
19298
19299
19300 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19301 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19302 return 1;
19303 }
19304
19305
19306 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19307 PyObject *pyobj = 0;
19308
19309 {
19310 #if wxUSE_UNICODE
19311 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19312 #else
19313 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19314 #endif
19315 }
19316 return pyobj;
19317 }
19318
19319
19320 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19321 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19322 return 1;
19323 }
19324
19325
19326 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19327 PyObject *pyobj = 0;
19328
19329 {
19330 #if wxUSE_UNICODE
19331 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19332 #else
19333 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19334 #endif
19335 }
19336 return pyobj;
19337 }
19338
19339
19340 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19341 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19342 return 1;
19343 }
19344
19345
19346 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19347 PyObject *pyobj = 0;
19348
19349 {
19350 #if wxUSE_UNICODE
19351 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19352 #else
19353 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19354 #endif
19355 }
19356 return pyobj;
19357 }
19358
19359
19360 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19361 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19362 return 1;
19363 }
19364
19365
19366 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19367 PyObject *pyobj = 0;
19368
19369 {
19370 #if wxUSE_UNICODE
19371 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19372 #else
19373 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19374 #endif
19375 }
19376 return pyobj;
19377 }
19378
19379
19380 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19381 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19382 return 1;
19383 }
19384
19385
19386 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19387 PyObject *pyobj = 0;
19388
19389 {
19390 #if wxUSE_UNICODE
19391 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19392 #else
19393 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19394 #endif
19395 }
19396 return pyobj;
19397 }
19398
19399
19400 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19401 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19402 return 1;
19403 }
19404
19405
19406 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19407 PyObject *pyobj = 0;
19408
19409 {
19410 #if wxUSE_UNICODE
19411 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19412 #else
19413 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19414 #endif
19415 }
19416 return pyobj;
19417 }
19418
19419
19420 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19421 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19422 return 1;
19423 }
19424
19425
19426 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19427 PyObject *pyobj = 0;
19428
19429 {
19430 #if wxUSE_UNICODE
19431 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19432 #else
19433 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19434 #endif
19435 }
19436 return pyobj;
19437 }
19438
19439
19440 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19441 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19442 return 1;
19443 }
19444
19445
19446 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19447 PyObject *pyobj = 0;
19448
19449 {
19450 #if wxUSE_UNICODE
19451 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19452 #else
19453 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19454 #endif
19455 }
19456 return pyobj;
19457 }
19458
19459
19460 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19461 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19462 return 1;
19463 }
19464
19465
19466 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19467 PyObject *pyobj = 0;
19468
19469 {
19470 #if wxUSE_UNICODE
19471 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19472 #else
19473 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19474 #endif
19475 }
19476 return pyobj;
19477 }
19478
19479
19480 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19481 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19482 return 1;
19483 }
19484
19485
19486 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19487 PyObject *pyobj = 0;
19488
19489 {
19490 #if wxUSE_UNICODE
19491 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19492 #else
19493 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19494 #endif
19495 }
19496 return pyobj;
19497 }
19498
19499
19500 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19501 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19502 return 1;
19503 }
19504
19505
19506 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19507 PyObject *pyobj = 0;
19508
19509 {
19510 #if wxUSE_UNICODE
19511 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19512 #else
19513 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19514 #endif
19515 }
19516 return pyobj;
19517 }
19518
19519
19520 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19521 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19522 return 1;
19523 }
19524
19525
19526 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19527 PyObject *pyobj = 0;
19528
19529 {
19530 #if wxUSE_UNICODE
19531 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19532 #else
19533 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19534 #endif
19535 }
19536 return pyobj;
19537 }
19538
19539
19540 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19541 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19542 return 1;
19543 }
19544
19545
19546 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19547 PyObject *pyobj = 0;
19548
19549 {
19550 #if wxUSE_UNICODE
19551 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19552 #else
19553 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19554 #endif
19555 }
19556 return pyobj;
19557 }
19558
19559
19560 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19561 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19562 return 1;
19563 }
19564
19565
19566 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19567 PyObject *pyobj = 0;
19568
19569 {
19570 #if wxUSE_UNICODE
19571 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19572 #else
19573 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19574 #endif
19575 }
19576 return pyobj;
19577 }
19578
19579
19580 SWIGINTERN int ART_PRINT_set(PyObject *) {
19581 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19582 return 1;
19583 }
19584
19585
19586 SWIGINTERN PyObject *ART_PRINT_get(void) {
19587 PyObject *pyobj = 0;
19588
19589 {
19590 #if wxUSE_UNICODE
19591 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19592 #else
19593 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19594 #endif
19595 }
19596 return pyobj;
19597 }
19598
19599
19600 SWIGINTERN int ART_HELP_set(PyObject *) {
19601 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19602 return 1;
19603 }
19604
19605
19606 SWIGINTERN PyObject *ART_HELP_get(void) {
19607 PyObject *pyobj = 0;
19608
19609 {
19610 #if wxUSE_UNICODE
19611 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19612 #else
19613 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19614 #endif
19615 }
19616 return pyobj;
19617 }
19618
19619
19620 SWIGINTERN int ART_TIP_set(PyObject *) {
19621 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19622 return 1;
19623 }
19624
19625
19626 SWIGINTERN PyObject *ART_TIP_get(void) {
19627 PyObject *pyobj = 0;
19628
19629 {
19630 #if wxUSE_UNICODE
19631 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19632 #else
19633 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19634 #endif
19635 }
19636 return pyobj;
19637 }
19638
19639
19640 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19641 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19642 return 1;
19643 }
19644
19645
19646 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19647 PyObject *pyobj = 0;
19648
19649 {
19650 #if wxUSE_UNICODE
19651 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19652 #else
19653 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19654 #endif
19655 }
19656 return pyobj;
19657 }
19658
19659
19660 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19661 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19662 return 1;
19663 }
19664
19665
19666 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19667 PyObject *pyobj = 0;
19668
19669 {
19670 #if wxUSE_UNICODE
19671 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19672 #else
19673 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19674 #endif
19675 }
19676 return pyobj;
19677 }
19678
19679
19680 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19681 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19682 return 1;
19683 }
19684
19685
19686 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19687 PyObject *pyobj = 0;
19688
19689 {
19690 #if wxUSE_UNICODE
19691 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19692 #else
19693 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19694 #endif
19695 }
19696 return pyobj;
19697 }
19698
19699
19700 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19701 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19702 return 1;
19703 }
19704
19705
19706 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19707 PyObject *pyobj = 0;
19708
19709 {
19710 #if wxUSE_UNICODE
19711 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19712 #else
19713 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19714 #endif
19715 }
19716 return pyobj;
19717 }
19718
19719
19720 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19721 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19722 return 1;
19723 }
19724
19725
19726 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19727 PyObject *pyobj = 0;
19728
19729 {
19730 #if wxUSE_UNICODE
19731 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19732 #else
19733 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19734 #endif
19735 }
19736 return pyobj;
19737 }
19738
19739
19740 SWIGINTERN int ART_CDROM_set(PyObject *) {
19741 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19742 return 1;
19743 }
19744
19745
19746 SWIGINTERN PyObject *ART_CDROM_get(void) {
19747 PyObject *pyobj = 0;
19748
19749 {
19750 #if wxUSE_UNICODE
19751 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19752 #else
19753 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19754 #endif
19755 }
19756 return pyobj;
19757 }
19758
19759
19760 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19761 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19762 return 1;
19763 }
19764
19765
19766 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19767 PyObject *pyobj = 0;
19768
19769 {
19770 #if wxUSE_UNICODE
19771 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19772 #else
19773 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19774 #endif
19775 }
19776 return pyobj;
19777 }
19778
19779
19780 SWIGINTERN int ART_FOLDER_set(PyObject *) {
19781 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
19782 return 1;
19783 }
19784
19785
19786 SWIGINTERN PyObject *ART_FOLDER_get(void) {
19787 PyObject *pyobj = 0;
19788
19789 {
19790 #if wxUSE_UNICODE
19791 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19792 #else
19793 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19794 #endif
19795 }
19796 return pyobj;
19797 }
19798
19799
19800 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
19801 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
19802 return 1;
19803 }
19804
19805
19806 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
19807 PyObject *pyobj = 0;
19808
19809 {
19810 #if wxUSE_UNICODE
19811 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19812 #else
19813 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19814 #endif
19815 }
19816 return pyobj;
19817 }
19818
19819
19820 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
19821 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
19822 return 1;
19823 }
19824
19825
19826 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
19827 PyObject *pyobj = 0;
19828
19829 {
19830 #if wxUSE_UNICODE
19831 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19832 #else
19833 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19834 #endif
19835 }
19836 return pyobj;
19837 }
19838
19839
19840 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
19841 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
19842 return 1;
19843 }
19844
19845
19846 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
19847 PyObject *pyobj = 0;
19848
19849 {
19850 #if wxUSE_UNICODE
19851 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19852 #else
19853 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19854 #endif
19855 }
19856 return pyobj;
19857 }
19858
19859
19860 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
19861 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
19862 return 1;
19863 }
19864
19865
19866 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
19867 PyObject *pyobj = 0;
19868
19869 {
19870 #if wxUSE_UNICODE
19871 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
19872 #else
19873 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
19874 #endif
19875 }
19876 return pyobj;
19877 }
19878
19879
19880 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
19881 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
19882 return 1;
19883 }
19884
19885
19886 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
19887 PyObject *pyobj = 0;
19888
19889 {
19890 #if wxUSE_UNICODE
19891 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
19892 #else
19893 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
19894 #endif
19895 }
19896 return pyobj;
19897 }
19898
19899
19900 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
19901 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
19902 return 1;
19903 }
19904
19905
19906 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
19907 PyObject *pyobj = 0;
19908
19909 {
19910 #if wxUSE_UNICODE
19911 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19912 #else
19913 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19914 #endif
19915 }
19916 return pyobj;
19917 }
19918
19919
19920 SWIGINTERN int ART_ERROR_set(PyObject *) {
19921 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
19922 return 1;
19923 }
19924
19925
19926 SWIGINTERN PyObject *ART_ERROR_get(void) {
19927 PyObject *pyobj = 0;
19928
19929 {
19930 #if wxUSE_UNICODE
19931 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19932 #else
19933 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19934 #endif
19935 }
19936 return pyobj;
19937 }
19938
19939
19940 SWIGINTERN int ART_QUESTION_set(PyObject *) {
19941 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
19942 return 1;
19943 }
19944
19945
19946 SWIGINTERN PyObject *ART_QUESTION_get(void) {
19947 PyObject *pyobj = 0;
19948
19949 {
19950 #if wxUSE_UNICODE
19951 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19952 #else
19953 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19954 #endif
19955 }
19956 return pyobj;
19957 }
19958
19959
19960 SWIGINTERN int ART_WARNING_set(PyObject *) {
19961 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
19962 return 1;
19963 }
19964
19965
19966 SWIGINTERN PyObject *ART_WARNING_get(void) {
19967 PyObject *pyobj = 0;
19968
19969 {
19970 #if wxUSE_UNICODE
19971 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19972 #else
19973 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19974 #endif
19975 }
19976 return pyobj;
19977 }
19978
19979
19980 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
19981 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
19982 return 1;
19983 }
19984
19985
19986 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
19987 PyObject *pyobj = 0;
19988
19989 {
19990 #if wxUSE_UNICODE
19991 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19992 #else
19993 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19994 #endif
19995 }
19996 return pyobj;
19997 }
19998
19999
20000 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20001 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20002 return 1;
20003 }
20004
20005
20006 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20007 PyObject *pyobj = 0;
20008
20009 {
20010 #if wxUSE_UNICODE
20011 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20012 #else
20013 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20014 #endif
20015 }
20016 return pyobj;
20017 }
20018
20019
20020 SWIGINTERN int ART_COPY_set(PyObject *) {
20021 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20022 return 1;
20023 }
20024
20025
20026 SWIGINTERN PyObject *ART_COPY_get(void) {
20027 PyObject *pyobj = 0;
20028
20029 {
20030 #if wxUSE_UNICODE
20031 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20032 #else
20033 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20034 #endif
20035 }
20036 return pyobj;
20037 }
20038
20039
20040 SWIGINTERN int ART_CUT_set(PyObject *) {
20041 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20042 return 1;
20043 }
20044
20045
20046 SWIGINTERN PyObject *ART_CUT_get(void) {
20047 PyObject *pyobj = 0;
20048
20049 {
20050 #if wxUSE_UNICODE
20051 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20052 #else
20053 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20054 #endif
20055 }
20056 return pyobj;
20057 }
20058
20059
20060 SWIGINTERN int ART_PASTE_set(PyObject *) {
20061 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20062 return 1;
20063 }
20064
20065
20066 SWIGINTERN PyObject *ART_PASTE_get(void) {
20067 PyObject *pyobj = 0;
20068
20069 {
20070 #if wxUSE_UNICODE
20071 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20072 #else
20073 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20074 #endif
20075 }
20076 return pyobj;
20077 }
20078
20079
20080 SWIGINTERN int ART_DELETE_set(PyObject *) {
20081 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20082 return 1;
20083 }
20084
20085
20086 SWIGINTERN PyObject *ART_DELETE_get(void) {
20087 PyObject *pyobj = 0;
20088
20089 {
20090 #if wxUSE_UNICODE
20091 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20092 #else
20093 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20094 #endif
20095 }
20096 return pyobj;
20097 }
20098
20099
20100 SWIGINTERN int ART_NEW_set(PyObject *) {
20101 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20102 return 1;
20103 }
20104
20105
20106 SWIGINTERN PyObject *ART_NEW_get(void) {
20107 PyObject *pyobj = 0;
20108
20109 {
20110 #if wxUSE_UNICODE
20111 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20112 #else
20113 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20114 #endif
20115 }
20116 return pyobj;
20117 }
20118
20119
20120 SWIGINTERN int ART_UNDO_set(PyObject *) {
20121 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20122 return 1;
20123 }
20124
20125
20126 SWIGINTERN PyObject *ART_UNDO_get(void) {
20127 PyObject *pyobj = 0;
20128
20129 {
20130 #if wxUSE_UNICODE
20131 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20132 #else
20133 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20134 #endif
20135 }
20136 return pyobj;
20137 }
20138
20139
20140 SWIGINTERN int ART_REDO_set(PyObject *) {
20141 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20142 return 1;
20143 }
20144
20145
20146 SWIGINTERN PyObject *ART_REDO_get(void) {
20147 PyObject *pyobj = 0;
20148
20149 {
20150 #if wxUSE_UNICODE
20151 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20152 #else
20153 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20154 #endif
20155 }
20156 return pyobj;
20157 }
20158
20159
20160 SWIGINTERN int ART_QUIT_set(PyObject *) {
20161 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20162 return 1;
20163 }
20164
20165
20166 SWIGINTERN PyObject *ART_QUIT_get(void) {
20167 PyObject *pyobj = 0;
20168
20169 {
20170 #if wxUSE_UNICODE
20171 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20172 #else
20173 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20174 #endif
20175 }
20176 return pyobj;
20177 }
20178
20179
20180 SWIGINTERN int ART_FIND_set(PyObject *) {
20181 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20182 return 1;
20183 }
20184
20185
20186 SWIGINTERN PyObject *ART_FIND_get(void) {
20187 PyObject *pyobj = 0;
20188
20189 {
20190 #if wxUSE_UNICODE
20191 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20192 #else
20193 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20194 #endif
20195 }
20196 return pyobj;
20197 }
20198
20199
20200 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20201 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20202 return 1;
20203 }
20204
20205
20206 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20207 PyObject *pyobj = 0;
20208
20209 {
20210 #if wxUSE_UNICODE
20211 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20212 #else
20213 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20214 #endif
20215 }
20216 return pyobj;
20217 }
20218
20219
20220 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20221 PyObject *resultobj = 0;
20222 wxPyArtProvider *result = 0 ;
20223
20224 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20225 {
20226 if (!wxPyCheckForApp()) SWIG_fail;
20227 PyThreadState* __tstate = wxPyBeginAllowThreads();
20228 result = (wxPyArtProvider *)new wxPyArtProvider();
20229 wxPyEndAllowThreads(__tstate);
20230 if (PyErr_Occurred()) SWIG_fail;
20231 }
20232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20233 return resultobj;
20234 fail:
20235 return NULL;
20236 }
20237
20238
20239 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20240 PyObject *resultobj = 0;
20241 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20242 void *argp1 = 0 ;
20243 int res1 = 0 ;
20244 PyObject *swig_obj[1] ;
20245
20246 if (!args) SWIG_fail;
20247 swig_obj[0] = args;
20248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20249 if (!SWIG_IsOK(res1)) {
20250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20251 }
20252 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20253 {
20254 PyThreadState* __tstate = wxPyBeginAllowThreads();
20255 delete arg1;
20256
20257 wxPyEndAllowThreads(__tstate);
20258 if (PyErr_Occurred()) SWIG_fail;
20259 }
20260 resultobj = SWIG_Py_Void();
20261 return resultobj;
20262 fail:
20263 return NULL;
20264 }
20265
20266
20267 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20268 PyObject *resultobj = 0;
20269 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20270 PyObject *arg2 = (PyObject *) 0 ;
20271 PyObject *arg3 = (PyObject *) 0 ;
20272 void *argp1 = 0 ;
20273 int res1 = 0 ;
20274 PyObject * obj0 = 0 ;
20275 PyObject * obj1 = 0 ;
20276 PyObject * obj2 = 0 ;
20277 char * kwnames[] = {
20278 (char *) "self",(char *) "self",(char *) "_class", NULL
20279 };
20280
20281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20283 if (!SWIG_IsOK(res1)) {
20284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20285 }
20286 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20287 arg2 = obj1;
20288 arg3 = obj2;
20289 {
20290 PyThreadState* __tstate = wxPyBeginAllowThreads();
20291 (arg1)->_setCallbackInfo(arg2,arg3);
20292 wxPyEndAllowThreads(__tstate);
20293 if (PyErr_Occurred()) SWIG_fail;
20294 }
20295 resultobj = SWIG_Py_Void();
20296 return resultobj;
20297 fail:
20298 return NULL;
20299 }
20300
20301
20302 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20303 PyObject *resultobj = 0;
20304 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20305 int res1 = 0 ;
20306 PyObject * obj0 = 0 ;
20307 char * kwnames[] = {
20308 (char *) "provider", NULL
20309 };
20310
20311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
20312 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20313 if (!SWIG_IsOK(res1)) {
20314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20315 }
20316 {
20317 PyThreadState* __tstate = wxPyBeginAllowThreads();
20318 wxPyArtProvider::PushProvider(arg1);
20319 wxPyEndAllowThreads(__tstate);
20320 if (PyErr_Occurred()) SWIG_fail;
20321 }
20322 resultobj = SWIG_Py_Void();
20323 return resultobj;
20324 fail:
20325 return NULL;
20326 }
20327
20328
20329 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20330 PyObject *resultobj = 0;
20331 bool result;
20332
20333 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
20334 {
20335 PyThreadState* __tstate = wxPyBeginAllowThreads();
20336 result = (bool)wxPyArtProvider::PopProvider();
20337 wxPyEndAllowThreads(__tstate);
20338 if (PyErr_Occurred()) SWIG_fail;
20339 }
20340 {
20341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20342 }
20343 return resultobj;
20344 fail:
20345 return NULL;
20346 }
20347
20348
20349 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20350 PyObject *resultobj = 0;
20351 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20352 bool result;
20353 void *argp1 = 0 ;
20354 int res1 = 0 ;
20355 PyObject * obj0 = 0 ;
20356 char * kwnames[] = {
20357 (char *) "provider", NULL
20358 };
20359
20360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
20361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20362 if (!SWIG_IsOK(res1)) {
20363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20364 }
20365 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20366 {
20367 PyThreadState* __tstate = wxPyBeginAllowThreads();
20368 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
20369 wxPyEndAllowThreads(__tstate);
20370 if (PyErr_Occurred()) SWIG_fail;
20371 }
20372 {
20373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20374 }
20375 return resultobj;
20376 fail:
20377 return NULL;
20378 }
20379
20380
20381 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20382 PyObject *resultobj = 0;
20383 wxString *arg1 = 0 ;
20384 wxString const &arg2_defvalue = wxPyART_OTHER ;
20385 wxString *arg2 = (wxString *) &arg2_defvalue ;
20386 wxSize const &arg3_defvalue = wxDefaultSize ;
20387 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20388 wxBitmap result;
20389 bool temp1 = false ;
20390 bool temp2 = false ;
20391 wxSize temp3 ;
20392 PyObject * obj0 = 0 ;
20393 PyObject * obj1 = 0 ;
20394 PyObject * obj2 = 0 ;
20395 char * kwnames[] = {
20396 (char *) "id",(char *) "client",(char *) "size", NULL
20397 };
20398
20399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20400 {
20401 arg1 = wxString_in_helper(obj0);
20402 if (arg1 == NULL) SWIG_fail;
20403 temp1 = true;
20404 }
20405 if (obj1) {
20406 {
20407 arg2 = wxString_in_helper(obj1);
20408 if (arg2 == NULL) SWIG_fail;
20409 temp2 = true;
20410 }
20411 }
20412 if (obj2) {
20413 {
20414 arg3 = &temp3;
20415 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20416 }
20417 }
20418 {
20419 if (!wxPyCheckForApp()) SWIG_fail;
20420 PyThreadState* __tstate = wxPyBeginAllowThreads();
20421 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20422 wxPyEndAllowThreads(__tstate);
20423 if (PyErr_Occurred()) SWIG_fail;
20424 }
20425 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20426 {
20427 if (temp1)
20428 delete arg1;
20429 }
20430 {
20431 if (temp2)
20432 delete arg2;
20433 }
20434 return resultobj;
20435 fail:
20436 {
20437 if (temp1)
20438 delete arg1;
20439 }
20440 {
20441 if (temp2)
20442 delete arg2;
20443 }
20444 return NULL;
20445 }
20446
20447
20448 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20449 PyObject *resultobj = 0;
20450 wxString *arg1 = 0 ;
20451 wxString const &arg2_defvalue = wxPyART_OTHER ;
20452 wxString *arg2 = (wxString *) &arg2_defvalue ;
20453 wxSize const &arg3_defvalue = wxDefaultSize ;
20454 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20455 wxIcon result;
20456 bool temp1 = false ;
20457 bool temp2 = false ;
20458 wxSize temp3 ;
20459 PyObject * obj0 = 0 ;
20460 PyObject * obj1 = 0 ;
20461 PyObject * obj2 = 0 ;
20462 char * kwnames[] = {
20463 (char *) "id",(char *) "client",(char *) "size", NULL
20464 };
20465
20466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20467 {
20468 arg1 = wxString_in_helper(obj0);
20469 if (arg1 == NULL) SWIG_fail;
20470 temp1 = true;
20471 }
20472 if (obj1) {
20473 {
20474 arg2 = wxString_in_helper(obj1);
20475 if (arg2 == NULL) SWIG_fail;
20476 temp2 = true;
20477 }
20478 }
20479 if (obj2) {
20480 {
20481 arg3 = &temp3;
20482 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20483 }
20484 }
20485 {
20486 if (!wxPyCheckForApp()) SWIG_fail;
20487 PyThreadState* __tstate = wxPyBeginAllowThreads();
20488 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20489 wxPyEndAllowThreads(__tstate);
20490 if (PyErr_Occurred()) SWIG_fail;
20491 }
20492 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20493 {
20494 if (temp1)
20495 delete arg1;
20496 }
20497 {
20498 if (temp2)
20499 delete arg2;
20500 }
20501 return resultobj;
20502 fail:
20503 {
20504 if (temp1)
20505 delete arg1;
20506 }
20507 {
20508 if (temp2)
20509 delete arg2;
20510 }
20511 return NULL;
20512 }
20513
20514
20515 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20516 PyObject *resultobj = 0;
20517 wxString *arg1 = 0 ;
20518 bool arg2 = (bool) false ;
20519 wxSize result;
20520 bool temp1 = false ;
20521 bool val2 ;
20522 int ecode2 = 0 ;
20523 PyObject * obj0 = 0 ;
20524 PyObject * obj1 = 0 ;
20525 char * kwnames[] = {
20526 (char *) "client",(char *) "platform_dependent", NULL
20527 };
20528
20529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20530 {
20531 arg1 = wxString_in_helper(obj0);
20532 if (arg1 == NULL) SWIG_fail;
20533 temp1 = true;
20534 }
20535 if (obj1) {
20536 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20537 if (!SWIG_IsOK(ecode2)) {
20538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20539 }
20540 arg2 = static_cast< bool >(val2);
20541 }
20542 {
20543 PyThreadState* __tstate = wxPyBeginAllowThreads();
20544 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20545 wxPyEndAllowThreads(__tstate);
20546 if (PyErr_Occurred()) SWIG_fail;
20547 }
20548 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20549 {
20550 if (temp1)
20551 delete arg1;
20552 }
20553 return resultobj;
20554 fail:
20555 {
20556 if (temp1)
20557 delete arg1;
20558 }
20559 return NULL;
20560 }
20561
20562
20563 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20564 PyObject *resultobj = 0;
20565 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20566 void *argp1 = 0 ;
20567 int res1 = 0 ;
20568 PyObject *swig_obj[1] ;
20569
20570 if (!args) SWIG_fail;
20571 swig_obj[0] = args;
20572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20573 if (!SWIG_IsOK(res1)) {
20574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20575 }
20576 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20577 {
20578 PyThreadState* __tstate = wxPyBeginAllowThreads();
20579 wxPyArtProvider_Destroy(arg1);
20580 wxPyEndAllowThreads(__tstate);
20581 if (PyErr_Occurred()) SWIG_fail;
20582 }
20583 resultobj = SWIG_Py_Void();
20584 return resultobj;
20585 fail:
20586 return NULL;
20587 }
20588
20589
20590 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20591 PyObject *obj;
20592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20593 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20594 return SWIG_Py_Void();
20595 }
20596
20597 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20598 return SWIG_Python_InitShadowInstance(args);
20599 }
20600
20601 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20602 PyObject *resultobj = 0;
20603 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20604 void *argp1 = 0 ;
20605 int res1 = 0 ;
20606 PyObject *swig_obj[1] ;
20607
20608 if (!args) SWIG_fail;
20609 swig_obj[0] = args;
20610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20611 if (!SWIG_IsOK(res1)) {
20612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20613 }
20614 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20615 {
20616 PyThreadState* __tstate = wxPyBeginAllowThreads();
20617 delete arg1;
20618
20619 wxPyEndAllowThreads(__tstate);
20620 if (PyErr_Occurred()) SWIG_fail;
20621 }
20622 resultobj = SWIG_Py_Void();
20623 return resultobj;
20624 fail:
20625 return NULL;
20626 }
20627
20628
20629 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20630 PyObject *resultobj = 0;
20631 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20632 wxConfigBase *result = 0 ;
20633 int res1 = 0 ;
20634 PyObject * obj0 = 0 ;
20635 char * kwnames[] = {
20636 (char *) "config", NULL
20637 };
20638
20639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20640 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20641 if (!SWIG_IsOK(res1)) {
20642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20643 }
20644 {
20645 PyThreadState* __tstate = wxPyBeginAllowThreads();
20646 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20647 wxPyEndAllowThreads(__tstate);
20648 if (PyErr_Occurred()) SWIG_fail;
20649 }
20650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20651 return resultobj;
20652 fail:
20653 return NULL;
20654 }
20655
20656
20657 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20658 PyObject *resultobj = 0;
20659 bool arg1 = (bool) true ;
20660 wxConfigBase *result = 0 ;
20661 bool val1 ;
20662 int ecode1 = 0 ;
20663 PyObject * obj0 = 0 ;
20664 char * kwnames[] = {
20665 (char *) "createOnDemand", NULL
20666 };
20667
20668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20669 if (obj0) {
20670 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20671 if (!SWIG_IsOK(ecode1)) {
20672 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20673 }
20674 arg1 = static_cast< bool >(val1);
20675 }
20676 {
20677 PyThreadState* __tstate = wxPyBeginAllowThreads();
20678 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20679 wxPyEndAllowThreads(__tstate);
20680 if (PyErr_Occurred()) SWIG_fail;
20681 }
20682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20683 return resultobj;
20684 fail:
20685 return NULL;
20686 }
20687
20688
20689 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20690 PyObject *resultobj = 0;
20691 wxConfigBase *result = 0 ;
20692
20693 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20694 {
20695 PyThreadState* __tstate = wxPyBeginAllowThreads();
20696 result = (wxConfigBase *)wxConfigBase::Create();
20697 wxPyEndAllowThreads(__tstate);
20698 if (PyErr_Occurred()) SWIG_fail;
20699 }
20700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20701 return resultobj;
20702 fail:
20703 return NULL;
20704 }
20705
20706
20707 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20708 PyObject *resultobj = 0;
20709
20710 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20711 {
20712 PyThreadState* __tstate = wxPyBeginAllowThreads();
20713 wxConfigBase::DontCreateOnDemand();
20714 wxPyEndAllowThreads(__tstate);
20715 if (PyErr_Occurred()) SWIG_fail;
20716 }
20717 resultobj = SWIG_Py_Void();
20718 return resultobj;
20719 fail:
20720 return NULL;
20721 }
20722
20723
20724 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20725 PyObject *resultobj = 0;
20726 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20727 wxString *arg2 = 0 ;
20728 void *argp1 = 0 ;
20729 int res1 = 0 ;
20730 bool temp2 = false ;
20731 PyObject * obj0 = 0 ;
20732 PyObject * obj1 = 0 ;
20733 char * kwnames[] = {
20734 (char *) "self",(char *) "path", NULL
20735 };
20736
20737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20739 if (!SWIG_IsOK(res1)) {
20740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20741 }
20742 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20743 {
20744 arg2 = wxString_in_helper(obj1);
20745 if (arg2 == NULL) SWIG_fail;
20746 temp2 = true;
20747 }
20748 {
20749 PyThreadState* __tstate = wxPyBeginAllowThreads();
20750 (arg1)->SetPath((wxString const &)*arg2);
20751 wxPyEndAllowThreads(__tstate);
20752 if (PyErr_Occurred()) SWIG_fail;
20753 }
20754 resultobj = SWIG_Py_Void();
20755 {
20756 if (temp2)
20757 delete arg2;
20758 }
20759 return resultobj;
20760 fail:
20761 {
20762 if (temp2)
20763 delete arg2;
20764 }
20765 return NULL;
20766 }
20767
20768
20769 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20770 PyObject *resultobj = 0;
20771 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20772 wxString *result = 0 ;
20773 void *argp1 = 0 ;
20774 int res1 = 0 ;
20775 PyObject *swig_obj[1] ;
20776
20777 if (!args) SWIG_fail;
20778 swig_obj[0] = args;
20779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20780 if (!SWIG_IsOK(res1)) {
20781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20782 }
20783 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20784 {
20785 PyThreadState* __tstate = wxPyBeginAllowThreads();
20786 {
20787 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
20788 result = (wxString *) &_result_ref;
20789 }
20790 wxPyEndAllowThreads(__tstate);
20791 if (PyErr_Occurred()) SWIG_fail;
20792 }
20793 {
20794 #if wxUSE_UNICODE
20795 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
20796 #else
20797 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
20798 #endif
20799 }
20800 return resultobj;
20801 fail:
20802 return NULL;
20803 }
20804
20805
20806 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20807 PyObject *resultobj = 0;
20808 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20809 PyObject *result = 0 ;
20810 void *argp1 = 0 ;
20811 int res1 = 0 ;
20812 PyObject *swig_obj[1] ;
20813
20814 if (!args) SWIG_fail;
20815 swig_obj[0] = args;
20816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20817 if (!SWIG_IsOK(res1)) {
20818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20819 }
20820 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20821 {
20822 PyThreadState* __tstate = wxPyBeginAllowThreads();
20823 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
20824 wxPyEndAllowThreads(__tstate);
20825 if (PyErr_Occurred()) SWIG_fail;
20826 }
20827 resultobj = result;
20828 return resultobj;
20829 fail:
20830 return NULL;
20831 }
20832
20833
20834 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20835 PyObject *resultobj = 0;
20836 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20837 long arg2 ;
20838 PyObject *result = 0 ;
20839 void *argp1 = 0 ;
20840 int res1 = 0 ;
20841 long val2 ;
20842 int ecode2 = 0 ;
20843 PyObject * obj0 = 0 ;
20844 PyObject * obj1 = 0 ;
20845 char * kwnames[] = {
20846 (char *) "self",(char *) "index", NULL
20847 };
20848
20849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20851 if (!SWIG_IsOK(res1)) {
20852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20853 }
20854 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20855 ecode2 = SWIG_AsVal_long(obj1, &val2);
20856 if (!SWIG_IsOK(ecode2)) {
20857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
20858 }
20859 arg2 = static_cast< long >(val2);
20860 {
20861 PyThreadState* __tstate = wxPyBeginAllowThreads();
20862 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
20863 wxPyEndAllowThreads(__tstate);
20864 if (PyErr_Occurred()) SWIG_fail;
20865 }
20866 resultobj = result;
20867 return resultobj;
20868 fail:
20869 return NULL;
20870 }
20871
20872
20873 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20874 PyObject *resultobj = 0;
20875 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20876 PyObject *result = 0 ;
20877 void *argp1 = 0 ;
20878 int res1 = 0 ;
20879 PyObject *swig_obj[1] ;
20880
20881 if (!args) SWIG_fail;
20882 swig_obj[0] = args;
20883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20884 if (!SWIG_IsOK(res1)) {
20885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20886 }
20887 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20888 {
20889 PyThreadState* __tstate = wxPyBeginAllowThreads();
20890 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
20891 wxPyEndAllowThreads(__tstate);
20892 if (PyErr_Occurred()) SWIG_fail;
20893 }
20894 resultobj = result;
20895 return resultobj;
20896 fail:
20897 return NULL;
20898 }
20899
20900
20901 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20902 PyObject *resultobj = 0;
20903 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20904 long arg2 ;
20905 PyObject *result = 0 ;
20906 void *argp1 = 0 ;
20907 int res1 = 0 ;
20908 long val2 ;
20909 int ecode2 = 0 ;
20910 PyObject * obj0 = 0 ;
20911 PyObject * obj1 = 0 ;
20912 char * kwnames[] = {
20913 (char *) "self",(char *) "index", NULL
20914 };
20915
20916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20918 if (!SWIG_IsOK(res1)) {
20919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20920 }
20921 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20922 ecode2 = SWIG_AsVal_long(obj1, &val2);
20923 if (!SWIG_IsOK(ecode2)) {
20924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
20925 }
20926 arg2 = static_cast< long >(val2);
20927 {
20928 PyThreadState* __tstate = wxPyBeginAllowThreads();
20929 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
20930 wxPyEndAllowThreads(__tstate);
20931 if (PyErr_Occurred()) SWIG_fail;
20932 }
20933 resultobj = result;
20934 return resultobj;
20935 fail:
20936 return NULL;
20937 }
20938
20939
20940 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20941 PyObject *resultobj = 0;
20942 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20943 bool arg2 = (bool) false ;
20944 size_t result;
20945 void *argp1 = 0 ;
20946 int res1 = 0 ;
20947 bool val2 ;
20948 int ecode2 = 0 ;
20949 PyObject * obj0 = 0 ;
20950 PyObject * obj1 = 0 ;
20951 char * kwnames[] = {
20952 (char *) "self",(char *) "recursive", NULL
20953 };
20954
20955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
20956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20957 if (!SWIG_IsOK(res1)) {
20958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20959 }
20960 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20961 if (obj1) {
20962 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20963 if (!SWIG_IsOK(ecode2)) {
20964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
20965 }
20966 arg2 = static_cast< bool >(val2);
20967 }
20968 {
20969 PyThreadState* __tstate = wxPyBeginAllowThreads();
20970 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
20971 wxPyEndAllowThreads(__tstate);
20972 if (PyErr_Occurred()) SWIG_fail;
20973 }
20974 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20975 return resultobj;
20976 fail:
20977 return NULL;
20978 }
20979
20980
20981 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20982 PyObject *resultobj = 0;
20983 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20984 bool arg2 = (bool) false ;
20985 size_t result;
20986 void *argp1 = 0 ;
20987 int res1 = 0 ;
20988 bool val2 ;
20989 int ecode2 = 0 ;
20990 PyObject * obj0 = 0 ;
20991 PyObject * obj1 = 0 ;
20992 char * kwnames[] = {
20993 (char *) "self",(char *) "recursive", NULL
20994 };
20995
20996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
20997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20998 if (!SWIG_IsOK(res1)) {
20999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21000 }
21001 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21002 if (obj1) {
21003 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21004 if (!SWIG_IsOK(ecode2)) {
21005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21006 }
21007 arg2 = static_cast< bool >(val2);
21008 }
21009 {
21010 PyThreadState* __tstate = wxPyBeginAllowThreads();
21011 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21012 wxPyEndAllowThreads(__tstate);
21013 if (PyErr_Occurred()) SWIG_fail;
21014 }
21015 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21016 return resultobj;
21017 fail:
21018 return NULL;
21019 }
21020
21021
21022 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21023 PyObject *resultobj = 0;
21024 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21025 wxString *arg2 = 0 ;
21026 bool result;
21027 void *argp1 = 0 ;
21028 int res1 = 0 ;
21029 bool temp2 = false ;
21030 PyObject * obj0 = 0 ;
21031 PyObject * obj1 = 0 ;
21032 char * kwnames[] = {
21033 (char *) "self",(char *) "name", NULL
21034 };
21035
21036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21038 if (!SWIG_IsOK(res1)) {
21039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21040 }
21041 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21042 {
21043 arg2 = wxString_in_helper(obj1);
21044 if (arg2 == NULL) SWIG_fail;
21045 temp2 = true;
21046 }
21047 {
21048 PyThreadState* __tstate = wxPyBeginAllowThreads();
21049 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21050 wxPyEndAllowThreads(__tstate);
21051 if (PyErr_Occurred()) SWIG_fail;
21052 }
21053 {
21054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21055 }
21056 {
21057 if (temp2)
21058 delete arg2;
21059 }
21060 return resultobj;
21061 fail:
21062 {
21063 if (temp2)
21064 delete arg2;
21065 }
21066 return NULL;
21067 }
21068
21069
21070 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21071 PyObject *resultobj = 0;
21072 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21073 wxString *arg2 = 0 ;
21074 bool result;
21075 void *argp1 = 0 ;
21076 int res1 = 0 ;
21077 bool temp2 = false ;
21078 PyObject * obj0 = 0 ;
21079 PyObject * obj1 = 0 ;
21080 char * kwnames[] = {
21081 (char *) "self",(char *) "name", NULL
21082 };
21083
21084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21086 if (!SWIG_IsOK(res1)) {
21087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21088 }
21089 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21090 {
21091 arg2 = wxString_in_helper(obj1);
21092 if (arg2 == NULL) SWIG_fail;
21093 temp2 = true;
21094 }
21095 {
21096 PyThreadState* __tstate = wxPyBeginAllowThreads();
21097 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21098 wxPyEndAllowThreads(__tstate);
21099 if (PyErr_Occurred()) SWIG_fail;
21100 }
21101 {
21102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21103 }
21104 {
21105 if (temp2)
21106 delete arg2;
21107 }
21108 return resultobj;
21109 fail:
21110 {
21111 if (temp2)
21112 delete arg2;
21113 }
21114 return NULL;
21115 }
21116
21117
21118 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21119 PyObject *resultobj = 0;
21120 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21121 wxString *arg2 = 0 ;
21122 bool result;
21123 void *argp1 = 0 ;
21124 int res1 = 0 ;
21125 bool temp2 = false ;
21126 PyObject * obj0 = 0 ;
21127 PyObject * obj1 = 0 ;
21128 char * kwnames[] = {
21129 (char *) "self",(char *) "name", NULL
21130 };
21131
21132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21134 if (!SWIG_IsOK(res1)) {
21135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21136 }
21137 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21138 {
21139 arg2 = wxString_in_helper(obj1);
21140 if (arg2 == NULL) SWIG_fail;
21141 temp2 = true;
21142 }
21143 {
21144 PyThreadState* __tstate = wxPyBeginAllowThreads();
21145 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21146 wxPyEndAllowThreads(__tstate);
21147 if (PyErr_Occurred()) SWIG_fail;
21148 }
21149 {
21150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21151 }
21152 {
21153 if (temp2)
21154 delete arg2;
21155 }
21156 return resultobj;
21157 fail:
21158 {
21159 if (temp2)
21160 delete arg2;
21161 }
21162 return NULL;
21163 }
21164
21165
21166 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21167 PyObject *resultobj = 0;
21168 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21169 wxString *arg2 = 0 ;
21170 wxConfigBase::EntryType result;
21171 void *argp1 = 0 ;
21172 int res1 = 0 ;
21173 bool temp2 = false ;
21174 PyObject * obj0 = 0 ;
21175 PyObject * obj1 = 0 ;
21176 char * kwnames[] = {
21177 (char *) "self",(char *) "name", NULL
21178 };
21179
21180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21182 if (!SWIG_IsOK(res1)) {
21183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21184 }
21185 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21186 {
21187 arg2 = wxString_in_helper(obj1);
21188 if (arg2 == NULL) SWIG_fail;
21189 temp2 = true;
21190 }
21191 {
21192 PyThreadState* __tstate = wxPyBeginAllowThreads();
21193 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21194 wxPyEndAllowThreads(__tstate);
21195 if (PyErr_Occurred()) SWIG_fail;
21196 }
21197 resultobj = SWIG_From_int(static_cast< int >(result));
21198 {
21199 if (temp2)
21200 delete arg2;
21201 }
21202 return resultobj;
21203 fail:
21204 {
21205 if (temp2)
21206 delete arg2;
21207 }
21208 return NULL;
21209 }
21210
21211
21212 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21213 PyObject *resultobj = 0;
21214 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21215 wxString *arg2 = 0 ;
21216 wxString const &arg3_defvalue = wxPyEmptyString ;
21217 wxString *arg3 = (wxString *) &arg3_defvalue ;
21218 wxString result;
21219 void *argp1 = 0 ;
21220 int res1 = 0 ;
21221 bool temp2 = false ;
21222 bool temp3 = false ;
21223 PyObject * obj0 = 0 ;
21224 PyObject * obj1 = 0 ;
21225 PyObject * obj2 = 0 ;
21226 char * kwnames[] = {
21227 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21228 };
21229
21230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21232 if (!SWIG_IsOK(res1)) {
21233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21234 }
21235 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21236 {
21237 arg2 = wxString_in_helper(obj1);
21238 if (arg2 == NULL) SWIG_fail;
21239 temp2 = true;
21240 }
21241 if (obj2) {
21242 {
21243 arg3 = wxString_in_helper(obj2);
21244 if (arg3 == NULL) SWIG_fail;
21245 temp3 = true;
21246 }
21247 }
21248 {
21249 PyThreadState* __tstate = wxPyBeginAllowThreads();
21250 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21251 wxPyEndAllowThreads(__tstate);
21252 if (PyErr_Occurred()) SWIG_fail;
21253 }
21254 {
21255 #if wxUSE_UNICODE
21256 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21257 #else
21258 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21259 #endif
21260 }
21261 {
21262 if (temp2)
21263 delete arg2;
21264 }
21265 {
21266 if (temp3)
21267 delete arg3;
21268 }
21269 return resultobj;
21270 fail:
21271 {
21272 if (temp2)
21273 delete arg2;
21274 }
21275 {
21276 if (temp3)
21277 delete arg3;
21278 }
21279 return NULL;
21280 }
21281
21282
21283 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21284 PyObject *resultobj = 0;
21285 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21286 wxString *arg2 = 0 ;
21287 long arg3 = (long) 0 ;
21288 long result;
21289 void *argp1 = 0 ;
21290 int res1 = 0 ;
21291 bool temp2 = false ;
21292 long val3 ;
21293 int ecode3 = 0 ;
21294 PyObject * obj0 = 0 ;
21295 PyObject * obj1 = 0 ;
21296 PyObject * obj2 = 0 ;
21297 char * kwnames[] = {
21298 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21299 };
21300
21301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21303 if (!SWIG_IsOK(res1)) {
21304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21305 }
21306 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21307 {
21308 arg2 = wxString_in_helper(obj1);
21309 if (arg2 == NULL) SWIG_fail;
21310 temp2 = true;
21311 }
21312 if (obj2) {
21313 ecode3 = SWIG_AsVal_long(obj2, &val3);
21314 if (!SWIG_IsOK(ecode3)) {
21315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21316 }
21317 arg3 = static_cast< long >(val3);
21318 }
21319 {
21320 PyThreadState* __tstate = wxPyBeginAllowThreads();
21321 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21322 wxPyEndAllowThreads(__tstate);
21323 if (PyErr_Occurred()) SWIG_fail;
21324 }
21325 resultobj = SWIG_From_long(static_cast< long >(result));
21326 {
21327 if (temp2)
21328 delete arg2;
21329 }
21330 return resultobj;
21331 fail:
21332 {
21333 if (temp2)
21334 delete arg2;
21335 }
21336 return NULL;
21337 }
21338
21339
21340 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21341 PyObject *resultobj = 0;
21342 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21343 wxString *arg2 = 0 ;
21344 double arg3 = (double) 0.0 ;
21345 double result;
21346 void *argp1 = 0 ;
21347 int res1 = 0 ;
21348 bool temp2 = false ;
21349 double val3 ;
21350 int ecode3 = 0 ;
21351 PyObject * obj0 = 0 ;
21352 PyObject * obj1 = 0 ;
21353 PyObject * obj2 = 0 ;
21354 char * kwnames[] = {
21355 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21356 };
21357
21358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21360 if (!SWIG_IsOK(res1)) {
21361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21362 }
21363 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21364 {
21365 arg2 = wxString_in_helper(obj1);
21366 if (arg2 == NULL) SWIG_fail;
21367 temp2 = true;
21368 }
21369 if (obj2) {
21370 ecode3 = SWIG_AsVal_double(obj2, &val3);
21371 if (!SWIG_IsOK(ecode3)) {
21372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21373 }
21374 arg3 = static_cast< double >(val3);
21375 }
21376 {
21377 PyThreadState* __tstate = wxPyBeginAllowThreads();
21378 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21379 wxPyEndAllowThreads(__tstate);
21380 if (PyErr_Occurred()) SWIG_fail;
21381 }
21382 resultobj = SWIG_From_double(static_cast< double >(result));
21383 {
21384 if (temp2)
21385 delete arg2;
21386 }
21387 return resultobj;
21388 fail:
21389 {
21390 if (temp2)
21391 delete arg2;
21392 }
21393 return NULL;
21394 }
21395
21396
21397 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21398 PyObject *resultobj = 0;
21399 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21400 wxString *arg2 = 0 ;
21401 bool arg3 = (bool) false ;
21402 bool result;
21403 void *argp1 = 0 ;
21404 int res1 = 0 ;
21405 bool temp2 = false ;
21406 bool val3 ;
21407 int ecode3 = 0 ;
21408 PyObject * obj0 = 0 ;
21409 PyObject * obj1 = 0 ;
21410 PyObject * obj2 = 0 ;
21411 char * kwnames[] = {
21412 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21413 };
21414
21415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21417 if (!SWIG_IsOK(res1)) {
21418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21419 }
21420 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21421 {
21422 arg2 = wxString_in_helper(obj1);
21423 if (arg2 == NULL) SWIG_fail;
21424 temp2 = true;
21425 }
21426 if (obj2) {
21427 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21428 if (!SWIG_IsOK(ecode3)) {
21429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21430 }
21431 arg3 = static_cast< bool >(val3);
21432 }
21433 {
21434 PyThreadState* __tstate = wxPyBeginAllowThreads();
21435 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21436 wxPyEndAllowThreads(__tstate);
21437 if (PyErr_Occurred()) SWIG_fail;
21438 }
21439 {
21440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21441 }
21442 {
21443 if (temp2)
21444 delete arg2;
21445 }
21446 return resultobj;
21447 fail:
21448 {
21449 if (temp2)
21450 delete arg2;
21451 }
21452 return NULL;
21453 }
21454
21455
21456 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21457 PyObject *resultobj = 0;
21458 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21459 wxString *arg2 = 0 ;
21460 wxString *arg3 = 0 ;
21461 bool result;
21462 void *argp1 = 0 ;
21463 int res1 = 0 ;
21464 bool temp2 = false ;
21465 bool temp3 = false ;
21466 PyObject * obj0 = 0 ;
21467 PyObject * obj1 = 0 ;
21468 PyObject * obj2 = 0 ;
21469 char * kwnames[] = {
21470 (char *) "self",(char *) "key",(char *) "value", NULL
21471 };
21472
21473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21475 if (!SWIG_IsOK(res1)) {
21476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21477 }
21478 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21479 {
21480 arg2 = wxString_in_helper(obj1);
21481 if (arg2 == NULL) SWIG_fail;
21482 temp2 = true;
21483 }
21484 {
21485 arg3 = wxString_in_helper(obj2);
21486 if (arg3 == NULL) SWIG_fail;
21487 temp3 = true;
21488 }
21489 {
21490 PyThreadState* __tstate = wxPyBeginAllowThreads();
21491 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21492 wxPyEndAllowThreads(__tstate);
21493 if (PyErr_Occurred()) SWIG_fail;
21494 }
21495 {
21496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21497 }
21498 {
21499 if (temp2)
21500 delete arg2;
21501 }
21502 {
21503 if (temp3)
21504 delete arg3;
21505 }
21506 return resultobj;
21507 fail:
21508 {
21509 if (temp2)
21510 delete arg2;
21511 }
21512 {
21513 if (temp3)
21514 delete arg3;
21515 }
21516 return NULL;
21517 }
21518
21519
21520 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21521 PyObject *resultobj = 0;
21522 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21523 wxString *arg2 = 0 ;
21524 long arg3 ;
21525 bool result;
21526 void *argp1 = 0 ;
21527 int res1 = 0 ;
21528 bool temp2 = false ;
21529 long val3 ;
21530 int ecode3 = 0 ;
21531 PyObject * obj0 = 0 ;
21532 PyObject * obj1 = 0 ;
21533 PyObject * obj2 = 0 ;
21534 char * kwnames[] = {
21535 (char *) "self",(char *) "key",(char *) "value", NULL
21536 };
21537
21538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21540 if (!SWIG_IsOK(res1)) {
21541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21542 }
21543 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21544 {
21545 arg2 = wxString_in_helper(obj1);
21546 if (arg2 == NULL) SWIG_fail;
21547 temp2 = true;
21548 }
21549 ecode3 = SWIG_AsVal_long(obj2, &val3);
21550 if (!SWIG_IsOK(ecode3)) {
21551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21552 }
21553 arg3 = static_cast< long >(val3);
21554 {
21555 PyThreadState* __tstate = wxPyBeginAllowThreads();
21556 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21557 wxPyEndAllowThreads(__tstate);
21558 if (PyErr_Occurred()) SWIG_fail;
21559 }
21560 {
21561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21562 }
21563 {
21564 if (temp2)
21565 delete arg2;
21566 }
21567 return resultobj;
21568 fail:
21569 {
21570 if (temp2)
21571 delete arg2;
21572 }
21573 return NULL;
21574 }
21575
21576
21577 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21578 PyObject *resultobj = 0;
21579 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21580 wxString *arg2 = 0 ;
21581 double arg3 ;
21582 bool result;
21583 void *argp1 = 0 ;
21584 int res1 = 0 ;
21585 bool temp2 = false ;
21586 double val3 ;
21587 int ecode3 = 0 ;
21588 PyObject * obj0 = 0 ;
21589 PyObject * obj1 = 0 ;
21590 PyObject * obj2 = 0 ;
21591 char * kwnames[] = {
21592 (char *) "self",(char *) "key",(char *) "value", NULL
21593 };
21594
21595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21597 if (!SWIG_IsOK(res1)) {
21598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21599 }
21600 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21601 {
21602 arg2 = wxString_in_helper(obj1);
21603 if (arg2 == NULL) SWIG_fail;
21604 temp2 = true;
21605 }
21606 ecode3 = SWIG_AsVal_double(obj2, &val3);
21607 if (!SWIG_IsOK(ecode3)) {
21608 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21609 }
21610 arg3 = static_cast< double >(val3);
21611 {
21612 PyThreadState* __tstate = wxPyBeginAllowThreads();
21613 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21614 wxPyEndAllowThreads(__tstate);
21615 if (PyErr_Occurred()) SWIG_fail;
21616 }
21617 {
21618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21619 }
21620 {
21621 if (temp2)
21622 delete arg2;
21623 }
21624 return resultobj;
21625 fail:
21626 {
21627 if (temp2)
21628 delete arg2;
21629 }
21630 return NULL;
21631 }
21632
21633
21634 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21635 PyObject *resultobj = 0;
21636 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21637 wxString *arg2 = 0 ;
21638 bool arg3 ;
21639 bool result;
21640 void *argp1 = 0 ;
21641 int res1 = 0 ;
21642 bool temp2 = false ;
21643 bool val3 ;
21644 int ecode3 = 0 ;
21645 PyObject * obj0 = 0 ;
21646 PyObject * obj1 = 0 ;
21647 PyObject * obj2 = 0 ;
21648 char * kwnames[] = {
21649 (char *) "self",(char *) "key",(char *) "value", NULL
21650 };
21651
21652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21654 if (!SWIG_IsOK(res1)) {
21655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21656 }
21657 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21658 {
21659 arg2 = wxString_in_helper(obj1);
21660 if (arg2 == NULL) SWIG_fail;
21661 temp2 = true;
21662 }
21663 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21664 if (!SWIG_IsOK(ecode3)) {
21665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21666 }
21667 arg3 = static_cast< bool >(val3);
21668 {
21669 PyThreadState* __tstate = wxPyBeginAllowThreads();
21670 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21671 wxPyEndAllowThreads(__tstate);
21672 if (PyErr_Occurred()) SWIG_fail;
21673 }
21674 {
21675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21676 }
21677 {
21678 if (temp2)
21679 delete arg2;
21680 }
21681 return resultobj;
21682 fail:
21683 {
21684 if (temp2)
21685 delete arg2;
21686 }
21687 return NULL;
21688 }
21689
21690
21691 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21692 PyObject *resultobj = 0;
21693 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21694 bool arg2 = (bool) false ;
21695 bool result;
21696 void *argp1 = 0 ;
21697 int res1 = 0 ;
21698 bool val2 ;
21699 int ecode2 = 0 ;
21700 PyObject * obj0 = 0 ;
21701 PyObject * obj1 = 0 ;
21702 char * kwnames[] = {
21703 (char *) "self",(char *) "currentOnly", NULL
21704 };
21705
21706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21708 if (!SWIG_IsOK(res1)) {
21709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21710 }
21711 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21712 if (obj1) {
21713 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21714 if (!SWIG_IsOK(ecode2)) {
21715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21716 }
21717 arg2 = static_cast< bool >(val2);
21718 }
21719 {
21720 PyThreadState* __tstate = wxPyBeginAllowThreads();
21721 result = (bool)(arg1)->Flush(arg2);
21722 wxPyEndAllowThreads(__tstate);
21723 if (PyErr_Occurred()) SWIG_fail;
21724 }
21725 {
21726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21727 }
21728 return resultobj;
21729 fail:
21730 return NULL;
21731 }
21732
21733
21734 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21735 PyObject *resultobj = 0;
21736 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21737 wxString *arg2 = 0 ;
21738 wxString *arg3 = 0 ;
21739 bool result;
21740 void *argp1 = 0 ;
21741 int res1 = 0 ;
21742 bool temp2 = false ;
21743 bool temp3 = false ;
21744 PyObject * obj0 = 0 ;
21745 PyObject * obj1 = 0 ;
21746 PyObject * obj2 = 0 ;
21747 char * kwnames[] = {
21748 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21749 };
21750
21751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21753 if (!SWIG_IsOK(res1)) {
21754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21755 }
21756 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21757 {
21758 arg2 = wxString_in_helper(obj1);
21759 if (arg2 == NULL) SWIG_fail;
21760 temp2 = true;
21761 }
21762 {
21763 arg3 = wxString_in_helper(obj2);
21764 if (arg3 == NULL) SWIG_fail;
21765 temp3 = true;
21766 }
21767 {
21768 PyThreadState* __tstate = wxPyBeginAllowThreads();
21769 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
21770 wxPyEndAllowThreads(__tstate);
21771 if (PyErr_Occurred()) SWIG_fail;
21772 }
21773 {
21774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21775 }
21776 {
21777 if (temp2)
21778 delete arg2;
21779 }
21780 {
21781 if (temp3)
21782 delete arg3;
21783 }
21784 return resultobj;
21785 fail:
21786 {
21787 if (temp2)
21788 delete arg2;
21789 }
21790 {
21791 if (temp3)
21792 delete arg3;
21793 }
21794 return NULL;
21795 }
21796
21797
21798 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21799 PyObject *resultobj = 0;
21800 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21801 wxString *arg2 = 0 ;
21802 wxString *arg3 = 0 ;
21803 bool result;
21804 void *argp1 = 0 ;
21805 int res1 = 0 ;
21806 bool temp2 = false ;
21807 bool temp3 = false ;
21808 PyObject * obj0 = 0 ;
21809 PyObject * obj1 = 0 ;
21810 PyObject * obj2 = 0 ;
21811 char * kwnames[] = {
21812 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21813 };
21814
21815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21817 if (!SWIG_IsOK(res1)) {
21818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21819 }
21820 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21821 {
21822 arg2 = wxString_in_helper(obj1);
21823 if (arg2 == NULL) SWIG_fail;
21824 temp2 = true;
21825 }
21826 {
21827 arg3 = wxString_in_helper(obj2);
21828 if (arg3 == NULL) SWIG_fail;
21829 temp3 = true;
21830 }
21831 {
21832 PyThreadState* __tstate = wxPyBeginAllowThreads();
21833 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
21834 wxPyEndAllowThreads(__tstate);
21835 if (PyErr_Occurred()) SWIG_fail;
21836 }
21837 {
21838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21839 }
21840 {
21841 if (temp2)
21842 delete arg2;
21843 }
21844 {
21845 if (temp3)
21846 delete arg3;
21847 }
21848 return resultobj;
21849 fail:
21850 {
21851 if (temp2)
21852 delete arg2;
21853 }
21854 {
21855 if (temp3)
21856 delete arg3;
21857 }
21858 return NULL;
21859 }
21860
21861
21862 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21863 PyObject *resultobj = 0;
21864 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21865 wxString *arg2 = 0 ;
21866 bool arg3 = (bool) true ;
21867 bool result;
21868 void *argp1 = 0 ;
21869 int res1 = 0 ;
21870 bool temp2 = false ;
21871 bool val3 ;
21872 int ecode3 = 0 ;
21873 PyObject * obj0 = 0 ;
21874 PyObject * obj1 = 0 ;
21875 PyObject * obj2 = 0 ;
21876 char * kwnames[] = {
21877 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
21878 };
21879
21880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21882 if (!SWIG_IsOK(res1)) {
21883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21884 }
21885 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21886 {
21887 arg2 = wxString_in_helper(obj1);
21888 if (arg2 == NULL) SWIG_fail;
21889 temp2 = true;
21890 }
21891 if (obj2) {
21892 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21893 if (!SWIG_IsOK(ecode3)) {
21894 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
21895 }
21896 arg3 = static_cast< bool >(val3);
21897 }
21898 {
21899 PyThreadState* __tstate = wxPyBeginAllowThreads();
21900 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
21901 wxPyEndAllowThreads(__tstate);
21902 if (PyErr_Occurred()) SWIG_fail;
21903 }
21904 {
21905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21906 }
21907 {
21908 if (temp2)
21909 delete arg2;
21910 }
21911 return resultobj;
21912 fail:
21913 {
21914 if (temp2)
21915 delete arg2;
21916 }
21917 return NULL;
21918 }
21919
21920
21921 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21922 PyObject *resultobj = 0;
21923 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21924 wxString *arg2 = 0 ;
21925 bool result;
21926 void *argp1 = 0 ;
21927 int res1 = 0 ;
21928 bool temp2 = false ;
21929 PyObject * obj0 = 0 ;
21930 PyObject * obj1 = 0 ;
21931 char * kwnames[] = {
21932 (char *) "self",(char *) "key", NULL
21933 };
21934
21935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21937 if (!SWIG_IsOK(res1)) {
21938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21939 }
21940 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21941 {
21942 arg2 = wxString_in_helper(obj1);
21943 if (arg2 == NULL) SWIG_fail;
21944 temp2 = true;
21945 }
21946 {
21947 PyThreadState* __tstate = wxPyBeginAllowThreads();
21948 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
21949 wxPyEndAllowThreads(__tstate);
21950 if (PyErr_Occurred()) SWIG_fail;
21951 }
21952 {
21953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21954 }
21955 {
21956 if (temp2)
21957 delete arg2;
21958 }
21959 return resultobj;
21960 fail:
21961 {
21962 if (temp2)
21963 delete arg2;
21964 }
21965 return NULL;
21966 }
21967
21968
21969 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21970 PyObject *resultobj = 0;
21971 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21972 bool result;
21973 void *argp1 = 0 ;
21974 int res1 = 0 ;
21975 PyObject *swig_obj[1] ;
21976
21977 if (!args) SWIG_fail;
21978 swig_obj[0] = args;
21979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21980 if (!SWIG_IsOK(res1)) {
21981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21982 }
21983 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21984 {
21985 PyThreadState* __tstate = wxPyBeginAllowThreads();
21986 result = (bool)(arg1)->DeleteAll();
21987 wxPyEndAllowThreads(__tstate);
21988 if (PyErr_Occurred()) SWIG_fail;
21989 }
21990 {
21991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21992 }
21993 return resultobj;
21994 fail:
21995 return NULL;
21996 }
21997
21998
21999 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22000 PyObject *resultobj = 0;
22001 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22002 bool arg2 = (bool) true ;
22003 void *argp1 = 0 ;
22004 int res1 = 0 ;
22005 bool val2 ;
22006 int ecode2 = 0 ;
22007 PyObject * obj0 = 0 ;
22008 PyObject * obj1 = 0 ;
22009 char * kwnames[] = {
22010 (char *) "self",(char *) "doIt", NULL
22011 };
22012
22013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22015 if (!SWIG_IsOK(res1)) {
22016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22017 }
22018 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22019 if (obj1) {
22020 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22021 if (!SWIG_IsOK(ecode2)) {
22022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22023 }
22024 arg2 = static_cast< bool >(val2);
22025 }
22026 {
22027 PyThreadState* __tstate = wxPyBeginAllowThreads();
22028 (arg1)->SetExpandEnvVars(arg2);
22029 wxPyEndAllowThreads(__tstate);
22030 if (PyErr_Occurred()) SWIG_fail;
22031 }
22032 resultobj = SWIG_Py_Void();
22033 return resultobj;
22034 fail:
22035 return NULL;
22036 }
22037
22038
22039 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22040 PyObject *resultobj = 0;
22041 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22042 bool result;
22043 void *argp1 = 0 ;
22044 int res1 = 0 ;
22045 PyObject *swig_obj[1] ;
22046
22047 if (!args) SWIG_fail;
22048 swig_obj[0] = args;
22049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22050 if (!SWIG_IsOK(res1)) {
22051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22052 }
22053 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22054 {
22055 PyThreadState* __tstate = wxPyBeginAllowThreads();
22056 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22057 wxPyEndAllowThreads(__tstate);
22058 if (PyErr_Occurred()) SWIG_fail;
22059 }
22060 {
22061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22062 }
22063 return resultobj;
22064 fail:
22065 return NULL;
22066 }
22067
22068
22069 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22070 PyObject *resultobj = 0;
22071 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22072 bool arg2 = (bool) true ;
22073 void *argp1 = 0 ;
22074 int res1 = 0 ;
22075 bool val2 ;
22076 int ecode2 = 0 ;
22077 PyObject * obj0 = 0 ;
22078 PyObject * obj1 = 0 ;
22079 char * kwnames[] = {
22080 (char *) "self",(char *) "doIt", NULL
22081 };
22082
22083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22085 if (!SWIG_IsOK(res1)) {
22086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22087 }
22088 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22089 if (obj1) {
22090 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22091 if (!SWIG_IsOK(ecode2)) {
22092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22093 }
22094 arg2 = static_cast< bool >(val2);
22095 }
22096 {
22097 PyThreadState* __tstate = wxPyBeginAllowThreads();
22098 (arg1)->SetRecordDefaults(arg2);
22099 wxPyEndAllowThreads(__tstate);
22100 if (PyErr_Occurred()) SWIG_fail;
22101 }
22102 resultobj = SWIG_Py_Void();
22103 return resultobj;
22104 fail:
22105 return NULL;
22106 }
22107
22108
22109 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22110 PyObject *resultobj = 0;
22111 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22112 bool result;
22113 void *argp1 = 0 ;
22114 int res1 = 0 ;
22115 PyObject *swig_obj[1] ;
22116
22117 if (!args) SWIG_fail;
22118 swig_obj[0] = args;
22119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22120 if (!SWIG_IsOK(res1)) {
22121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22122 }
22123 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22124 {
22125 PyThreadState* __tstate = wxPyBeginAllowThreads();
22126 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22127 wxPyEndAllowThreads(__tstate);
22128 if (PyErr_Occurred()) SWIG_fail;
22129 }
22130 {
22131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22132 }
22133 return resultobj;
22134 fail:
22135 return NULL;
22136 }
22137
22138
22139 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22140 PyObject *resultobj = 0;
22141 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22142 wxString *arg2 = 0 ;
22143 wxString result;
22144 void *argp1 = 0 ;
22145 int res1 = 0 ;
22146 bool temp2 = false ;
22147 PyObject * obj0 = 0 ;
22148 PyObject * obj1 = 0 ;
22149 char * kwnames[] = {
22150 (char *) "self",(char *) "str", NULL
22151 };
22152
22153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22155 if (!SWIG_IsOK(res1)) {
22156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22157 }
22158 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22159 {
22160 arg2 = wxString_in_helper(obj1);
22161 if (arg2 == NULL) SWIG_fail;
22162 temp2 = true;
22163 }
22164 {
22165 PyThreadState* __tstate = wxPyBeginAllowThreads();
22166 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22167 wxPyEndAllowThreads(__tstate);
22168 if (PyErr_Occurred()) SWIG_fail;
22169 }
22170 {
22171 #if wxUSE_UNICODE
22172 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22173 #else
22174 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22175 #endif
22176 }
22177 {
22178 if (temp2)
22179 delete arg2;
22180 }
22181 return resultobj;
22182 fail:
22183 {
22184 if (temp2)
22185 delete arg2;
22186 }
22187 return NULL;
22188 }
22189
22190
22191 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22192 PyObject *resultobj = 0;
22193 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22194 wxString result;
22195 void *argp1 = 0 ;
22196 int res1 = 0 ;
22197 PyObject *swig_obj[1] ;
22198
22199 if (!args) SWIG_fail;
22200 swig_obj[0] = args;
22201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22202 if (!SWIG_IsOK(res1)) {
22203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22204 }
22205 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22206 {
22207 PyThreadState* __tstate = wxPyBeginAllowThreads();
22208 result = ((wxConfigBase const *)arg1)->GetAppName();
22209 wxPyEndAllowThreads(__tstate);
22210 if (PyErr_Occurred()) SWIG_fail;
22211 }
22212 {
22213 #if wxUSE_UNICODE
22214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22215 #else
22216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22217 #endif
22218 }
22219 return resultobj;
22220 fail:
22221 return NULL;
22222 }
22223
22224
22225 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22226 PyObject *resultobj = 0;
22227 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22228 wxString result;
22229 void *argp1 = 0 ;
22230 int res1 = 0 ;
22231 PyObject *swig_obj[1] ;
22232
22233 if (!args) SWIG_fail;
22234 swig_obj[0] = args;
22235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22236 if (!SWIG_IsOK(res1)) {
22237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22238 }
22239 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22240 {
22241 PyThreadState* __tstate = wxPyBeginAllowThreads();
22242 result = ((wxConfigBase const *)arg1)->GetVendorName();
22243 wxPyEndAllowThreads(__tstate);
22244 if (PyErr_Occurred()) SWIG_fail;
22245 }
22246 {
22247 #if wxUSE_UNICODE
22248 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22249 #else
22250 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22251 #endif
22252 }
22253 return resultobj;
22254 fail:
22255 return NULL;
22256 }
22257
22258
22259 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22260 PyObject *resultobj = 0;
22261 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22262 wxString *arg2 = 0 ;
22263 void *argp1 = 0 ;
22264 int res1 = 0 ;
22265 bool temp2 = false ;
22266 PyObject * obj0 = 0 ;
22267 PyObject * obj1 = 0 ;
22268 char * kwnames[] = {
22269 (char *) "self",(char *) "appName", NULL
22270 };
22271
22272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22274 if (!SWIG_IsOK(res1)) {
22275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22276 }
22277 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22278 {
22279 arg2 = wxString_in_helper(obj1);
22280 if (arg2 == NULL) SWIG_fail;
22281 temp2 = true;
22282 }
22283 {
22284 PyThreadState* __tstate = wxPyBeginAllowThreads();
22285 (arg1)->SetAppName((wxString const &)*arg2);
22286 wxPyEndAllowThreads(__tstate);
22287 if (PyErr_Occurred()) SWIG_fail;
22288 }
22289 resultobj = SWIG_Py_Void();
22290 {
22291 if (temp2)
22292 delete arg2;
22293 }
22294 return resultobj;
22295 fail:
22296 {
22297 if (temp2)
22298 delete arg2;
22299 }
22300 return NULL;
22301 }
22302
22303
22304 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22305 PyObject *resultobj = 0;
22306 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22307 wxString *arg2 = 0 ;
22308 void *argp1 = 0 ;
22309 int res1 = 0 ;
22310 bool temp2 = false ;
22311 PyObject * obj0 = 0 ;
22312 PyObject * obj1 = 0 ;
22313 char * kwnames[] = {
22314 (char *) "self",(char *) "vendorName", NULL
22315 };
22316
22317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22319 if (!SWIG_IsOK(res1)) {
22320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22321 }
22322 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22323 {
22324 arg2 = wxString_in_helper(obj1);
22325 if (arg2 == NULL) SWIG_fail;
22326 temp2 = true;
22327 }
22328 {
22329 PyThreadState* __tstate = wxPyBeginAllowThreads();
22330 (arg1)->SetVendorName((wxString const &)*arg2);
22331 wxPyEndAllowThreads(__tstate);
22332 if (PyErr_Occurred()) SWIG_fail;
22333 }
22334 resultobj = SWIG_Py_Void();
22335 {
22336 if (temp2)
22337 delete arg2;
22338 }
22339 return resultobj;
22340 fail:
22341 {
22342 if (temp2)
22343 delete arg2;
22344 }
22345 return NULL;
22346 }
22347
22348
22349 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22350 PyObject *resultobj = 0;
22351 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22352 long arg2 ;
22353 void *argp1 = 0 ;
22354 int res1 = 0 ;
22355 long val2 ;
22356 int ecode2 = 0 ;
22357 PyObject * obj0 = 0 ;
22358 PyObject * obj1 = 0 ;
22359 char * kwnames[] = {
22360 (char *) "self",(char *) "style", NULL
22361 };
22362
22363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22365 if (!SWIG_IsOK(res1)) {
22366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22367 }
22368 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22369 ecode2 = SWIG_AsVal_long(obj1, &val2);
22370 if (!SWIG_IsOK(ecode2)) {
22371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22372 }
22373 arg2 = static_cast< long >(val2);
22374 {
22375 PyThreadState* __tstate = wxPyBeginAllowThreads();
22376 (arg1)->SetStyle(arg2);
22377 wxPyEndAllowThreads(__tstate);
22378 if (PyErr_Occurred()) SWIG_fail;
22379 }
22380 resultobj = SWIG_Py_Void();
22381 return resultobj;
22382 fail:
22383 return NULL;
22384 }
22385
22386
22387 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22388 PyObject *resultobj = 0;
22389 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22390 long result;
22391 void *argp1 = 0 ;
22392 int res1 = 0 ;
22393 PyObject *swig_obj[1] ;
22394
22395 if (!args) SWIG_fail;
22396 swig_obj[0] = args;
22397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22398 if (!SWIG_IsOK(res1)) {
22399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22400 }
22401 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22402 {
22403 PyThreadState* __tstate = wxPyBeginAllowThreads();
22404 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22405 wxPyEndAllowThreads(__tstate);
22406 if (PyErr_Occurred()) SWIG_fail;
22407 }
22408 resultobj = SWIG_From_long(static_cast< long >(result));
22409 return resultobj;
22410 fail:
22411 return NULL;
22412 }
22413
22414
22415 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22416 PyObject *obj;
22417 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22418 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22419 return SWIG_Py_Void();
22420 }
22421
22422 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22423 PyObject *resultobj = 0;
22424 wxString const &arg1_defvalue = wxPyEmptyString ;
22425 wxString *arg1 = (wxString *) &arg1_defvalue ;
22426 wxString const &arg2_defvalue = wxPyEmptyString ;
22427 wxString *arg2 = (wxString *) &arg2_defvalue ;
22428 wxString const &arg3_defvalue = wxPyEmptyString ;
22429 wxString *arg3 = (wxString *) &arg3_defvalue ;
22430 wxString const &arg4_defvalue = wxPyEmptyString ;
22431 wxString *arg4 = (wxString *) &arg4_defvalue ;
22432 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22433 wxConfig *result = 0 ;
22434 bool temp1 = false ;
22435 bool temp2 = false ;
22436 bool temp3 = false ;
22437 bool temp4 = false ;
22438 long val5 ;
22439 int ecode5 = 0 ;
22440 PyObject * obj0 = 0 ;
22441 PyObject * obj1 = 0 ;
22442 PyObject * obj2 = 0 ;
22443 PyObject * obj3 = 0 ;
22444 PyObject * obj4 = 0 ;
22445 char * kwnames[] = {
22446 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22447 };
22448
22449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22450 if (obj0) {
22451 {
22452 arg1 = wxString_in_helper(obj0);
22453 if (arg1 == NULL) SWIG_fail;
22454 temp1 = true;
22455 }
22456 }
22457 if (obj1) {
22458 {
22459 arg2 = wxString_in_helper(obj1);
22460 if (arg2 == NULL) SWIG_fail;
22461 temp2 = true;
22462 }
22463 }
22464 if (obj2) {
22465 {
22466 arg3 = wxString_in_helper(obj2);
22467 if (arg3 == NULL) SWIG_fail;
22468 temp3 = true;
22469 }
22470 }
22471 if (obj3) {
22472 {
22473 arg4 = wxString_in_helper(obj3);
22474 if (arg4 == NULL) SWIG_fail;
22475 temp4 = true;
22476 }
22477 }
22478 if (obj4) {
22479 ecode5 = SWIG_AsVal_long(obj4, &val5);
22480 if (!SWIG_IsOK(ecode5)) {
22481 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22482 }
22483 arg5 = static_cast< long >(val5);
22484 }
22485 {
22486 PyThreadState* __tstate = wxPyBeginAllowThreads();
22487 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22488 wxPyEndAllowThreads(__tstate);
22489 if (PyErr_Occurred()) SWIG_fail;
22490 }
22491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22492 {
22493 if (temp1)
22494 delete arg1;
22495 }
22496 {
22497 if (temp2)
22498 delete arg2;
22499 }
22500 {
22501 if (temp3)
22502 delete arg3;
22503 }
22504 {
22505 if (temp4)
22506 delete arg4;
22507 }
22508 return resultobj;
22509 fail:
22510 {
22511 if (temp1)
22512 delete arg1;
22513 }
22514 {
22515 if (temp2)
22516 delete arg2;
22517 }
22518 {
22519 if (temp3)
22520 delete arg3;
22521 }
22522 {
22523 if (temp4)
22524 delete arg4;
22525 }
22526 return NULL;
22527 }
22528
22529
22530 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22531 PyObject *resultobj = 0;
22532 wxConfig *arg1 = (wxConfig *) 0 ;
22533 void *argp1 = 0 ;
22534 int res1 = 0 ;
22535 PyObject *swig_obj[1] ;
22536
22537 if (!args) SWIG_fail;
22538 swig_obj[0] = args;
22539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22540 if (!SWIG_IsOK(res1)) {
22541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22542 }
22543 arg1 = reinterpret_cast< wxConfig * >(argp1);
22544 {
22545 PyThreadState* __tstate = wxPyBeginAllowThreads();
22546 delete arg1;
22547
22548 wxPyEndAllowThreads(__tstate);
22549 if (PyErr_Occurred()) SWIG_fail;
22550 }
22551 resultobj = SWIG_Py_Void();
22552 return resultobj;
22553 fail:
22554 return NULL;
22555 }
22556
22557
22558 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22559 PyObject *obj;
22560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22561 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22562 return SWIG_Py_Void();
22563 }
22564
22565 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22566 return SWIG_Python_InitShadowInstance(args);
22567 }
22568
22569 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22570 PyObject *resultobj = 0;
22571 wxString const &arg1_defvalue = wxPyEmptyString ;
22572 wxString *arg1 = (wxString *) &arg1_defvalue ;
22573 wxString const &arg2_defvalue = wxPyEmptyString ;
22574 wxString *arg2 = (wxString *) &arg2_defvalue ;
22575 wxString const &arg3_defvalue = wxPyEmptyString ;
22576 wxString *arg3 = (wxString *) &arg3_defvalue ;
22577 wxString const &arg4_defvalue = wxPyEmptyString ;
22578 wxString *arg4 = (wxString *) &arg4_defvalue ;
22579 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22580 wxFileConfig *result = 0 ;
22581 bool temp1 = false ;
22582 bool temp2 = false ;
22583 bool temp3 = false ;
22584 bool temp4 = false ;
22585 long val5 ;
22586 int ecode5 = 0 ;
22587 PyObject * obj0 = 0 ;
22588 PyObject * obj1 = 0 ;
22589 PyObject * obj2 = 0 ;
22590 PyObject * obj3 = 0 ;
22591 PyObject * obj4 = 0 ;
22592 char * kwnames[] = {
22593 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22594 };
22595
22596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22597 if (obj0) {
22598 {
22599 arg1 = wxString_in_helper(obj0);
22600 if (arg1 == NULL) SWIG_fail;
22601 temp1 = true;
22602 }
22603 }
22604 if (obj1) {
22605 {
22606 arg2 = wxString_in_helper(obj1);
22607 if (arg2 == NULL) SWIG_fail;
22608 temp2 = true;
22609 }
22610 }
22611 if (obj2) {
22612 {
22613 arg3 = wxString_in_helper(obj2);
22614 if (arg3 == NULL) SWIG_fail;
22615 temp3 = true;
22616 }
22617 }
22618 if (obj3) {
22619 {
22620 arg4 = wxString_in_helper(obj3);
22621 if (arg4 == NULL) SWIG_fail;
22622 temp4 = true;
22623 }
22624 }
22625 if (obj4) {
22626 ecode5 = SWIG_AsVal_long(obj4, &val5);
22627 if (!SWIG_IsOK(ecode5)) {
22628 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22629 }
22630 arg5 = static_cast< long >(val5);
22631 }
22632 {
22633 PyThreadState* __tstate = wxPyBeginAllowThreads();
22634 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22635 wxPyEndAllowThreads(__tstate);
22636 if (PyErr_Occurred()) SWIG_fail;
22637 }
22638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22639 {
22640 if (temp1)
22641 delete arg1;
22642 }
22643 {
22644 if (temp2)
22645 delete arg2;
22646 }
22647 {
22648 if (temp3)
22649 delete arg3;
22650 }
22651 {
22652 if (temp4)
22653 delete arg4;
22654 }
22655 return resultobj;
22656 fail:
22657 {
22658 if (temp1)
22659 delete arg1;
22660 }
22661 {
22662 if (temp2)
22663 delete arg2;
22664 }
22665 {
22666 if (temp3)
22667 delete arg3;
22668 }
22669 {
22670 if (temp4)
22671 delete arg4;
22672 }
22673 return NULL;
22674 }
22675
22676
22677 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22678 PyObject *resultobj = 0;
22679 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22680 void *argp1 = 0 ;
22681 int res1 = 0 ;
22682 PyObject *swig_obj[1] ;
22683
22684 if (!args) SWIG_fail;
22685 swig_obj[0] = args;
22686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22687 if (!SWIG_IsOK(res1)) {
22688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22689 }
22690 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22691 {
22692 PyThreadState* __tstate = wxPyBeginAllowThreads();
22693 delete arg1;
22694
22695 wxPyEndAllowThreads(__tstate);
22696 if (PyErr_Occurred()) SWIG_fail;
22697 }
22698 resultobj = SWIG_Py_Void();
22699 return resultobj;
22700 fail:
22701 return NULL;
22702 }
22703
22704
22705 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22706 PyObject *obj;
22707 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22708 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22709 return SWIG_Py_Void();
22710 }
22711
22712 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22713 return SWIG_Python_InitShadowInstance(args);
22714 }
22715
22716 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22717 PyObject *resultobj = 0;
22718 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22719 wxString *arg2 = 0 ;
22720 wxConfigPathChanger *result = 0 ;
22721 void *argp1 = 0 ;
22722 int res1 = 0 ;
22723 bool temp2 = false ;
22724 PyObject * obj0 = 0 ;
22725 PyObject * obj1 = 0 ;
22726 char * kwnames[] = {
22727 (char *) "config",(char *) "entry", NULL
22728 };
22729
22730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22732 if (!SWIG_IsOK(res1)) {
22733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22734 }
22735 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22736 {
22737 arg2 = wxString_in_helper(obj1);
22738 if (arg2 == NULL) SWIG_fail;
22739 temp2 = true;
22740 }
22741 {
22742 PyThreadState* __tstate = wxPyBeginAllowThreads();
22743 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22744 wxPyEndAllowThreads(__tstate);
22745 if (PyErr_Occurred()) SWIG_fail;
22746 }
22747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
22748 {
22749 if (temp2)
22750 delete arg2;
22751 }
22752 return resultobj;
22753 fail:
22754 {
22755 if (temp2)
22756 delete arg2;
22757 }
22758 return NULL;
22759 }
22760
22761
22762 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22763 PyObject *resultobj = 0;
22764 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22765 void *argp1 = 0 ;
22766 int res1 = 0 ;
22767 PyObject *swig_obj[1] ;
22768
22769 if (!args) SWIG_fail;
22770 swig_obj[0] = args;
22771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
22772 if (!SWIG_IsOK(res1)) {
22773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
22774 }
22775 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22776 {
22777 PyThreadState* __tstate = wxPyBeginAllowThreads();
22778 delete arg1;
22779
22780 wxPyEndAllowThreads(__tstate);
22781 if (PyErr_Occurred()) SWIG_fail;
22782 }
22783 resultobj = SWIG_Py_Void();
22784 return resultobj;
22785 fail:
22786 return NULL;
22787 }
22788
22789
22790 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22791 PyObject *resultobj = 0;
22792 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22793 wxString *result = 0 ;
22794 void *argp1 = 0 ;
22795 int res1 = 0 ;
22796 PyObject *swig_obj[1] ;
22797
22798 if (!args) SWIG_fail;
22799 swig_obj[0] = args;
22800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
22801 if (!SWIG_IsOK(res1)) {
22802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
22803 }
22804 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22805 {
22806 PyThreadState* __tstate = wxPyBeginAllowThreads();
22807 {
22808 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
22809 result = (wxString *) &_result_ref;
22810 }
22811 wxPyEndAllowThreads(__tstate);
22812 if (PyErr_Occurred()) SWIG_fail;
22813 }
22814 {
22815 #if wxUSE_UNICODE
22816 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22817 #else
22818 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22819 #endif
22820 }
22821 return resultobj;
22822 fail:
22823 return NULL;
22824 }
22825
22826
22827 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22828 PyObject *obj;
22829 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22830 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
22831 return SWIG_Py_Void();
22832 }
22833
22834 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22835 return SWIG_Python_InitShadowInstance(args);
22836 }
22837
22838 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22839 PyObject *resultobj = 0;
22840 wxString *arg1 = 0 ;
22841 wxString result;
22842 bool temp1 = false ;
22843 PyObject * obj0 = 0 ;
22844 char * kwnames[] = {
22845 (char *) "sz", NULL
22846 };
22847
22848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
22849 {
22850 arg1 = wxString_in_helper(obj0);
22851 if (arg1 == NULL) SWIG_fail;
22852 temp1 = true;
22853 }
22854 {
22855 PyThreadState* __tstate = wxPyBeginAllowThreads();
22856 result = wxExpandEnvVars((wxString const &)*arg1);
22857 wxPyEndAllowThreads(__tstate);
22858 if (PyErr_Occurred()) SWIG_fail;
22859 }
22860 {
22861 #if wxUSE_UNICODE
22862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22863 #else
22864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22865 #endif
22866 }
22867 {
22868 if (temp1)
22869 delete arg1;
22870 }
22871 return resultobj;
22872 fail:
22873 {
22874 if (temp1)
22875 delete arg1;
22876 }
22877 return NULL;
22878 }
22879
22880
22881 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
22882 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
22883 return 1;
22884 }
22885
22886
22887 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
22888 PyObject *pyobj = 0;
22889
22890 {
22891 #if wxUSE_UNICODE
22892 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
22893 #else
22894 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
22895 #endif
22896 }
22897 return pyobj;
22898 }
22899
22900
22901 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
22902 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
22903 return 1;
22904 }
22905
22906
22907 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
22908 PyObject *pyobj = 0;
22909
22910 {
22911 #if wxUSE_UNICODE
22912 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22913 #else
22914 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22915 #endif
22916 }
22917 return pyobj;
22918 }
22919
22920
22921 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22922 PyObject *resultobj = 0;
22923 wxDateTime::Country arg1 ;
22924 int val1 ;
22925 int ecode1 = 0 ;
22926 PyObject * obj0 = 0 ;
22927 char * kwnames[] = {
22928 (char *) "country", NULL
22929 };
22930
22931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
22932 ecode1 = SWIG_AsVal_int(obj0, &val1);
22933 if (!SWIG_IsOK(ecode1)) {
22934 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22935 }
22936 arg1 = static_cast< wxDateTime::Country >(val1);
22937 {
22938 PyThreadState* __tstate = wxPyBeginAllowThreads();
22939 wxDateTime::SetCountry(arg1);
22940 wxPyEndAllowThreads(__tstate);
22941 if (PyErr_Occurred()) SWIG_fail;
22942 }
22943 resultobj = SWIG_Py_Void();
22944 return resultobj;
22945 fail:
22946 return NULL;
22947 }
22948
22949
22950 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22951 PyObject *resultobj = 0;
22952 wxDateTime::Country result;
22953
22954 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
22955 {
22956 PyThreadState* __tstate = wxPyBeginAllowThreads();
22957 result = (wxDateTime::Country)wxDateTime::GetCountry();
22958 wxPyEndAllowThreads(__tstate);
22959 if (PyErr_Occurred()) SWIG_fail;
22960 }
22961 resultobj = SWIG_From_int(static_cast< int >(result));
22962 return resultobj;
22963 fail:
22964 return NULL;
22965 }
22966
22967
22968 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22969 PyObject *resultobj = 0;
22970 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
22971 bool result;
22972 int val1 ;
22973 int ecode1 = 0 ;
22974 PyObject * obj0 = 0 ;
22975 char * kwnames[] = {
22976 (char *) "country", NULL
22977 };
22978
22979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
22980 if (obj0) {
22981 ecode1 = SWIG_AsVal_int(obj0, &val1);
22982 if (!SWIG_IsOK(ecode1)) {
22983 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22984 }
22985 arg1 = static_cast< wxDateTime::Country >(val1);
22986 }
22987 {
22988 PyThreadState* __tstate = wxPyBeginAllowThreads();
22989 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
22990 wxPyEndAllowThreads(__tstate);
22991 if (PyErr_Occurred()) SWIG_fail;
22992 }
22993 {
22994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22995 }
22996 return resultobj;
22997 fail:
22998 return NULL;
22999 }
23000
23001
23002 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23003 PyObject *resultobj = 0;
23004 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23005 int result;
23006 int val1 ;
23007 int ecode1 = 0 ;
23008 PyObject * obj0 = 0 ;
23009 char * kwnames[] = {
23010 (char *) "cal", NULL
23011 };
23012
23013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23014 if (obj0) {
23015 ecode1 = SWIG_AsVal_int(obj0, &val1);
23016 if (!SWIG_IsOK(ecode1)) {
23017 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23018 }
23019 arg1 = static_cast< wxDateTime::Calendar >(val1);
23020 }
23021 {
23022 PyThreadState* __tstate = wxPyBeginAllowThreads();
23023 result = (int)wxDateTime::GetCurrentYear(arg1);
23024 wxPyEndAllowThreads(__tstate);
23025 if (PyErr_Occurred()) SWIG_fail;
23026 }
23027 resultobj = SWIG_From_int(static_cast< int >(result));
23028 return resultobj;
23029 fail:
23030 return NULL;
23031 }
23032
23033
23034 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23035 PyObject *resultobj = 0;
23036 int arg1 ;
23037 int result;
23038 int val1 ;
23039 int ecode1 = 0 ;
23040 PyObject * obj0 = 0 ;
23041 char * kwnames[] = {
23042 (char *) "year", NULL
23043 };
23044
23045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23046 ecode1 = SWIG_AsVal_int(obj0, &val1);
23047 if (!SWIG_IsOK(ecode1)) {
23048 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23049 }
23050 arg1 = static_cast< int >(val1);
23051 {
23052 PyThreadState* __tstate = wxPyBeginAllowThreads();
23053 result = (int)wxDateTime::ConvertYearToBC(arg1);
23054 wxPyEndAllowThreads(__tstate);
23055 if (PyErr_Occurred()) SWIG_fail;
23056 }
23057 resultobj = SWIG_From_int(static_cast< int >(result));
23058 return resultobj;
23059 fail:
23060 return NULL;
23061 }
23062
23063
23064 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23065 PyObject *resultobj = 0;
23066 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23067 wxDateTime::Month result;
23068 int val1 ;
23069 int ecode1 = 0 ;
23070 PyObject * obj0 = 0 ;
23071 char * kwnames[] = {
23072 (char *) "cal", NULL
23073 };
23074
23075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23076 if (obj0) {
23077 ecode1 = SWIG_AsVal_int(obj0, &val1);
23078 if (!SWIG_IsOK(ecode1)) {
23079 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23080 }
23081 arg1 = static_cast< wxDateTime::Calendar >(val1);
23082 }
23083 {
23084 PyThreadState* __tstate = wxPyBeginAllowThreads();
23085 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23086 wxPyEndAllowThreads(__tstate);
23087 if (PyErr_Occurred()) SWIG_fail;
23088 }
23089 resultobj = SWIG_From_int(static_cast< int >(result));
23090 return resultobj;
23091 fail:
23092 return NULL;
23093 }
23094
23095
23096 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23097 PyObject *resultobj = 0;
23098 int arg1 = (int) wxDateTime::Inv_Year ;
23099 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23100 bool result;
23101 int val1 ;
23102 int ecode1 = 0 ;
23103 int val2 ;
23104 int ecode2 = 0 ;
23105 PyObject * obj0 = 0 ;
23106 PyObject * obj1 = 0 ;
23107 char * kwnames[] = {
23108 (char *) "year",(char *) "cal", NULL
23109 };
23110
23111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23112 if (obj0) {
23113 ecode1 = SWIG_AsVal_int(obj0, &val1);
23114 if (!SWIG_IsOK(ecode1)) {
23115 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23116 }
23117 arg1 = static_cast< int >(val1);
23118 }
23119 if (obj1) {
23120 ecode2 = SWIG_AsVal_int(obj1, &val2);
23121 if (!SWIG_IsOK(ecode2)) {
23122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23123 }
23124 arg2 = static_cast< wxDateTime::Calendar >(val2);
23125 }
23126 {
23127 PyThreadState* __tstate = wxPyBeginAllowThreads();
23128 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23129 wxPyEndAllowThreads(__tstate);
23130 if (PyErr_Occurred()) SWIG_fail;
23131 }
23132 {
23133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23134 }
23135 return resultobj;
23136 fail:
23137 return NULL;
23138 }
23139
23140
23141 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23142 PyObject *resultobj = 0;
23143 int arg1 = (int) wxDateTime::Inv_Year ;
23144 int result;
23145 int val1 ;
23146 int ecode1 = 0 ;
23147 PyObject * obj0 = 0 ;
23148 char * kwnames[] = {
23149 (char *) "year", NULL
23150 };
23151
23152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23153 if (obj0) {
23154 ecode1 = SWIG_AsVal_int(obj0, &val1);
23155 if (!SWIG_IsOK(ecode1)) {
23156 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23157 }
23158 arg1 = static_cast< int >(val1);
23159 }
23160 {
23161 PyThreadState* __tstate = wxPyBeginAllowThreads();
23162 result = (int)wxDateTime::GetCentury(arg1);
23163 wxPyEndAllowThreads(__tstate);
23164 if (PyErr_Occurred()) SWIG_fail;
23165 }
23166 resultobj = SWIG_From_int(static_cast< int >(result));
23167 return resultobj;
23168 fail:
23169 return NULL;
23170 }
23171
23172
23173 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23174 PyObject *resultobj = 0;
23175 int arg1 ;
23176 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23177 int result;
23178 int val1 ;
23179 int ecode1 = 0 ;
23180 int val2 ;
23181 int ecode2 = 0 ;
23182 PyObject * obj0 = 0 ;
23183 PyObject * obj1 = 0 ;
23184 char * kwnames[] = {
23185 (char *) "year",(char *) "cal", NULL
23186 };
23187
23188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23189 ecode1 = SWIG_AsVal_int(obj0, &val1);
23190 if (!SWIG_IsOK(ecode1)) {
23191 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23192 }
23193 arg1 = static_cast< int >(val1);
23194 if (obj1) {
23195 ecode2 = SWIG_AsVal_int(obj1, &val2);
23196 if (!SWIG_IsOK(ecode2)) {
23197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23198 }
23199 arg2 = static_cast< wxDateTime::Calendar >(val2);
23200 }
23201 {
23202 PyThreadState* __tstate = wxPyBeginAllowThreads();
23203 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23204 wxPyEndAllowThreads(__tstate);
23205 if (PyErr_Occurred()) SWIG_fail;
23206 }
23207 resultobj = SWIG_From_int(static_cast< int >(result));
23208 return resultobj;
23209 fail:
23210 return NULL;
23211 }
23212
23213
23214 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23215 PyObject *resultobj = 0;
23216 wxDateTime::Month arg1 ;
23217 int arg2 = (int) wxDateTime::Inv_Year ;
23218 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23219 int result;
23220 int val1 ;
23221 int ecode1 = 0 ;
23222 int val2 ;
23223 int ecode2 = 0 ;
23224 int val3 ;
23225 int ecode3 = 0 ;
23226 PyObject * obj0 = 0 ;
23227 PyObject * obj1 = 0 ;
23228 PyObject * obj2 = 0 ;
23229 char * kwnames[] = {
23230 (char *) "month",(char *) "year",(char *) "cal", NULL
23231 };
23232
23233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23234 ecode1 = SWIG_AsVal_int(obj0, &val1);
23235 if (!SWIG_IsOK(ecode1)) {
23236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23237 }
23238 arg1 = static_cast< wxDateTime::Month >(val1);
23239 if (obj1) {
23240 ecode2 = SWIG_AsVal_int(obj1, &val2);
23241 if (!SWIG_IsOK(ecode2)) {
23242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23243 }
23244 arg2 = static_cast< int >(val2);
23245 }
23246 if (obj2) {
23247 ecode3 = SWIG_AsVal_int(obj2, &val3);
23248 if (!SWIG_IsOK(ecode3)) {
23249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23250 }
23251 arg3 = static_cast< wxDateTime::Calendar >(val3);
23252 }
23253 {
23254 PyThreadState* __tstate = wxPyBeginAllowThreads();
23255 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23256 wxPyEndAllowThreads(__tstate);
23257 if (PyErr_Occurred()) SWIG_fail;
23258 }
23259 resultobj = SWIG_From_int(static_cast< int >(result));
23260 return resultobj;
23261 fail:
23262 return NULL;
23263 }
23264
23265
23266 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23267 PyObject *resultobj = 0;
23268 wxDateTime::Month arg1 ;
23269 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23270 wxString result;
23271 int val1 ;
23272 int ecode1 = 0 ;
23273 int val2 ;
23274 int ecode2 = 0 ;
23275 PyObject * obj0 = 0 ;
23276 PyObject * obj1 = 0 ;
23277 char * kwnames[] = {
23278 (char *) "month",(char *) "flags", NULL
23279 };
23280
23281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23282 ecode1 = SWIG_AsVal_int(obj0, &val1);
23283 if (!SWIG_IsOK(ecode1)) {
23284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23285 }
23286 arg1 = static_cast< wxDateTime::Month >(val1);
23287 if (obj1) {
23288 ecode2 = SWIG_AsVal_int(obj1, &val2);
23289 if (!SWIG_IsOK(ecode2)) {
23290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23291 }
23292 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23293 }
23294 {
23295 PyThreadState* __tstate = wxPyBeginAllowThreads();
23296 result = wxDateTime::GetMonthName(arg1,arg2);
23297 wxPyEndAllowThreads(__tstate);
23298 if (PyErr_Occurred()) SWIG_fail;
23299 }
23300 {
23301 #if wxUSE_UNICODE
23302 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23303 #else
23304 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23305 #endif
23306 }
23307 return resultobj;
23308 fail:
23309 return NULL;
23310 }
23311
23312
23313 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23314 PyObject *resultobj = 0;
23315 wxDateTime::WeekDay arg1 ;
23316 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23317 wxString result;
23318 int val1 ;
23319 int ecode1 = 0 ;
23320 int val2 ;
23321 int ecode2 = 0 ;
23322 PyObject * obj0 = 0 ;
23323 PyObject * obj1 = 0 ;
23324 char * kwnames[] = {
23325 (char *) "weekday",(char *) "flags", NULL
23326 };
23327
23328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23329 ecode1 = SWIG_AsVal_int(obj0, &val1);
23330 if (!SWIG_IsOK(ecode1)) {
23331 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23332 }
23333 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23334 if (obj1) {
23335 ecode2 = SWIG_AsVal_int(obj1, &val2);
23336 if (!SWIG_IsOK(ecode2)) {
23337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23338 }
23339 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23340 }
23341 {
23342 PyThreadState* __tstate = wxPyBeginAllowThreads();
23343 result = wxDateTime::GetWeekDayName(arg1,arg2);
23344 wxPyEndAllowThreads(__tstate);
23345 if (PyErr_Occurred()) SWIG_fail;
23346 }
23347 {
23348 #if wxUSE_UNICODE
23349 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23350 #else
23351 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23352 #endif
23353 }
23354 return resultobj;
23355 fail:
23356 return NULL;
23357 }
23358
23359
23360 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23361 PyObject *resultobj = 0;
23362 PyObject *result = 0 ;
23363
23364 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23365 {
23366 PyThreadState* __tstate = wxPyBeginAllowThreads();
23367 result = (PyObject *)wxDateTime_GetAmPmStrings();
23368 wxPyEndAllowThreads(__tstate);
23369 if (PyErr_Occurred()) SWIG_fail;
23370 }
23371 resultobj = result;
23372 return resultobj;
23373 fail:
23374 return NULL;
23375 }
23376
23377
23378 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23379 PyObject *resultobj = 0;
23380 int arg1 = (int) wxDateTime::Inv_Year ;
23381 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23382 bool result;
23383 int val1 ;
23384 int ecode1 = 0 ;
23385 int val2 ;
23386 int ecode2 = 0 ;
23387 PyObject * obj0 = 0 ;
23388 PyObject * obj1 = 0 ;
23389 char * kwnames[] = {
23390 (char *) "year",(char *) "country", NULL
23391 };
23392
23393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23394 if (obj0) {
23395 ecode1 = SWIG_AsVal_int(obj0, &val1);
23396 if (!SWIG_IsOK(ecode1)) {
23397 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23398 }
23399 arg1 = static_cast< int >(val1);
23400 }
23401 if (obj1) {
23402 ecode2 = SWIG_AsVal_int(obj1, &val2);
23403 if (!SWIG_IsOK(ecode2)) {
23404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23405 }
23406 arg2 = static_cast< wxDateTime::Country >(val2);
23407 }
23408 {
23409 PyThreadState* __tstate = wxPyBeginAllowThreads();
23410 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23411 wxPyEndAllowThreads(__tstate);
23412 if (PyErr_Occurred()) SWIG_fail;
23413 }
23414 {
23415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23416 }
23417 return resultobj;
23418 fail:
23419 return NULL;
23420 }
23421
23422
23423 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23424 PyObject *resultobj = 0;
23425 int arg1 = (int) wxDateTime::Inv_Year ;
23426 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23427 wxDateTime result;
23428 int val1 ;
23429 int ecode1 = 0 ;
23430 int val2 ;
23431 int ecode2 = 0 ;
23432 PyObject * obj0 = 0 ;
23433 PyObject * obj1 = 0 ;
23434 char * kwnames[] = {
23435 (char *) "year",(char *) "country", NULL
23436 };
23437
23438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23439 if (obj0) {
23440 ecode1 = SWIG_AsVal_int(obj0, &val1);
23441 if (!SWIG_IsOK(ecode1)) {
23442 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23443 }
23444 arg1 = static_cast< int >(val1);
23445 }
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_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23450 }
23451 arg2 = static_cast< wxDateTime::Country >(val2);
23452 }
23453 {
23454 PyThreadState* __tstate = wxPyBeginAllowThreads();
23455 result = wxDateTime::GetBeginDST(arg1,arg2);
23456 wxPyEndAllowThreads(__tstate);
23457 if (PyErr_Occurred()) SWIG_fail;
23458 }
23459 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23460 return resultobj;
23461 fail:
23462 return NULL;
23463 }
23464
23465
23466 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23467 PyObject *resultobj = 0;
23468 int arg1 = (int) wxDateTime::Inv_Year ;
23469 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23470 wxDateTime result;
23471 int val1 ;
23472 int ecode1 = 0 ;
23473 int val2 ;
23474 int ecode2 = 0 ;
23475 PyObject * obj0 = 0 ;
23476 PyObject * obj1 = 0 ;
23477 char * kwnames[] = {
23478 (char *) "year",(char *) "country", NULL
23479 };
23480
23481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23482 if (obj0) {
23483 ecode1 = SWIG_AsVal_int(obj0, &val1);
23484 if (!SWIG_IsOK(ecode1)) {
23485 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23486 }
23487 arg1 = static_cast< int >(val1);
23488 }
23489 if (obj1) {
23490 ecode2 = SWIG_AsVal_int(obj1, &val2);
23491 if (!SWIG_IsOK(ecode2)) {
23492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23493 }
23494 arg2 = static_cast< wxDateTime::Country >(val2);
23495 }
23496 {
23497 PyThreadState* __tstate = wxPyBeginAllowThreads();
23498 result = wxDateTime::GetEndDST(arg1,arg2);
23499 wxPyEndAllowThreads(__tstate);
23500 if (PyErr_Occurred()) SWIG_fail;
23501 }
23502 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23503 return resultobj;
23504 fail:
23505 return NULL;
23506 }
23507
23508
23509 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23510 PyObject *resultobj = 0;
23511 wxDateTime result;
23512
23513 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23514 {
23515 PyThreadState* __tstate = wxPyBeginAllowThreads();
23516 result = wxDateTime::Now();
23517 wxPyEndAllowThreads(__tstate);
23518 if (PyErr_Occurred()) SWIG_fail;
23519 }
23520 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23521 return resultobj;
23522 fail:
23523 return NULL;
23524 }
23525
23526
23527 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23528 PyObject *resultobj = 0;
23529 wxDateTime result;
23530
23531 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23532 {
23533 PyThreadState* __tstate = wxPyBeginAllowThreads();
23534 result = wxDateTime::UNow();
23535 wxPyEndAllowThreads(__tstate);
23536 if (PyErr_Occurred()) SWIG_fail;
23537 }
23538 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23539 return resultobj;
23540 fail:
23541 return NULL;
23542 }
23543
23544
23545 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23546 PyObject *resultobj = 0;
23547 wxDateTime result;
23548
23549 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23550 {
23551 PyThreadState* __tstate = wxPyBeginAllowThreads();
23552 result = wxDateTime::Today();
23553 wxPyEndAllowThreads(__tstate);
23554 if (PyErr_Occurred()) SWIG_fail;
23555 }
23556 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23557 return resultobj;
23558 fail:
23559 return NULL;
23560 }
23561
23562
23563 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23564 PyObject *resultobj = 0;
23565 wxDateTime *result = 0 ;
23566
23567 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23568 {
23569 PyThreadState* __tstate = wxPyBeginAllowThreads();
23570 result = (wxDateTime *)new wxDateTime();
23571 wxPyEndAllowThreads(__tstate);
23572 if (PyErr_Occurred()) SWIG_fail;
23573 }
23574 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23575 return resultobj;
23576 fail:
23577 return NULL;
23578 }
23579
23580
23581 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23582 PyObject *resultobj = 0;
23583 time_t arg1 ;
23584 wxDateTime *result = 0 ;
23585 unsigned int val1 ;
23586 int ecode1 = 0 ;
23587 PyObject * obj0 = 0 ;
23588 char * kwnames[] = {
23589 (char *) "timet", NULL
23590 };
23591
23592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23593 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23594 if (!SWIG_IsOK(ecode1)) {
23595 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23596 }
23597 arg1 = static_cast< time_t >(val1);
23598 {
23599 PyThreadState* __tstate = wxPyBeginAllowThreads();
23600 result = (wxDateTime *)new wxDateTime(arg1);
23601 wxPyEndAllowThreads(__tstate);
23602 if (PyErr_Occurred()) SWIG_fail;
23603 }
23604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23605 return resultobj;
23606 fail:
23607 return NULL;
23608 }
23609
23610
23611 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23612 PyObject *resultobj = 0;
23613 double arg1 ;
23614 wxDateTime *result = 0 ;
23615 double val1 ;
23616 int ecode1 = 0 ;
23617 PyObject * obj0 = 0 ;
23618 char * kwnames[] = {
23619 (char *) "jdn", NULL
23620 };
23621
23622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23623 ecode1 = SWIG_AsVal_double(obj0, &val1);
23624 if (!SWIG_IsOK(ecode1)) {
23625 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23626 }
23627 arg1 = static_cast< double >(val1);
23628 {
23629 PyThreadState* __tstate = wxPyBeginAllowThreads();
23630 result = (wxDateTime *)new wxDateTime(arg1);
23631 wxPyEndAllowThreads(__tstate);
23632 if (PyErr_Occurred()) SWIG_fail;
23633 }
23634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23635 return resultobj;
23636 fail:
23637 return NULL;
23638 }
23639
23640
23641 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23642 PyObject *resultobj = 0;
23643 int arg1 ;
23644 int arg2 = (int) 0 ;
23645 int arg3 = (int) 0 ;
23646 int arg4 = (int) 0 ;
23647 wxDateTime *result = 0 ;
23648 int val1 ;
23649 int ecode1 = 0 ;
23650 int val2 ;
23651 int ecode2 = 0 ;
23652 int val3 ;
23653 int ecode3 = 0 ;
23654 int val4 ;
23655 int ecode4 = 0 ;
23656 PyObject * obj0 = 0 ;
23657 PyObject * obj1 = 0 ;
23658 PyObject * obj2 = 0 ;
23659 PyObject * obj3 = 0 ;
23660 char * kwnames[] = {
23661 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23662 };
23663
23664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23665 ecode1 = SWIG_AsVal_int(obj0, &val1);
23666 if (!SWIG_IsOK(ecode1)) {
23667 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23668 }
23669 arg1 = static_cast< int >(val1);
23670 if (obj1) {
23671 ecode2 = SWIG_AsVal_int(obj1, &val2);
23672 if (!SWIG_IsOK(ecode2)) {
23673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23674 }
23675 arg2 = static_cast< int >(val2);
23676 }
23677 if (obj2) {
23678 ecode3 = SWIG_AsVal_int(obj2, &val3);
23679 if (!SWIG_IsOK(ecode3)) {
23680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23681 }
23682 arg3 = static_cast< int >(val3);
23683 }
23684 if (obj3) {
23685 ecode4 = SWIG_AsVal_int(obj3, &val4);
23686 if (!SWIG_IsOK(ecode4)) {
23687 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23688 }
23689 arg4 = static_cast< int >(val4);
23690 }
23691 {
23692 PyThreadState* __tstate = wxPyBeginAllowThreads();
23693 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23694 wxPyEndAllowThreads(__tstate);
23695 if (PyErr_Occurred()) SWIG_fail;
23696 }
23697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23698 return resultobj;
23699 fail:
23700 return NULL;
23701 }
23702
23703
23704 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23705 PyObject *resultobj = 0;
23706 int arg1 ;
23707 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23708 int arg3 = (int) wxDateTime::Inv_Year ;
23709 int arg4 = (int) 0 ;
23710 int arg5 = (int) 0 ;
23711 int arg6 = (int) 0 ;
23712 int arg7 = (int) 0 ;
23713 wxDateTime *result = 0 ;
23714 int val1 ;
23715 int ecode1 = 0 ;
23716 int val2 ;
23717 int ecode2 = 0 ;
23718 int val3 ;
23719 int ecode3 = 0 ;
23720 int val4 ;
23721 int ecode4 = 0 ;
23722 int val5 ;
23723 int ecode5 = 0 ;
23724 int val6 ;
23725 int ecode6 = 0 ;
23726 int val7 ;
23727 int ecode7 = 0 ;
23728 PyObject * obj0 = 0 ;
23729 PyObject * obj1 = 0 ;
23730 PyObject * obj2 = 0 ;
23731 PyObject * obj3 = 0 ;
23732 PyObject * obj4 = 0 ;
23733 PyObject * obj5 = 0 ;
23734 PyObject * obj6 = 0 ;
23735 char * kwnames[] = {
23736 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23737 };
23738
23739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23740 ecode1 = SWIG_AsVal_int(obj0, &val1);
23741 if (!SWIG_IsOK(ecode1)) {
23742 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23743 }
23744 arg1 = static_cast< int >(val1);
23745 if (obj1) {
23746 ecode2 = SWIG_AsVal_int(obj1, &val2);
23747 if (!SWIG_IsOK(ecode2)) {
23748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23749 }
23750 arg2 = static_cast< wxDateTime::Month >(val2);
23751 }
23752 if (obj2) {
23753 ecode3 = SWIG_AsVal_int(obj2, &val3);
23754 if (!SWIG_IsOK(ecode3)) {
23755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
23756 }
23757 arg3 = static_cast< int >(val3);
23758 }
23759 if (obj3) {
23760 ecode4 = SWIG_AsVal_int(obj3, &val4);
23761 if (!SWIG_IsOK(ecode4)) {
23762 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
23763 }
23764 arg4 = static_cast< int >(val4);
23765 }
23766 if (obj4) {
23767 ecode5 = SWIG_AsVal_int(obj4, &val5);
23768 if (!SWIG_IsOK(ecode5)) {
23769 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
23770 }
23771 arg5 = static_cast< int >(val5);
23772 }
23773 if (obj5) {
23774 ecode6 = SWIG_AsVal_int(obj5, &val6);
23775 if (!SWIG_IsOK(ecode6)) {
23776 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
23777 }
23778 arg6 = static_cast< int >(val6);
23779 }
23780 if (obj6) {
23781 ecode7 = SWIG_AsVal_int(obj6, &val7);
23782 if (!SWIG_IsOK(ecode7)) {
23783 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
23784 }
23785 arg7 = static_cast< int >(val7);
23786 }
23787 {
23788 PyThreadState* __tstate = wxPyBeginAllowThreads();
23789 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
23790 wxPyEndAllowThreads(__tstate);
23791 if (PyErr_Occurred()) SWIG_fail;
23792 }
23793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23794 return resultobj;
23795 fail:
23796 return NULL;
23797 }
23798
23799
23800 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23801 PyObject *resultobj = 0;
23802 wxDateTime *arg1 = 0 ;
23803 wxDateTime *result = 0 ;
23804 void *argp1 = 0 ;
23805 int res1 = 0 ;
23806 PyObject * obj0 = 0 ;
23807 char * kwnames[] = {
23808 (char *) "date", NULL
23809 };
23810
23811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
23812 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
23813 if (!SWIG_IsOK(res1)) {
23814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23815 }
23816 if (!argp1) {
23817 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23818 }
23819 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23820 {
23821 PyThreadState* __tstate = wxPyBeginAllowThreads();
23822 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
23823 wxPyEndAllowThreads(__tstate);
23824 if (PyErr_Occurred()) SWIG_fail;
23825 }
23826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23827 return resultobj;
23828 fail:
23829 return NULL;
23830 }
23831
23832
23833 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23834 PyObject *resultobj = 0;
23835 wxDateTime *arg1 = (wxDateTime *) 0 ;
23836 void *argp1 = 0 ;
23837 int res1 = 0 ;
23838 PyObject *swig_obj[1] ;
23839
23840 if (!args) SWIG_fail;
23841 swig_obj[0] = args;
23842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
23843 if (!SWIG_IsOK(res1)) {
23844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23845 }
23846 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23847 {
23848 PyThreadState* __tstate = wxPyBeginAllowThreads();
23849 delete arg1;
23850
23851 wxPyEndAllowThreads(__tstate);
23852 if (PyErr_Occurred()) SWIG_fail;
23853 }
23854 resultobj = SWIG_Py_Void();
23855 return resultobj;
23856 fail:
23857 return NULL;
23858 }
23859
23860
23861 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23862 PyObject *resultobj = 0;
23863 wxDateTime *arg1 = (wxDateTime *) 0 ;
23864 wxDateTime *result = 0 ;
23865 void *argp1 = 0 ;
23866 int res1 = 0 ;
23867 PyObject *swig_obj[1] ;
23868
23869 if (!args) SWIG_fail;
23870 swig_obj[0] = args;
23871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23872 if (!SWIG_IsOK(res1)) {
23873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
23874 }
23875 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23876 {
23877 PyThreadState* __tstate = wxPyBeginAllowThreads();
23878 {
23879 wxDateTime &_result_ref = (arg1)->SetToCurrent();
23880 result = (wxDateTime *) &_result_ref;
23881 }
23882 wxPyEndAllowThreads(__tstate);
23883 if (PyErr_Occurred()) SWIG_fail;
23884 }
23885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23886 return resultobj;
23887 fail:
23888 return NULL;
23889 }
23890
23891
23892 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23893 PyObject *resultobj = 0;
23894 wxDateTime *arg1 = (wxDateTime *) 0 ;
23895 time_t arg2 ;
23896 wxDateTime *result = 0 ;
23897 void *argp1 = 0 ;
23898 int res1 = 0 ;
23899 unsigned int val2 ;
23900 int ecode2 = 0 ;
23901 PyObject * obj0 = 0 ;
23902 PyObject * obj1 = 0 ;
23903 char * kwnames[] = {
23904 (char *) "self",(char *) "timet", NULL
23905 };
23906
23907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
23908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23909 if (!SWIG_IsOK(res1)) {
23910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
23911 }
23912 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23913 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
23914 if (!SWIG_IsOK(ecode2)) {
23915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
23916 }
23917 arg2 = static_cast< time_t >(val2);
23918 {
23919 PyThreadState* __tstate = wxPyBeginAllowThreads();
23920 {
23921 wxDateTime &_result_ref = (arg1)->Set(arg2);
23922 result = (wxDateTime *) &_result_ref;
23923 }
23924 wxPyEndAllowThreads(__tstate);
23925 if (PyErr_Occurred()) SWIG_fail;
23926 }
23927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23928 return resultobj;
23929 fail:
23930 return NULL;
23931 }
23932
23933
23934 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23935 PyObject *resultobj = 0;
23936 wxDateTime *arg1 = (wxDateTime *) 0 ;
23937 double arg2 ;
23938 wxDateTime *result = 0 ;
23939 void *argp1 = 0 ;
23940 int res1 = 0 ;
23941 double val2 ;
23942 int ecode2 = 0 ;
23943 PyObject * obj0 = 0 ;
23944 PyObject * obj1 = 0 ;
23945 char * kwnames[] = {
23946 (char *) "self",(char *) "jdn", NULL
23947 };
23948
23949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
23950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23951 if (!SWIG_IsOK(res1)) {
23952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
23953 }
23954 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23955 ecode2 = SWIG_AsVal_double(obj1, &val2);
23956 if (!SWIG_IsOK(ecode2)) {
23957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
23958 }
23959 arg2 = static_cast< double >(val2);
23960 {
23961 PyThreadState* __tstate = wxPyBeginAllowThreads();
23962 {
23963 wxDateTime &_result_ref = (arg1)->Set(arg2);
23964 result = (wxDateTime *) &_result_ref;
23965 }
23966 wxPyEndAllowThreads(__tstate);
23967 if (PyErr_Occurred()) SWIG_fail;
23968 }
23969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23970 return resultobj;
23971 fail:
23972 return NULL;
23973 }
23974
23975
23976 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23977 PyObject *resultobj = 0;
23978 wxDateTime *arg1 = (wxDateTime *) 0 ;
23979 int arg2 ;
23980 int arg3 = (int) 0 ;
23981 int arg4 = (int) 0 ;
23982 int arg5 = (int) 0 ;
23983 wxDateTime *result = 0 ;
23984 void *argp1 = 0 ;
23985 int res1 = 0 ;
23986 int val2 ;
23987 int ecode2 = 0 ;
23988 int val3 ;
23989 int ecode3 = 0 ;
23990 int val4 ;
23991 int ecode4 = 0 ;
23992 int val5 ;
23993 int ecode5 = 0 ;
23994 PyObject * obj0 = 0 ;
23995 PyObject * obj1 = 0 ;
23996 PyObject * obj2 = 0 ;
23997 PyObject * obj3 = 0 ;
23998 PyObject * obj4 = 0 ;
23999 char * kwnames[] = {
24000 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24001 };
24002
24003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24005 if (!SWIG_IsOK(res1)) {
24006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24007 }
24008 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24009 ecode2 = SWIG_AsVal_int(obj1, &val2);
24010 if (!SWIG_IsOK(ecode2)) {
24011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24012 }
24013 arg2 = static_cast< int >(val2);
24014 if (obj2) {
24015 ecode3 = SWIG_AsVal_int(obj2, &val3);
24016 if (!SWIG_IsOK(ecode3)) {
24017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24018 }
24019 arg3 = static_cast< int >(val3);
24020 }
24021 if (obj3) {
24022 ecode4 = SWIG_AsVal_int(obj3, &val4);
24023 if (!SWIG_IsOK(ecode4)) {
24024 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24025 }
24026 arg4 = static_cast< int >(val4);
24027 }
24028 if (obj4) {
24029 ecode5 = SWIG_AsVal_int(obj4, &val5);
24030 if (!SWIG_IsOK(ecode5)) {
24031 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24032 }
24033 arg5 = static_cast< int >(val5);
24034 }
24035 {
24036 PyThreadState* __tstate = wxPyBeginAllowThreads();
24037 {
24038 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24039 result = (wxDateTime *) &_result_ref;
24040 }
24041 wxPyEndAllowThreads(__tstate);
24042 if (PyErr_Occurred()) SWIG_fail;
24043 }
24044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24045 return resultobj;
24046 fail:
24047 return NULL;
24048 }
24049
24050
24051 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24052 PyObject *resultobj = 0;
24053 wxDateTime *arg1 = (wxDateTime *) 0 ;
24054 int arg2 ;
24055 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24056 int arg4 = (int) wxDateTime::Inv_Year ;
24057 int arg5 = (int) 0 ;
24058 int arg6 = (int) 0 ;
24059 int arg7 = (int) 0 ;
24060 int arg8 = (int) 0 ;
24061 wxDateTime *result = 0 ;
24062 void *argp1 = 0 ;
24063 int res1 = 0 ;
24064 int val2 ;
24065 int ecode2 = 0 ;
24066 int val3 ;
24067 int ecode3 = 0 ;
24068 int val4 ;
24069 int ecode4 = 0 ;
24070 int val5 ;
24071 int ecode5 = 0 ;
24072 int val6 ;
24073 int ecode6 = 0 ;
24074 int val7 ;
24075 int ecode7 = 0 ;
24076 int val8 ;
24077 int ecode8 = 0 ;
24078 PyObject * obj0 = 0 ;
24079 PyObject * obj1 = 0 ;
24080 PyObject * obj2 = 0 ;
24081 PyObject * obj3 = 0 ;
24082 PyObject * obj4 = 0 ;
24083 PyObject * obj5 = 0 ;
24084 PyObject * obj6 = 0 ;
24085 PyObject * obj7 = 0 ;
24086 char * kwnames[] = {
24087 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24088 };
24089
24090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24092 if (!SWIG_IsOK(res1)) {
24093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24094 }
24095 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24096 ecode2 = SWIG_AsVal_int(obj1, &val2);
24097 if (!SWIG_IsOK(ecode2)) {
24098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24099 }
24100 arg2 = static_cast< int >(val2);
24101 if (obj2) {
24102 ecode3 = SWIG_AsVal_int(obj2, &val3);
24103 if (!SWIG_IsOK(ecode3)) {
24104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24105 }
24106 arg3 = static_cast< wxDateTime::Month >(val3);
24107 }
24108 if (obj3) {
24109 ecode4 = SWIG_AsVal_int(obj3, &val4);
24110 if (!SWIG_IsOK(ecode4)) {
24111 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24112 }
24113 arg4 = static_cast< int >(val4);
24114 }
24115 if (obj4) {
24116 ecode5 = SWIG_AsVal_int(obj4, &val5);
24117 if (!SWIG_IsOK(ecode5)) {
24118 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24119 }
24120 arg5 = static_cast< int >(val5);
24121 }
24122 if (obj5) {
24123 ecode6 = SWIG_AsVal_int(obj5, &val6);
24124 if (!SWIG_IsOK(ecode6)) {
24125 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24126 }
24127 arg6 = static_cast< int >(val6);
24128 }
24129 if (obj6) {
24130 ecode7 = SWIG_AsVal_int(obj6, &val7);
24131 if (!SWIG_IsOK(ecode7)) {
24132 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24133 }
24134 arg7 = static_cast< int >(val7);
24135 }
24136 if (obj7) {
24137 ecode8 = SWIG_AsVal_int(obj7, &val8);
24138 if (!SWIG_IsOK(ecode8)) {
24139 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24140 }
24141 arg8 = static_cast< int >(val8);
24142 }
24143 {
24144 PyThreadState* __tstate = wxPyBeginAllowThreads();
24145 {
24146 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24147 result = (wxDateTime *) &_result_ref;
24148 }
24149 wxPyEndAllowThreads(__tstate);
24150 if (PyErr_Occurred()) SWIG_fail;
24151 }
24152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24153 return resultobj;
24154 fail:
24155 return NULL;
24156 }
24157
24158
24159 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24160 PyObject *resultobj = 0;
24161 wxDateTime *arg1 = (wxDateTime *) 0 ;
24162 wxDateTime *result = 0 ;
24163 void *argp1 = 0 ;
24164 int res1 = 0 ;
24165 PyObject *swig_obj[1] ;
24166
24167 if (!args) SWIG_fail;
24168 swig_obj[0] = args;
24169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24170 if (!SWIG_IsOK(res1)) {
24171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24172 }
24173 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24174 {
24175 PyThreadState* __tstate = wxPyBeginAllowThreads();
24176 {
24177 wxDateTime &_result_ref = (arg1)->ResetTime();
24178 result = (wxDateTime *) &_result_ref;
24179 }
24180 wxPyEndAllowThreads(__tstate);
24181 if (PyErr_Occurred()) SWIG_fail;
24182 }
24183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24184 return resultobj;
24185 fail:
24186 return NULL;
24187 }
24188
24189
24190 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24191 PyObject *resultobj = 0;
24192 wxDateTime *arg1 = (wxDateTime *) 0 ;
24193 int arg2 ;
24194 wxDateTime *result = 0 ;
24195 void *argp1 = 0 ;
24196 int res1 = 0 ;
24197 int val2 ;
24198 int ecode2 = 0 ;
24199 PyObject * obj0 = 0 ;
24200 PyObject * obj1 = 0 ;
24201 char * kwnames[] = {
24202 (char *) "self",(char *) "year", NULL
24203 };
24204
24205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24207 if (!SWIG_IsOK(res1)) {
24208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24209 }
24210 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24211 ecode2 = SWIG_AsVal_int(obj1, &val2);
24212 if (!SWIG_IsOK(ecode2)) {
24213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24214 }
24215 arg2 = static_cast< int >(val2);
24216 {
24217 PyThreadState* __tstate = wxPyBeginAllowThreads();
24218 {
24219 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24220 result = (wxDateTime *) &_result_ref;
24221 }
24222 wxPyEndAllowThreads(__tstate);
24223 if (PyErr_Occurred()) SWIG_fail;
24224 }
24225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24226 return resultobj;
24227 fail:
24228 return NULL;
24229 }
24230
24231
24232 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24233 PyObject *resultobj = 0;
24234 wxDateTime *arg1 = (wxDateTime *) 0 ;
24235 wxDateTime::Month arg2 ;
24236 wxDateTime *result = 0 ;
24237 void *argp1 = 0 ;
24238 int res1 = 0 ;
24239 int val2 ;
24240 int ecode2 = 0 ;
24241 PyObject * obj0 = 0 ;
24242 PyObject * obj1 = 0 ;
24243 char * kwnames[] = {
24244 (char *) "self",(char *) "month", NULL
24245 };
24246
24247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24249 if (!SWIG_IsOK(res1)) {
24250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24251 }
24252 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24253 ecode2 = SWIG_AsVal_int(obj1, &val2);
24254 if (!SWIG_IsOK(ecode2)) {
24255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24256 }
24257 arg2 = static_cast< wxDateTime::Month >(val2);
24258 {
24259 PyThreadState* __tstate = wxPyBeginAllowThreads();
24260 {
24261 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24262 result = (wxDateTime *) &_result_ref;
24263 }
24264 wxPyEndAllowThreads(__tstate);
24265 if (PyErr_Occurred()) SWIG_fail;
24266 }
24267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24268 return resultobj;
24269 fail:
24270 return NULL;
24271 }
24272
24273
24274 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24275 PyObject *resultobj = 0;
24276 wxDateTime *arg1 = (wxDateTime *) 0 ;
24277 int arg2 ;
24278 wxDateTime *result = 0 ;
24279 void *argp1 = 0 ;
24280 int res1 = 0 ;
24281 int val2 ;
24282 int ecode2 = 0 ;
24283 PyObject * obj0 = 0 ;
24284 PyObject * obj1 = 0 ;
24285 char * kwnames[] = {
24286 (char *) "self",(char *) "day", NULL
24287 };
24288
24289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24291 if (!SWIG_IsOK(res1)) {
24292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24293 }
24294 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24295 ecode2 = SWIG_AsVal_int(obj1, &val2);
24296 if (!SWIG_IsOK(ecode2)) {
24297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24298 }
24299 arg2 = static_cast< int >(val2);
24300 {
24301 PyThreadState* __tstate = wxPyBeginAllowThreads();
24302 {
24303 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24304 result = (wxDateTime *) &_result_ref;
24305 }
24306 wxPyEndAllowThreads(__tstate);
24307 if (PyErr_Occurred()) SWIG_fail;
24308 }
24309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24310 return resultobj;
24311 fail:
24312 return NULL;
24313 }
24314
24315
24316 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24317 PyObject *resultobj = 0;
24318 wxDateTime *arg1 = (wxDateTime *) 0 ;
24319 int arg2 ;
24320 wxDateTime *result = 0 ;
24321 void *argp1 = 0 ;
24322 int res1 = 0 ;
24323 int val2 ;
24324 int ecode2 = 0 ;
24325 PyObject * obj0 = 0 ;
24326 PyObject * obj1 = 0 ;
24327 char * kwnames[] = {
24328 (char *) "self",(char *) "hour", NULL
24329 };
24330
24331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24333 if (!SWIG_IsOK(res1)) {
24334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24335 }
24336 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24337 ecode2 = SWIG_AsVal_int(obj1, &val2);
24338 if (!SWIG_IsOK(ecode2)) {
24339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24340 }
24341 arg2 = static_cast< int >(val2);
24342 {
24343 PyThreadState* __tstate = wxPyBeginAllowThreads();
24344 {
24345 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24346 result = (wxDateTime *) &_result_ref;
24347 }
24348 wxPyEndAllowThreads(__tstate);
24349 if (PyErr_Occurred()) SWIG_fail;
24350 }
24351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24352 return resultobj;
24353 fail:
24354 return NULL;
24355 }
24356
24357
24358 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24359 PyObject *resultobj = 0;
24360 wxDateTime *arg1 = (wxDateTime *) 0 ;
24361 int arg2 ;
24362 wxDateTime *result = 0 ;
24363 void *argp1 = 0 ;
24364 int res1 = 0 ;
24365 int val2 ;
24366 int ecode2 = 0 ;
24367 PyObject * obj0 = 0 ;
24368 PyObject * obj1 = 0 ;
24369 char * kwnames[] = {
24370 (char *) "self",(char *) "minute", NULL
24371 };
24372
24373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24375 if (!SWIG_IsOK(res1)) {
24376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24377 }
24378 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24379 ecode2 = SWIG_AsVal_int(obj1, &val2);
24380 if (!SWIG_IsOK(ecode2)) {
24381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24382 }
24383 arg2 = static_cast< int >(val2);
24384 {
24385 PyThreadState* __tstate = wxPyBeginAllowThreads();
24386 {
24387 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24388 result = (wxDateTime *) &_result_ref;
24389 }
24390 wxPyEndAllowThreads(__tstate);
24391 if (PyErr_Occurred()) SWIG_fail;
24392 }
24393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24394 return resultobj;
24395 fail:
24396 return NULL;
24397 }
24398
24399
24400 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24401 PyObject *resultobj = 0;
24402 wxDateTime *arg1 = (wxDateTime *) 0 ;
24403 int arg2 ;
24404 wxDateTime *result = 0 ;
24405 void *argp1 = 0 ;
24406 int res1 = 0 ;
24407 int val2 ;
24408 int ecode2 = 0 ;
24409 PyObject * obj0 = 0 ;
24410 PyObject * obj1 = 0 ;
24411 char * kwnames[] = {
24412 (char *) "self",(char *) "second", NULL
24413 };
24414
24415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24417 if (!SWIG_IsOK(res1)) {
24418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24419 }
24420 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24421 ecode2 = SWIG_AsVal_int(obj1, &val2);
24422 if (!SWIG_IsOK(ecode2)) {
24423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24424 }
24425 arg2 = static_cast< int >(val2);
24426 {
24427 PyThreadState* __tstate = wxPyBeginAllowThreads();
24428 {
24429 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
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_SetMillisecond(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 *) "millisecond", NULL
24455 };
24456
24457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",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_SetMillisecond" "', 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_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24466 }
24467 arg2 = static_cast< int >(val2);
24468 {
24469 PyThreadState* __tstate = wxPyBeginAllowThreads();
24470 {
24471 wxDateTime &_result_ref = (arg1)->SetMillisecond(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_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24485 PyObject *resultobj = 0;
24486 wxDateTime *arg1 = (wxDateTime *) 0 ;
24487 wxDateTime::WeekDay arg2 ;
24488 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24489 wxDateTime *result = 0 ;
24490 void *argp1 = 0 ;
24491 int res1 = 0 ;
24492 int val2 ;
24493 int ecode2 = 0 ;
24494 int val3 ;
24495 int ecode3 = 0 ;
24496 PyObject * obj0 = 0 ;
24497 PyObject * obj1 = 0 ;
24498 PyObject * obj2 = 0 ;
24499 char * kwnames[] = {
24500 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24501 };
24502
24503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24505 if (!SWIG_IsOK(res1)) {
24506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24507 }
24508 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24509 ecode2 = SWIG_AsVal_int(obj1, &val2);
24510 if (!SWIG_IsOK(ecode2)) {
24511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24512 }
24513 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24514 if (obj2) {
24515 ecode3 = SWIG_AsVal_int(obj2, &val3);
24516 if (!SWIG_IsOK(ecode3)) {
24517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24518 }
24519 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24520 }
24521 {
24522 PyThreadState* __tstate = wxPyBeginAllowThreads();
24523 {
24524 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24525 result = (wxDateTime *) &_result_ref;
24526 }
24527 wxPyEndAllowThreads(__tstate);
24528 if (PyErr_Occurred()) SWIG_fail;
24529 }
24530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24531 return resultobj;
24532 fail:
24533 return NULL;
24534 }
24535
24536
24537 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24538 PyObject *resultobj = 0;
24539 wxDateTime *arg1 = (wxDateTime *) 0 ;
24540 wxDateTime::WeekDay arg2 ;
24541 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24542 wxDateTime result;
24543 void *argp1 = 0 ;
24544 int res1 = 0 ;
24545 int val2 ;
24546 int ecode2 = 0 ;
24547 int val3 ;
24548 int ecode3 = 0 ;
24549 PyObject * obj0 = 0 ;
24550 PyObject * obj1 = 0 ;
24551 PyObject * obj2 = 0 ;
24552 char * kwnames[] = {
24553 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24554 };
24555
24556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24558 if (!SWIG_IsOK(res1)) {
24559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24560 }
24561 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24562 ecode2 = SWIG_AsVal_int(obj1, &val2);
24563 if (!SWIG_IsOK(ecode2)) {
24564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24565 }
24566 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24567 if (obj2) {
24568 ecode3 = SWIG_AsVal_int(obj2, &val3);
24569 if (!SWIG_IsOK(ecode3)) {
24570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24571 }
24572 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24573 }
24574 {
24575 PyThreadState* __tstate = wxPyBeginAllowThreads();
24576 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24577 wxPyEndAllowThreads(__tstate);
24578 if (PyErr_Occurred()) SWIG_fail;
24579 }
24580 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24581 return resultobj;
24582 fail:
24583 return NULL;
24584 }
24585
24586
24587 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24588 PyObject *resultobj = 0;
24589 wxDateTime *arg1 = (wxDateTime *) 0 ;
24590 wxDateTime::WeekDay arg2 ;
24591 wxDateTime *result = 0 ;
24592 void *argp1 = 0 ;
24593 int res1 = 0 ;
24594 int val2 ;
24595 int ecode2 = 0 ;
24596 PyObject * obj0 = 0 ;
24597 PyObject * obj1 = 0 ;
24598 char * kwnames[] = {
24599 (char *) "self",(char *) "weekday", NULL
24600 };
24601
24602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24604 if (!SWIG_IsOK(res1)) {
24605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24606 }
24607 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24608 ecode2 = SWIG_AsVal_int(obj1, &val2);
24609 if (!SWIG_IsOK(ecode2)) {
24610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24611 }
24612 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24613 {
24614 PyThreadState* __tstate = wxPyBeginAllowThreads();
24615 {
24616 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24617 result = (wxDateTime *) &_result_ref;
24618 }
24619 wxPyEndAllowThreads(__tstate);
24620 if (PyErr_Occurred()) SWIG_fail;
24621 }
24622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24623 return resultobj;
24624 fail:
24625 return NULL;
24626 }
24627
24628
24629 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24630 PyObject *resultobj = 0;
24631 wxDateTime *arg1 = (wxDateTime *) 0 ;
24632 wxDateTime::WeekDay arg2 ;
24633 wxDateTime result;
24634 void *argp1 = 0 ;
24635 int res1 = 0 ;
24636 int val2 ;
24637 int ecode2 = 0 ;
24638 PyObject * obj0 = 0 ;
24639 PyObject * obj1 = 0 ;
24640 char * kwnames[] = {
24641 (char *) "self",(char *) "weekday", NULL
24642 };
24643
24644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24646 if (!SWIG_IsOK(res1)) {
24647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24648 }
24649 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24650 ecode2 = SWIG_AsVal_int(obj1, &val2);
24651 if (!SWIG_IsOK(ecode2)) {
24652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24653 }
24654 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24655 {
24656 PyThreadState* __tstate = wxPyBeginAllowThreads();
24657 result = (arg1)->GetNextWeekDay(arg2);
24658 wxPyEndAllowThreads(__tstate);
24659 if (PyErr_Occurred()) SWIG_fail;
24660 }
24661 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24662 return resultobj;
24663 fail:
24664 return NULL;
24665 }
24666
24667
24668 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24669 PyObject *resultobj = 0;
24670 wxDateTime *arg1 = (wxDateTime *) 0 ;
24671 wxDateTime::WeekDay arg2 ;
24672 wxDateTime *result = 0 ;
24673 void *argp1 = 0 ;
24674 int res1 = 0 ;
24675 int val2 ;
24676 int ecode2 = 0 ;
24677 PyObject * obj0 = 0 ;
24678 PyObject * obj1 = 0 ;
24679 char * kwnames[] = {
24680 (char *) "self",(char *) "weekday", NULL
24681 };
24682
24683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24685 if (!SWIG_IsOK(res1)) {
24686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24687 }
24688 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24689 ecode2 = SWIG_AsVal_int(obj1, &val2);
24690 if (!SWIG_IsOK(ecode2)) {
24691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24692 }
24693 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24694 {
24695 PyThreadState* __tstate = wxPyBeginAllowThreads();
24696 {
24697 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24698 result = (wxDateTime *) &_result_ref;
24699 }
24700 wxPyEndAllowThreads(__tstate);
24701 if (PyErr_Occurred()) SWIG_fail;
24702 }
24703 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24704 return resultobj;
24705 fail:
24706 return NULL;
24707 }
24708
24709
24710 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24711 PyObject *resultobj = 0;
24712 wxDateTime *arg1 = (wxDateTime *) 0 ;
24713 wxDateTime::WeekDay arg2 ;
24714 wxDateTime result;
24715 void *argp1 = 0 ;
24716 int res1 = 0 ;
24717 int val2 ;
24718 int ecode2 = 0 ;
24719 PyObject * obj0 = 0 ;
24720 PyObject * obj1 = 0 ;
24721 char * kwnames[] = {
24722 (char *) "self",(char *) "weekday", NULL
24723 };
24724
24725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24727 if (!SWIG_IsOK(res1)) {
24728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24729 }
24730 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24731 ecode2 = SWIG_AsVal_int(obj1, &val2);
24732 if (!SWIG_IsOK(ecode2)) {
24733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24734 }
24735 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24736 {
24737 PyThreadState* __tstate = wxPyBeginAllowThreads();
24738 result = (arg1)->GetPrevWeekDay(arg2);
24739 wxPyEndAllowThreads(__tstate);
24740 if (PyErr_Occurred()) SWIG_fail;
24741 }
24742 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24743 return resultobj;
24744 fail:
24745 return NULL;
24746 }
24747
24748
24749 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24750 PyObject *resultobj = 0;
24751 wxDateTime *arg1 = (wxDateTime *) 0 ;
24752 wxDateTime::WeekDay arg2 ;
24753 int arg3 = (int) 1 ;
24754 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24755 int arg5 = (int) wxDateTime::Inv_Year ;
24756 bool result;
24757 void *argp1 = 0 ;
24758 int res1 = 0 ;
24759 int val2 ;
24760 int ecode2 = 0 ;
24761 int val3 ;
24762 int ecode3 = 0 ;
24763 int val4 ;
24764 int ecode4 = 0 ;
24765 int val5 ;
24766 int ecode5 = 0 ;
24767 PyObject * obj0 = 0 ;
24768 PyObject * obj1 = 0 ;
24769 PyObject * obj2 = 0 ;
24770 PyObject * obj3 = 0 ;
24771 PyObject * obj4 = 0 ;
24772 char * kwnames[] = {
24773 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
24774 };
24775
24776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24778 if (!SWIG_IsOK(res1)) {
24779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24780 }
24781 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24782 ecode2 = SWIG_AsVal_int(obj1, &val2);
24783 if (!SWIG_IsOK(ecode2)) {
24784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24785 }
24786 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24787 if (obj2) {
24788 ecode3 = SWIG_AsVal_int(obj2, &val3);
24789 if (!SWIG_IsOK(ecode3)) {
24790 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
24791 }
24792 arg3 = static_cast< int >(val3);
24793 }
24794 if (obj3) {
24795 ecode4 = SWIG_AsVal_int(obj3, &val4);
24796 if (!SWIG_IsOK(ecode4)) {
24797 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
24798 }
24799 arg4 = static_cast< wxDateTime::Month >(val4);
24800 }
24801 if (obj4) {
24802 ecode5 = SWIG_AsVal_int(obj4, &val5);
24803 if (!SWIG_IsOK(ecode5)) {
24804 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
24805 }
24806 arg5 = static_cast< int >(val5);
24807 }
24808 {
24809 PyThreadState* __tstate = wxPyBeginAllowThreads();
24810 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
24811 wxPyEndAllowThreads(__tstate);
24812 if (PyErr_Occurred()) SWIG_fail;
24813 }
24814 {
24815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24816 }
24817 return resultobj;
24818 fail:
24819 return NULL;
24820 }
24821
24822
24823 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24824 PyObject *resultobj = 0;
24825 wxDateTime *arg1 = (wxDateTime *) 0 ;
24826 wxDateTime::WeekDay arg2 ;
24827 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24828 int arg4 = (int) wxDateTime::Inv_Year ;
24829 bool result;
24830 void *argp1 = 0 ;
24831 int res1 = 0 ;
24832 int val2 ;
24833 int ecode2 = 0 ;
24834 int val3 ;
24835 int ecode3 = 0 ;
24836 int val4 ;
24837 int ecode4 = 0 ;
24838 PyObject * obj0 = 0 ;
24839 PyObject * obj1 = 0 ;
24840 PyObject * obj2 = 0 ;
24841 PyObject * obj3 = 0 ;
24842 char * kwnames[] = {
24843 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
24844 };
24845
24846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24848 if (!SWIG_IsOK(res1)) {
24849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24850 }
24851 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24852 ecode2 = SWIG_AsVal_int(obj1, &val2);
24853 if (!SWIG_IsOK(ecode2)) {
24854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24855 }
24856 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24857 if (obj2) {
24858 ecode3 = SWIG_AsVal_int(obj2, &val3);
24859 if (!SWIG_IsOK(ecode3)) {
24860 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24861 }
24862 arg3 = static_cast< wxDateTime::Month >(val3);
24863 }
24864 if (obj3) {
24865 ecode4 = SWIG_AsVal_int(obj3, &val4);
24866 if (!SWIG_IsOK(ecode4)) {
24867 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
24868 }
24869 arg4 = static_cast< int >(val4);
24870 }
24871 {
24872 PyThreadState* __tstate = wxPyBeginAllowThreads();
24873 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
24874 wxPyEndAllowThreads(__tstate);
24875 if (PyErr_Occurred()) SWIG_fail;
24876 }
24877 {
24878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24879 }
24880 return resultobj;
24881 fail:
24882 return NULL;
24883 }
24884
24885
24886 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24887 PyObject *resultobj = 0;
24888 wxDateTime *arg1 = (wxDateTime *) 0 ;
24889 wxDateTime::WeekDay arg2 ;
24890 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24891 int arg4 = (int) wxDateTime::Inv_Year ;
24892 wxDateTime result;
24893 void *argp1 = 0 ;
24894 int res1 = 0 ;
24895 int val2 ;
24896 int ecode2 = 0 ;
24897 int val3 ;
24898 int ecode3 = 0 ;
24899 int val4 ;
24900 int ecode4 = 0 ;
24901 PyObject * obj0 = 0 ;
24902 PyObject * obj1 = 0 ;
24903 PyObject * obj2 = 0 ;
24904 PyObject * obj3 = 0 ;
24905 char * kwnames[] = {
24906 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
24907 };
24908
24909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24911 if (!SWIG_IsOK(res1)) {
24912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24913 }
24914 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24915 ecode2 = SWIG_AsVal_int(obj1, &val2);
24916 if (!SWIG_IsOK(ecode2)) {
24917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24918 }
24919 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24920 if (obj2) {
24921 ecode3 = SWIG_AsVal_int(obj2, &val3);
24922 if (!SWIG_IsOK(ecode3)) {
24923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24924 }
24925 arg3 = static_cast< wxDateTime::Month >(val3);
24926 }
24927 if (obj3) {
24928 ecode4 = SWIG_AsVal_int(obj3, &val4);
24929 if (!SWIG_IsOK(ecode4)) {
24930 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
24931 }
24932 arg4 = static_cast< int >(val4);
24933 }
24934 {
24935 PyThreadState* __tstate = wxPyBeginAllowThreads();
24936 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
24937 wxPyEndAllowThreads(__tstate);
24938 if (PyErr_Occurred()) SWIG_fail;
24939 }
24940 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24941 return resultobj;
24942 fail:
24943 return NULL;
24944 }
24945
24946
24947 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24948 PyObject *resultobj = 0;
24949 wxDateTime *arg1 = (wxDateTime *) 0 ;
24950 int arg2 ;
24951 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24952 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24953 bool result;
24954 void *argp1 = 0 ;
24955 int res1 = 0 ;
24956 int val2 ;
24957 int ecode2 = 0 ;
24958 int val3 ;
24959 int ecode3 = 0 ;
24960 int val4 ;
24961 int ecode4 = 0 ;
24962 PyObject * obj0 = 0 ;
24963 PyObject * obj1 = 0 ;
24964 PyObject * obj2 = 0 ;
24965 PyObject * obj3 = 0 ;
24966 char * kwnames[] = {
24967 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24968 };
24969
24970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24972 if (!SWIG_IsOK(res1)) {
24973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24974 }
24975 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24976 ecode2 = SWIG_AsVal_int(obj1, &val2);
24977 if (!SWIG_IsOK(ecode2)) {
24978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
24979 }
24980 arg2 = static_cast< int >(val2);
24981 if (obj2) {
24982 ecode3 = SWIG_AsVal_int(obj2, &val3);
24983 if (!SWIG_IsOK(ecode3)) {
24984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24985 }
24986 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24987 }
24988 if (obj3) {
24989 ecode4 = SWIG_AsVal_int(obj3, &val4);
24990 if (!SWIG_IsOK(ecode4)) {
24991 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
24992 }
24993 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
24994 }
24995 {
24996 PyThreadState* __tstate = wxPyBeginAllowThreads();
24997 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
24998 wxPyEndAllowThreads(__tstate);
24999 if (PyErr_Occurred()) SWIG_fail;
25000 }
25001 {
25002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25003 }
25004 return resultobj;
25005 fail:
25006 return NULL;
25007 }
25008
25009
25010 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25011 PyObject *resultobj = 0;
25012 wxDateTime *arg1 = (wxDateTime *) 0 ;
25013 int arg2 ;
25014 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25015 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25016 wxDateTime result;
25017 void *argp1 = 0 ;
25018 int res1 = 0 ;
25019 int val2 ;
25020 int ecode2 = 0 ;
25021 int val3 ;
25022 int ecode3 = 0 ;
25023 int val4 ;
25024 int ecode4 = 0 ;
25025 PyObject * obj0 = 0 ;
25026 PyObject * obj1 = 0 ;
25027 PyObject * obj2 = 0 ;
25028 PyObject * obj3 = 0 ;
25029 char * kwnames[] = {
25030 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25031 };
25032
25033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25035 if (!SWIG_IsOK(res1)) {
25036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25037 }
25038 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25039 ecode2 = SWIG_AsVal_int(obj1, &val2);
25040 if (!SWIG_IsOK(ecode2)) {
25041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25042 }
25043 arg2 = static_cast< int >(val2);
25044 if (obj2) {
25045 ecode3 = SWIG_AsVal_int(obj2, &val3);
25046 if (!SWIG_IsOK(ecode3)) {
25047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25048 }
25049 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25050 }
25051 if (obj3) {
25052 ecode4 = SWIG_AsVal_int(obj3, &val4);
25053 if (!SWIG_IsOK(ecode4)) {
25054 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25055 }
25056 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25057 }
25058 {
25059 PyThreadState* __tstate = wxPyBeginAllowThreads();
25060 result = (arg1)->GetWeek(arg2,arg3,arg4);
25061 wxPyEndAllowThreads(__tstate);
25062 if (PyErr_Occurred()) SWIG_fail;
25063 }
25064 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25065 return resultobj;
25066 fail:
25067 return NULL;
25068 }
25069
25070
25071 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25072 PyObject *resultobj = 0;
25073 int arg1 ;
25074 int arg2 ;
25075 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25076 wxDateTime result;
25077 int val1 ;
25078 int ecode1 = 0 ;
25079 int val2 ;
25080 int ecode2 = 0 ;
25081 int val3 ;
25082 int ecode3 = 0 ;
25083 PyObject * obj0 = 0 ;
25084 PyObject * obj1 = 0 ;
25085 PyObject * obj2 = 0 ;
25086 char * kwnames[] = {
25087 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25088 };
25089
25090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25091 ecode1 = SWIG_AsVal_int(obj0, &val1);
25092 if (!SWIG_IsOK(ecode1)) {
25093 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25094 }
25095 arg1 = static_cast< int >(val1);
25096 ecode2 = SWIG_AsVal_int(obj1, &val2);
25097 if (!SWIG_IsOK(ecode2)) {
25098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25099 }
25100 arg2 = static_cast< int >(val2);
25101 if (obj2) {
25102 ecode3 = SWIG_AsVal_int(obj2, &val3);
25103 if (!SWIG_IsOK(ecode3)) {
25104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25105 }
25106 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25107 }
25108 {
25109 PyThreadState* __tstate = wxPyBeginAllowThreads();
25110 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25111 wxPyEndAllowThreads(__tstate);
25112 if (PyErr_Occurred()) SWIG_fail;
25113 }
25114 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25115 return resultobj;
25116 fail:
25117 return NULL;
25118 }
25119
25120
25121 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25122 PyObject *resultobj = 0;
25123 wxDateTime *arg1 = (wxDateTime *) 0 ;
25124 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25125 int arg3 = (int) wxDateTime::Inv_Year ;
25126 wxDateTime *result = 0 ;
25127 void *argp1 = 0 ;
25128 int res1 = 0 ;
25129 int val2 ;
25130 int ecode2 = 0 ;
25131 int val3 ;
25132 int ecode3 = 0 ;
25133 PyObject * obj0 = 0 ;
25134 PyObject * obj1 = 0 ;
25135 PyObject * obj2 = 0 ;
25136 char * kwnames[] = {
25137 (char *) "self",(char *) "month",(char *) "year", NULL
25138 };
25139
25140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25142 if (!SWIG_IsOK(res1)) {
25143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25144 }
25145 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25146 if (obj1) {
25147 ecode2 = SWIG_AsVal_int(obj1, &val2);
25148 if (!SWIG_IsOK(ecode2)) {
25149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25150 }
25151 arg2 = static_cast< wxDateTime::Month >(val2);
25152 }
25153 if (obj2) {
25154 ecode3 = SWIG_AsVal_int(obj2, &val3);
25155 if (!SWIG_IsOK(ecode3)) {
25156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25157 }
25158 arg3 = static_cast< int >(val3);
25159 }
25160 {
25161 PyThreadState* __tstate = wxPyBeginAllowThreads();
25162 {
25163 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25164 result = (wxDateTime *) &_result_ref;
25165 }
25166 wxPyEndAllowThreads(__tstate);
25167 if (PyErr_Occurred()) SWIG_fail;
25168 }
25169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25170 return resultobj;
25171 fail:
25172 return NULL;
25173 }
25174
25175
25176 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25177 PyObject *resultobj = 0;
25178 wxDateTime *arg1 = (wxDateTime *) 0 ;
25179 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25180 int arg3 = (int) wxDateTime::Inv_Year ;
25181 wxDateTime result;
25182 void *argp1 = 0 ;
25183 int res1 = 0 ;
25184 int val2 ;
25185 int ecode2 = 0 ;
25186 int val3 ;
25187 int ecode3 = 0 ;
25188 PyObject * obj0 = 0 ;
25189 PyObject * obj1 = 0 ;
25190 PyObject * obj2 = 0 ;
25191 char * kwnames[] = {
25192 (char *) "self",(char *) "month",(char *) "year", NULL
25193 };
25194
25195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25197 if (!SWIG_IsOK(res1)) {
25198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25199 }
25200 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25201 if (obj1) {
25202 ecode2 = SWIG_AsVal_int(obj1, &val2);
25203 if (!SWIG_IsOK(ecode2)) {
25204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25205 }
25206 arg2 = static_cast< wxDateTime::Month >(val2);
25207 }
25208 if (obj2) {
25209 ecode3 = SWIG_AsVal_int(obj2, &val3);
25210 if (!SWIG_IsOK(ecode3)) {
25211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25212 }
25213 arg3 = static_cast< int >(val3);
25214 }
25215 {
25216 PyThreadState* __tstate = wxPyBeginAllowThreads();
25217 result = (arg1)->GetLastMonthDay(arg2,arg3);
25218 wxPyEndAllowThreads(__tstate);
25219 if (PyErr_Occurred()) SWIG_fail;
25220 }
25221 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25222 return resultobj;
25223 fail:
25224 return NULL;
25225 }
25226
25227
25228 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25229 PyObject *resultobj = 0;
25230 wxDateTime *arg1 = (wxDateTime *) 0 ;
25231 int arg2 ;
25232 wxDateTime *result = 0 ;
25233 void *argp1 = 0 ;
25234 int res1 = 0 ;
25235 int val2 ;
25236 int ecode2 = 0 ;
25237 PyObject * obj0 = 0 ;
25238 PyObject * obj1 = 0 ;
25239 char * kwnames[] = {
25240 (char *) "self",(char *) "yday", NULL
25241 };
25242
25243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25245 if (!SWIG_IsOK(res1)) {
25246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25247 }
25248 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25249 ecode2 = SWIG_AsVal_int(obj1, &val2);
25250 if (!SWIG_IsOK(ecode2)) {
25251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25252 }
25253 arg2 = static_cast< int >(val2);
25254 {
25255 PyThreadState* __tstate = wxPyBeginAllowThreads();
25256 {
25257 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25258 result = (wxDateTime *) &_result_ref;
25259 }
25260 wxPyEndAllowThreads(__tstate);
25261 if (PyErr_Occurred()) SWIG_fail;
25262 }
25263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25264 return resultobj;
25265 fail:
25266 return NULL;
25267 }
25268
25269
25270 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25271 PyObject *resultobj = 0;
25272 wxDateTime *arg1 = (wxDateTime *) 0 ;
25273 int arg2 ;
25274 wxDateTime result;
25275 void *argp1 = 0 ;
25276 int res1 = 0 ;
25277 int val2 ;
25278 int ecode2 = 0 ;
25279 PyObject * obj0 = 0 ;
25280 PyObject * obj1 = 0 ;
25281 char * kwnames[] = {
25282 (char *) "self",(char *) "yday", NULL
25283 };
25284
25285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) 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_GetYearDay" "', 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_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25294 }
25295 arg2 = static_cast< int >(val2);
25296 {
25297 PyThreadState* __tstate = wxPyBeginAllowThreads();
25298 result = (arg1)->GetYearDay(arg2);
25299 wxPyEndAllowThreads(__tstate);
25300 if (PyErr_Occurred()) SWIG_fail;
25301 }
25302 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25303 return resultobj;
25304 fail:
25305 return NULL;
25306 }
25307
25308
25309 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25310 PyObject *resultobj = 0;
25311 wxDateTime *arg1 = (wxDateTime *) 0 ;
25312 double result;
25313 void *argp1 = 0 ;
25314 int res1 = 0 ;
25315 PyObject *swig_obj[1] ;
25316
25317 if (!args) SWIG_fail;
25318 swig_obj[0] = args;
25319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25320 if (!SWIG_IsOK(res1)) {
25321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25322 }
25323 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25324 {
25325 PyThreadState* __tstate = wxPyBeginAllowThreads();
25326 result = (double)(arg1)->GetJulianDayNumber();
25327 wxPyEndAllowThreads(__tstate);
25328 if (PyErr_Occurred()) SWIG_fail;
25329 }
25330 resultobj = SWIG_From_double(static_cast< double >(result));
25331 return resultobj;
25332 fail:
25333 return NULL;
25334 }
25335
25336
25337 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25338 PyObject *resultobj = 0;
25339 wxDateTime *arg1 = (wxDateTime *) 0 ;
25340 double result;
25341 void *argp1 = 0 ;
25342 int res1 = 0 ;
25343 PyObject *swig_obj[1] ;
25344
25345 if (!args) SWIG_fail;
25346 swig_obj[0] = args;
25347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25348 if (!SWIG_IsOK(res1)) {
25349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25350 }
25351 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25352 {
25353 PyThreadState* __tstate = wxPyBeginAllowThreads();
25354 result = (double)(arg1)->GetJDN();
25355 wxPyEndAllowThreads(__tstate);
25356 if (PyErr_Occurred()) SWIG_fail;
25357 }
25358 resultobj = SWIG_From_double(static_cast< double >(result));
25359 return resultobj;
25360 fail:
25361 return NULL;
25362 }
25363
25364
25365 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25366 PyObject *resultobj = 0;
25367 wxDateTime *arg1 = (wxDateTime *) 0 ;
25368 double result;
25369 void *argp1 = 0 ;
25370 int res1 = 0 ;
25371 PyObject *swig_obj[1] ;
25372
25373 if (!args) SWIG_fail;
25374 swig_obj[0] = args;
25375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25376 if (!SWIG_IsOK(res1)) {
25377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25378 }
25379 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25380 {
25381 PyThreadState* __tstate = wxPyBeginAllowThreads();
25382 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25383 wxPyEndAllowThreads(__tstate);
25384 if (PyErr_Occurred()) SWIG_fail;
25385 }
25386 resultobj = SWIG_From_double(static_cast< double >(result));
25387 return resultobj;
25388 fail:
25389 return NULL;
25390 }
25391
25392
25393 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25394 PyObject *resultobj = 0;
25395 wxDateTime *arg1 = (wxDateTime *) 0 ;
25396 double result;
25397 void *argp1 = 0 ;
25398 int res1 = 0 ;
25399 PyObject *swig_obj[1] ;
25400
25401 if (!args) SWIG_fail;
25402 swig_obj[0] = args;
25403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25404 if (!SWIG_IsOK(res1)) {
25405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25406 }
25407 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25408 {
25409 PyThreadState* __tstate = wxPyBeginAllowThreads();
25410 result = (double)(arg1)->GetMJD();
25411 wxPyEndAllowThreads(__tstate);
25412 if (PyErr_Occurred()) SWIG_fail;
25413 }
25414 resultobj = SWIG_From_double(static_cast< double >(result));
25415 return resultobj;
25416 fail:
25417 return NULL;
25418 }
25419
25420
25421 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25422 PyObject *resultobj = 0;
25423 wxDateTime *arg1 = (wxDateTime *) 0 ;
25424 double result;
25425 void *argp1 = 0 ;
25426 int res1 = 0 ;
25427 PyObject *swig_obj[1] ;
25428
25429 if (!args) SWIG_fail;
25430 swig_obj[0] = args;
25431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25432 if (!SWIG_IsOK(res1)) {
25433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25434 }
25435 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25436 {
25437 PyThreadState* __tstate = wxPyBeginAllowThreads();
25438 result = (double)(arg1)->GetRataDie();
25439 wxPyEndAllowThreads(__tstate);
25440 if (PyErr_Occurred()) SWIG_fail;
25441 }
25442 resultobj = SWIG_From_double(static_cast< double >(result));
25443 return resultobj;
25444 fail:
25445 return NULL;
25446 }
25447
25448
25449 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25450 PyObject *resultobj = 0;
25451 wxDateTime *arg1 = (wxDateTime *) 0 ;
25452 wxDateTime::TimeZone *arg2 = 0 ;
25453 bool arg3 = (bool) false ;
25454 wxDateTime result;
25455 void *argp1 = 0 ;
25456 int res1 = 0 ;
25457 bool temp2 = false ;
25458 bool val3 ;
25459 int ecode3 = 0 ;
25460 PyObject * obj0 = 0 ;
25461 PyObject * obj1 = 0 ;
25462 PyObject * obj2 = 0 ;
25463 char * kwnames[] = {
25464 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25465 };
25466
25467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25469 if (!SWIG_IsOK(res1)) {
25470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25471 }
25472 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25473 {
25474 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25475 temp2 = true;
25476 }
25477 if (obj2) {
25478 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25479 if (!SWIG_IsOK(ecode3)) {
25480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25481 }
25482 arg3 = static_cast< bool >(val3);
25483 }
25484 {
25485 PyThreadState* __tstate = wxPyBeginAllowThreads();
25486 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25487 wxPyEndAllowThreads(__tstate);
25488 if (PyErr_Occurred()) SWIG_fail;
25489 }
25490 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25491 {
25492 if (temp2) delete arg2;
25493 }
25494 return resultobj;
25495 fail:
25496 {
25497 if (temp2) delete arg2;
25498 }
25499 return NULL;
25500 }
25501
25502
25503 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25504 PyObject *resultobj = 0;
25505 wxDateTime *arg1 = (wxDateTime *) 0 ;
25506 wxDateTime::TimeZone *arg2 = 0 ;
25507 bool arg3 = (bool) false ;
25508 wxDateTime *result = 0 ;
25509 void *argp1 = 0 ;
25510 int res1 = 0 ;
25511 bool temp2 = false ;
25512 bool val3 ;
25513 int ecode3 = 0 ;
25514 PyObject * obj0 = 0 ;
25515 PyObject * obj1 = 0 ;
25516 PyObject * obj2 = 0 ;
25517 char * kwnames[] = {
25518 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25519 };
25520
25521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25523 if (!SWIG_IsOK(res1)) {
25524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25525 }
25526 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25527 {
25528 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25529 temp2 = true;
25530 }
25531 if (obj2) {
25532 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25533 if (!SWIG_IsOK(ecode3)) {
25534 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25535 }
25536 arg3 = static_cast< bool >(val3);
25537 }
25538 {
25539 PyThreadState* __tstate = wxPyBeginAllowThreads();
25540 {
25541 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25542 result = (wxDateTime *) &_result_ref;
25543 }
25544 wxPyEndAllowThreads(__tstate);
25545 if (PyErr_Occurred()) SWIG_fail;
25546 }
25547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25548 {
25549 if (temp2) delete arg2;
25550 }
25551 return resultobj;
25552 fail:
25553 {
25554 if (temp2) delete arg2;
25555 }
25556 return NULL;
25557 }
25558
25559
25560 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25561 PyObject *resultobj = 0;
25562 wxDateTime *arg1 = (wxDateTime *) 0 ;
25563 wxDateTime::TimeZone *arg2 = 0 ;
25564 bool arg3 = (bool) false ;
25565 wxDateTime result;
25566 void *argp1 = 0 ;
25567 int res1 = 0 ;
25568 bool temp2 = false ;
25569 bool val3 ;
25570 int ecode3 = 0 ;
25571 PyObject * obj0 = 0 ;
25572 PyObject * obj1 = 0 ;
25573 PyObject * obj2 = 0 ;
25574 char * kwnames[] = {
25575 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25576 };
25577
25578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25580 if (!SWIG_IsOK(res1)) {
25581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25582 }
25583 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25584 {
25585 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25586 temp2 = true;
25587 }
25588 if (obj2) {
25589 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25590 if (!SWIG_IsOK(ecode3)) {
25591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25592 }
25593 arg3 = static_cast< bool >(val3);
25594 }
25595 {
25596 PyThreadState* __tstate = wxPyBeginAllowThreads();
25597 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25598 wxPyEndAllowThreads(__tstate);
25599 if (PyErr_Occurred()) SWIG_fail;
25600 }
25601 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25602 {
25603 if (temp2) delete arg2;
25604 }
25605 return resultobj;
25606 fail:
25607 {
25608 if (temp2) delete arg2;
25609 }
25610 return NULL;
25611 }
25612
25613
25614 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25615 PyObject *resultobj = 0;
25616 wxDateTime *arg1 = (wxDateTime *) 0 ;
25617 wxDateTime::TimeZone *arg2 = 0 ;
25618 bool arg3 = (bool) false ;
25619 wxDateTime *result = 0 ;
25620 void *argp1 = 0 ;
25621 int res1 = 0 ;
25622 bool temp2 = false ;
25623 bool val3 ;
25624 int ecode3 = 0 ;
25625 PyObject * obj0 = 0 ;
25626 PyObject * obj1 = 0 ;
25627 PyObject * obj2 = 0 ;
25628 char * kwnames[] = {
25629 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25630 };
25631
25632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25634 if (!SWIG_IsOK(res1)) {
25635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25636 }
25637 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25638 {
25639 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25640 temp2 = true;
25641 }
25642 if (obj2) {
25643 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25644 if (!SWIG_IsOK(ecode3)) {
25645 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25646 }
25647 arg3 = static_cast< bool >(val3);
25648 }
25649 {
25650 PyThreadState* __tstate = wxPyBeginAllowThreads();
25651 {
25652 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25653 result = (wxDateTime *) &_result_ref;
25654 }
25655 wxPyEndAllowThreads(__tstate);
25656 if (PyErr_Occurred()) SWIG_fail;
25657 }
25658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25659 {
25660 if (temp2) delete arg2;
25661 }
25662 return resultobj;
25663 fail:
25664 {
25665 if (temp2) delete arg2;
25666 }
25667 return NULL;
25668 }
25669
25670
25671 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25672 PyObject *resultobj = 0;
25673 wxDateTime *arg1 = (wxDateTime *) 0 ;
25674 bool arg2 = (bool) false ;
25675 wxDateTime result;
25676 void *argp1 = 0 ;
25677 int res1 = 0 ;
25678 bool val2 ;
25679 int ecode2 = 0 ;
25680 PyObject * obj0 = 0 ;
25681 PyObject * obj1 = 0 ;
25682 char * kwnames[] = {
25683 (char *) "self",(char *) "noDST", NULL
25684 };
25685
25686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25688 if (!SWIG_IsOK(res1)) {
25689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25690 }
25691 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25692 if (obj1) {
25693 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25694 if (!SWIG_IsOK(ecode2)) {
25695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25696 }
25697 arg2 = static_cast< bool >(val2);
25698 }
25699 {
25700 PyThreadState* __tstate = wxPyBeginAllowThreads();
25701 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25702 wxPyEndAllowThreads(__tstate);
25703 if (PyErr_Occurred()) SWIG_fail;
25704 }
25705 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25706 return resultobj;
25707 fail:
25708 return NULL;
25709 }
25710
25711
25712 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25713 PyObject *resultobj = 0;
25714 wxDateTime *arg1 = (wxDateTime *) 0 ;
25715 bool arg2 = (bool) false ;
25716 wxDateTime *result = 0 ;
25717 void *argp1 = 0 ;
25718 int res1 = 0 ;
25719 bool val2 ;
25720 int ecode2 = 0 ;
25721 PyObject * obj0 = 0 ;
25722 PyObject * obj1 = 0 ;
25723 char * kwnames[] = {
25724 (char *) "self",(char *) "noDST", NULL
25725 };
25726
25727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25729 if (!SWIG_IsOK(res1)) {
25730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25731 }
25732 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25733 if (obj1) {
25734 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25735 if (!SWIG_IsOK(ecode2)) {
25736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25737 }
25738 arg2 = static_cast< bool >(val2);
25739 }
25740 {
25741 PyThreadState* __tstate = wxPyBeginAllowThreads();
25742 {
25743 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25744 result = (wxDateTime *) &_result_ref;
25745 }
25746 wxPyEndAllowThreads(__tstate);
25747 if (PyErr_Occurred()) SWIG_fail;
25748 }
25749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25750 return resultobj;
25751 fail:
25752 return NULL;
25753 }
25754
25755
25756 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25757 PyObject *resultobj = 0;
25758 wxDateTime *arg1 = (wxDateTime *) 0 ;
25759 bool arg2 = (bool) false ;
25760 wxDateTime result;
25761 void *argp1 = 0 ;
25762 int res1 = 0 ;
25763 bool val2 ;
25764 int ecode2 = 0 ;
25765 PyObject * obj0 = 0 ;
25766 PyObject * obj1 = 0 ;
25767 char * kwnames[] = {
25768 (char *) "self",(char *) "noDST", NULL
25769 };
25770
25771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25773 if (!SWIG_IsOK(res1)) {
25774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25775 }
25776 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25777 if (obj1) {
25778 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25779 if (!SWIG_IsOK(ecode2)) {
25780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
25781 }
25782 arg2 = static_cast< bool >(val2);
25783 }
25784 {
25785 PyThreadState* __tstate = wxPyBeginAllowThreads();
25786 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
25787 wxPyEndAllowThreads(__tstate);
25788 if (PyErr_Occurred()) SWIG_fail;
25789 }
25790 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25791 return resultobj;
25792 fail:
25793 return NULL;
25794 }
25795
25796
25797 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25798 PyObject *resultobj = 0;
25799 wxDateTime *arg1 = (wxDateTime *) 0 ;
25800 bool arg2 = (bool) false ;
25801 wxDateTime *result = 0 ;
25802 void *argp1 = 0 ;
25803 int res1 = 0 ;
25804 bool val2 ;
25805 int ecode2 = 0 ;
25806 PyObject * obj0 = 0 ;
25807 PyObject * obj1 = 0 ;
25808 char * kwnames[] = {
25809 (char *) "self",(char *) "noDST", NULL
25810 };
25811
25812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25814 if (!SWIG_IsOK(res1)) {
25815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
25816 }
25817 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25818 if (obj1) {
25819 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25820 if (!SWIG_IsOK(ecode2)) {
25821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
25822 }
25823 arg2 = static_cast< bool >(val2);
25824 }
25825 {
25826 PyThreadState* __tstate = wxPyBeginAllowThreads();
25827 {
25828 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
25829 result = (wxDateTime *) &_result_ref;
25830 }
25831 wxPyEndAllowThreads(__tstate);
25832 if (PyErr_Occurred()) SWIG_fail;
25833 }
25834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25835 return resultobj;
25836 fail:
25837 return NULL;
25838 }
25839
25840
25841 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25842 PyObject *resultobj = 0;
25843 wxDateTime *arg1 = (wxDateTime *) 0 ;
25844 bool arg2 = (bool) false ;
25845 wxDateTime result;
25846 void *argp1 = 0 ;
25847 int res1 = 0 ;
25848 bool val2 ;
25849 int ecode2 = 0 ;
25850 PyObject * obj0 = 0 ;
25851 PyObject * obj1 = 0 ;
25852 char * kwnames[] = {
25853 (char *) "self",(char *) "noDST", NULL
25854 };
25855
25856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25858 if (!SWIG_IsOK(res1)) {
25859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25860 }
25861 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25862 if (obj1) {
25863 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25864 if (!SWIG_IsOK(ecode2)) {
25865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
25866 }
25867 arg2 = static_cast< bool >(val2);
25868 }
25869 {
25870 PyThreadState* __tstate = wxPyBeginAllowThreads();
25871 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
25872 wxPyEndAllowThreads(__tstate);
25873 if (PyErr_Occurred()) SWIG_fail;
25874 }
25875 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25876 return resultobj;
25877 fail:
25878 return NULL;
25879 }
25880
25881
25882 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25883 PyObject *resultobj = 0;
25884 wxDateTime *arg1 = (wxDateTime *) 0 ;
25885 bool arg2 = (bool) false ;
25886 wxDateTime *result = 0 ;
25887 void *argp1 = 0 ;
25888 int res1 = 0 ;
25889 bool val2 ;
25890 int ecode2 = 0 ;
25891 PyObject * obj0 = 0 ;
25892 PyObject * obj1 = 0 ;
25893 char * kwnames[] = {
25894 (char *) "self",(char *) "noDST", NULL
25895 };
25896
25897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25899 if (!SWIG_IsOK(res1)) {
25900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25901 }
25902 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25903 if (obj1) {
25904 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25905 if (!SWIG_IsOK(ecode2)) {
25906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
25907 }
25908 arg2 = static_cast< bool >(val2);
25909 }
25910 {
25911 PyThreadState* __tstate = wxPyBeginAllowThreads();
25912 {
25913 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
25914 result = (wxDateTime *) &_result_ref;
25915 }
25916 wxPyEndAllowThreads(__tstate);
25917 if (PyErr_Occurred()) SWIG_fail;
25918 }
25919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25920 return resultobj;
25921 fail:
25922 return NULL;
25923 }
25924
25925
25926 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25927 PyObject *resultobj = 0;
25928 wxDateTime *arg1 = (wxDateTime *) 0 ;
25929 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25930 int result;
25931 void *argp1 = 0 ;
25932 int res1 = 0 ;
25933 int val2 ;
25934 int ecode2 = 0 ;
25935 PyObject * obj0 = 0 ;
25936 PyObject * obj1 = 0 ;
25937 char * kwnames[] = {
25938 (char *) "self",(char *) "country", NULL
25939 };
25940
25941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
25942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25943 if (!SWIG_IsOK(res1)) {
25944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
25945 }
25946 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25947 if (obj1) {
25948 ecode2 = SWIG_AsVal_int(obj1, &val2);
25949 if (!SWIG_IsOK(ecode2)) {
25950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25951 }
25952 arg2 = static_cast< wxDateTime::Country >(val2);
25953 }
25954 {
25955 PyThreadState* __tstate = wxPyBeginAllowThreads();
25956 result = (int)(arg1)->IsDST(arg2);
25957 wxPyEndAllowThreads(__tstate);
25958 if (PyErr_Occurred()) SWIG_fail;
25959 }
25960 resultobj = SWIG_From_int(static_cast< int >(result));
25961 return resultobj;
25962 fail:
25963 return NULL;
25964 }
25965
25966
25967 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25968 PyObject *resultobj = 0;
25969 wxDateTime *arg1 = (wxDateTime *) 0 ;
25970 bool result;
25971 void *argp1 = 0 ;
25972 int res1 = 0 ;
25973 PyObject *swig_obj[1] ;
25974
25975 if (!args) SWIG_fail;
25976 swig_obj[0] = args;
25977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25978 if (!SWIG_IsOK(res1)) {
25979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25980 }
25981 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25982 {
25983 PyThreadState* __tstate = wxPyBeginAllowThreads();
25984 result = (bool)((wxDateTime const *)arg1)->IsValid();
25985 wxPyEndAllowThreads(__tstate);
25986 if (PyErr_Occurred()) SWIG_fail;
25987 }
25988 {
25989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25990 }
25991 return resultobj;
25992 fail:
25993 return NULL;
25994 }
25995
25996
25997 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25998 PyObject *resultobj = 0;
25999 wxDateTime *arg1 = (wxDateTime *) 0 ;
26000 time_t result;
26001 void *argp1 = 0 ;
26002 int res1 = 0 ;
26003 PyObject *swig_obj[1] ;
26004
26005 if (!args) SWIG_fail;
26006 swig_obj[0] = args;
26007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26008 if (!SWIG_IsOK(res1)) {
26009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26010 }
26011 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26012 {
26013 PyThreadState* __tstate = wxPyBeginAllowThreads();
26014 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26015 wxPyEndAllowThreads(__tstate);
26016 if (PyErr_Occurred()) SWIG_fail;
26017 }
26018 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26019 return resultobj;
26020 fail:
26021 return NULL;
26022 }
26023
26024
26025 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26026 PyObject *resultobj = 0;
26027 wxDateTime *arg1 = (wxDateTime *) 0 ;
26028 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26029 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26030 int result;
26031 void *argp1 = 0 ;
26032 int res1 = 0 ;
26033 bool temp2 = false ;
26034 PyObject * obj0 = 0 ;
26035 PyObject * obj1 = 0 ;
26036 char * kwnames[] = {
26037 (char *) "self",(char *) "tz", NULL
26038 };
26039
26040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26042 if (!SWIG_IsOK(res1)) {
26043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26044 }
26045 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26046 if (obj1) {
26047 {
26048 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26049 temp2 = true;
26050 }
26051 }
26052 {
26053 PyThreadState* __tstate = wxPyBeginAllowThreads();
26054 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26055 wxPyEndAllowThreads(__tstate);
26056 if (PyErr_Occurred()) SWIG_fail;
26057 }
26058 resultobj = SWIG_From_int(static_cast< int >(result));
26059 {
26060 if (temp2) delete arg2;
26061 }
26062 return resultobj;
26063 fail:
26064 {
26065 if (temp2) delete arg2;
26066 }
26067 return NULL;
26068 }
26069
26070
26071 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26072 PyObject *resultobj = 0;
26073 wxDateTime *arg1 = (wxDateTime *) 0 ;
26074 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26075 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26076 wxDateTime::Month result;
26077 void *argp1 = 0 ;
26078 int res1 = 0 ;
26079 bool temp2 = false ;
26080 PyObject * obj0 = 0 ;
26081 PyObject * obj1 = 0 ;
26082 char * kwnames[] = {
26083 (char *) "self",(char *) "tz", NULL
26084 };
26085
26086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26088 if (!SWIG_IsOK(res1)) {
26089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26090 }
26091 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26092 if (obj1) {
26093 {
26094 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26095 temp2 = true;
26096 }
26097 }
26098 {
26099 PyThreadState* __tstate = wxPyBeginAllowThreads();
26100 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26101 wxPyEndAllowThreads(__tstate);
26102 if (PyErr_Occurred()) SWIG_fail;
26103 }
26104 resultobj = SWIG_From_int(static_cast< int >(result));
26105 {
26106 if (temp2) delete arg2;
26107 }
26108 return resultobj;
26109 fail:
26110 {
26111 if (temp2) delete arg2;
26112 }
26113 return NULL;
26114 }
26115
26116
26117 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26118 PyObject *resultobj = 0;
26119 wxDateTime *arg1 = (wxDateTime *) 0 ;
26120 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26121 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26122 int result;
26123 void *argp1 = 0 ;
26124 int res1 = 0 ;
26125 bool temp2 = false ;
26126 PyObject * obj0 = 0 ;
26127 PyObject * obj1 = 0 ;
26128 char * kwnames[] = {
26129 (char *) "self",(char *) "tz", NULL
26130 };
26131
26132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26134 if (!SWIG_IsOK(res1)) {
26135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26136 }
26137 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26138 if (obj1) {
26139 {
26140 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26141 temp2 = true;
26142 }
26143 }
26144 {
26145 PyThreadState* __tstate = wxPyBeginAllowThreads();
26146 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26147 wxPyEndAllowThreads(__tstate);
26148 if (PyErr_Occurred()) SWIG_fail;
26149 }
26150 resultobj = SWIG_From_int(static_cast< int >(result));
26151 {
26152 if (temp2) delete arg2;
26153 }
26154 return resultobj;
26155 fail:
26156 {
26157 if (temp2) delete arg2;
26158 }
26159 return NULL;
26160 }
26161
26162
26163 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26164 PyObject *resultobj = 0;
26165 wxDateTime *arg1 = (wxDateTime *) 0 ;
26166 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26167 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26168 wxDateTime::WeekDay result;
26169 void *argp1 = 0 ;
26170 int res1 = 0 ;
26171 bool temp2 = false ;
26172 PyObject * obj0 = 0 ;
26173 PyObject * obj1 = 0 ;
26174 char * kwnames[] = {
26175 (char *) "self",(char *) "tz", NULL
26176 };
26177
26178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26180 if (!SWIG_IsOK(res1)) {
26181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26182 }
26183 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26184 if (obj1) {
26185 {
26186 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26187 temp2 = true;
26188 }
26189 }
26190 {
26191 PyThreadState* __tstate = wxPyBeginAllowThreads();
26192 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26193 wxPyEndAllowThreads(__tstate);
26194 if (PyErr_Occurred()) SWIG_fail;
26195 }
26196 resultobj = SWIG_From_int(static_cast< int >(result));
26197 {
26198 if (temp2) delete arg2;
26199 }
26200 return resultobj;
26201 fail:
26202 {
26203 if (temp2) delete arg2;
26204 }
26205 return NULL;
26206 }
26207
26208
26209 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26210 PyObject *resultobj = 0;
26211 wxDateTime *arg1 = (wxDateTime *) 0 ;
26212 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26213 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26214 int result;
26215 void *argp1 = 0 ;
26216 int res1 = 0 ;
26217 bool temp2 = false ;
26218 PyObject * obj0 = 0 ;
26219 PyObject * obj1 = 0 ;
26220 char * kwnames[] = {
26221 (char *) "self",(char *) "tz", NULL
26222 };
26223
26224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26226 if (!SWIG_IsOK(res1)) {
26227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26228 }
26229 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26230 if (obj1) {
26231 {
26232 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26233 temp2 = true;
26234 }
26235 }
26236 {
26237 PyThreadState* __tstate = wxPyBeginAllowThreads();
26238 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26239 wxPyEndAllowThreads(__tstate);
26240 if (PyErr_Occurred()) SWIG_fail;
26241 }
26242 resultobj = SWIG_From_int(static_cast< int >(result));
26243 {
26244 if (temp2) delete arg2;
26245 }
26246 return resultobj;
26247 fail:
26248 {
26249 if (temp2) delete arg2;
26250 }
26251 return NULL;
26252 }
26253
26254
26255 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26256 PyObject *resultobj = 0;
26257 wxDateTime *arg1 = (wxDateTime *) 0 ;
26258 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26259 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26260 int result;
26261 void *argp1 = 0 ;
26262 int res1 = 0 ;
26263 bool temp2 = false ;
26264 PyObject * obj0 = 0 ;
26265 PyObject * obj1 = 0 ;
26266 char * kwnames[] = {
26267 (char *) "self",(char *) "tz", NULL
26268 };
26269
26270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26272 if (!SWIG_IsOK(res1)) {
26273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26274 }
26275 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26276 if (obj1) {
26277 {
26278 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26279 temp2 = true;
26280 }
26281 }
26282 {
26283 PyThreadState* __tstate = wxPyBeginAllowThreads();
26284 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26285 wxPyEndAllowThreads(__tstate);
26286 if (PyErr_Occurred()) SWIG_fail;
26287 }
26288 resultobj = SWIG_From_int(static_cast< int >(result));
26289 {
26290 if (temp2) delete arg2;
26291 }
26292 return resultobj;
26293 fail:
26294 {
26295 if (temp2) delete arg2;
26296 }
26297 return NULL;
26298 }
26299
26300
26301 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26302 PyObject *resultobj = 0;
26303 wxDateTime *arg1 = (wxDateTime *) 0 ;
26304 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26305 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26306 int result;
26307 void *argp1 = 0 ;
26308 int res1 = 0 ;
26309 bool temp2 = false ;
26310 PyObject * obj0 = 0 ;
26311 PyObject * obj1 = 0 ;
26312 char * kwnames[] = {
26313 (char *) "self",(char *) "tz", NULL
26314 };
26315
26316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26318 if (!SWIG_IsOK(res1)) {
26319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26320 }
26321 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26322 if (obj1) {
26323 {
26324 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26325 temp2 = true;
26326 }
26327 }
26328 {
26329 PyThreadState* __tstate = wxPyBeginAllowThreads();
26330 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26331 wxPyEndAllowThreads(__tstate);
26332 if (PyErr_Occurred()) SWIG_fail;
26333 }
26334 resultobj = SWIG_From_int(static_cast< int >(result));
26335 {
26336 if (temp2) delete arg2;
26337 }
26338 return resultobj;
26339 fail:
26340 {
26341 if (temp2) delete arg2;
26342 }
26343 return NULL;
26344 }
26345
26346
26347 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26348 PyObject *resultobj = 0;
26349 wxDateTime *arg1 = (wxDateTime *) 0 ;
26350 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26351 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26352 int result;
26353 void *argp1 = 0 ;
26354 int res1 = 0 ;
26355 bool temp2 = false ;
26356 PyObject * obj0 = 0 ;
26357 PyObject * obj1 = 0 ;
26358 char * kwnames[] = {
26359 (char *) "self",(char *) "tz", NULL
26360 };
26361
26362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26364 if (!SWIG_IsOK(res1)) {
26365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26366 }
26367 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26368 if (obj1) {
26369 {
26370 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26371 temp2 = true;
26372 }
26373 }
26374 {
26375 PyThreadState* __tstate = wxPyBeginAllowThreads();
26376 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26377 wxPyEndAllowThreads(__tstate);
26378 if (PyErr_Occurred()) SWIG_fail;
26379 }
26380 resultobj = SWIG_From_int(static_cast< int >(result));
26381 {
26382 if (temp2) delete arg2;
26383 }
26384 return resultobj;
26385 fail:
26386 {
26387 if (temp2) delete arg2;
26388 }
26389 return NULL;
26390 }
26391
26392
26393 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26394 PyObject *resultobj = 0;
26395 wxDateTime *arg1 = (wxDateTime *) 0 ;
26396 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26397 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26398 int result;
26399 void *argp1 = 0 ;
26400 int res1 = 0 ;
26401 bool temp2 = false ;
26402 PyObject * obj0 = 0 ;
26403 PyObject * obj1 = 0 ;
26404 char * kwnames[] = {
26405 (char *) "self",(char *) "tz", NULL
26406 };
26407
26408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26410 if (!SWIG_IsOK(res1)) {
26411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26412 }
26413 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26414 if (obj1) {
26415 {
26416 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26417 temp2 = true;
26418 }
26419 }
26420 {
26421 PyThreadState* __tstate = wxPyBeginAllowThreads();
26422 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26423 wxPyEndAllowThreads(__tstate);
26424 if (PyErr_Occurred()) SWIG_fail;
26425 }
26426 resultobj = SWIG_From_int(static_cast< int >(result));
26427 {
26428 if (temp2) delete arg2;
26429 }
26430 return resultobj;
26431 fail:
26432 {
26433 if (temp2) delete arg2;
26434 }
26435 return NULL;
26436 }
26437
26438
26439 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26440 PyObject *resultobj = 0;
26441 wxDateTime *arg1 = (wxDateTime *) 0 ;
26442 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26443 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26444 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26445 int result;
26446 void *argp1 = 0 ;
26447 int res1 = 0 ;
26448 int val2 ;
26449 int ecode2 = 0 ;
26450 bool temp3 = false ;
26451 PyObject * obj0 = 0 ;
26452 PyObject * obj1 = 0 ;
26453 PyObject * obj2 = 0 ;
26454 char * kwnames[] = {
26455 (char *) "self",(char *) "flags",(char *) "tz", NULL
26456 };
26457
26458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26460 if (!SWIG_IsOK(res1)) {
26461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26462 }
26463 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26464 if (obj1) {
26465 ecode2 = SWIG_AsVal_int(obj1, &val2);
26466 if (!SWIG_IsOK(ecode2)) {
26467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26468 }
26469 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26470 }
26471 if (obj2) {
26472 {
26473 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26474 temp3 = true;
26475 }
26476 }
26477 {
26478 PyThreadState* __tstate = wxPyBeginAllowThreads();
26479 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26480 wxPyEndAllowThreads(__tstate);
26481 if (PyErr_Occurred()) SWIG_fail;
26482 }
26483 resultobj = SWIG_From_int(static_cast< int >(result));
26484 {
26485 if (temp3) delete arg3;
26486 }
26487 return resultobj;
26488 fail:
26489 {
26490 if (temp3) delete arg3;
26491 }
26492 return NULL;
26493 }
26494
26495
26496 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26497 PyObject *resultobj = 0;
26498 wxDateTime *arg1 = (wxDateTime *) 0 ;
26499 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26500 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26501 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26502 int result;
26503 void *argp1 = 0 ;
26504 int res1 = 0 ;
26505 int val2 ;
26506 int ecode2 = 0 ;
26507 bool temp3 = false ;
26508 PyObject * obj0 = 0 ;
26509 PyObject * obj1 = 0 ;
26510 PyObject * obj2 = 0 ;
26511 char * kwnames[] = {
26512 (char *) "self",(char *) "flags",(char *) "tz", NULL
26513 };
26514
26515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26517 if (!SWIG_IsOK(res1)) {
26518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26519 }
26520 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26521 if (obj1) {
26522 ecode2 = SWIG_AsVal_int(obj1, &val2);
26523 if (!SWIG_IsOK(ecode2)) {
26524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26525 }
26526 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26527 }
26528 if (obj2) {
26529 {
26530 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26531 temp3 = true;
26532 }
26533 }
26534 {
26535 PyThreadState* __tstate = wxPyBeginAllowThreads();
26536 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26537 wxPyEndAllowThreads(__tstate);
26538 if (PyErr_Occurred()) SWIG_fail;
26539 }
26540 resultobj = SWIG_From_int(static_cast< int >(result));
26541 {
26542 if (temp3) delete arg3;
26543 }
26544 return resultobj;
26545 fail:
26546 {
26547 if (temp3) delete arg3;
26548 }
26549 return NULL;
26550 }
26551
26552
26553 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26554 PyObject *resultobj = 0;
26555 wxDateTime *arg1 = (wxDateTime *) 0 ;
26556 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26557 bool result;
26558 void *argp1 = 0 ;
26559 int res1 = 0 ;
26560 int val2 ;
26561 int ecode2 = 0 ;
26562 PyObject * obj0 = 0 ;
26563 PyObject * obj1 = 0 ;
26564 char * kwnames[] = {
26565 (char *) "self",(char *) "country", NULL
26566 };
26567
26568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",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_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26572 }
26573 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26574 if (obj1) {
26575 ecode2 = SWIG_AsVal_int(obj1, &val2);
26576 if (!SWIG_IsOK(ecode2)) {
26577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26578 }
26579 arg2 = static_cast< wxDateTime::Country >(val2);
26580 }
26581 {
26582 PyThreadState* __tstate = wxPyBeginAllowThreads();
26583 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26584 wxPyEndAllowThreads(__tstate);
26585 if (PyErr_Occurred()) SWIG_fail;
26586 }
26587 {
26588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26589 }
26590 return resultobj;
26591 fail:
26592 return NULL;
26593 }
26594
26595
26596 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26597 PyObject *resultobj = 0;
26598 wxDateTime *arg1 = (wxDateTime *) 0 ;
26599 wxDateTime *arg2 = 0 ;
26600 bool result;
26601 void *argp1 = 0 ;
26602 int res1 = 0 ;
26603 void *argp2 = 0 ;
26604 int res2 = 0 ;
26605 PyObject * obj0 = 0 ;
26606 PyObject * obj1 = 0 ;
26607 char * kwnames[] = {
26608 (char *) "self",(char *) "datetime", NULL
26609 };
26610
26611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26613 if (!SWIG_IsOK(res1)) {
26614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26615 }
26616 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26617 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26618 if (!SWIG_IsOK(res2)) {
26619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26620 }
26621 if (!argp2) {
26622 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26623 }
26624 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26625 {
26626 PyThreadState* __tstate = wxPyBeginAllowThreads();
26627 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26628 wxPyEndAllowThreads(__tstate);
26629 if (PyErr_Occurred()) SWIG_fail;
26630 }
26631 {
26632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26633 }
26634 return resultobj;
26635 fail:
26636 return NULL;
26637 }
26638
26639
26640 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26641 PyObject *resultobj = 0;
26642 wxDateTime *arg1 = (wxDateTime *) 0 ;
26643 wxDateTime *arg2 = 0 ;
26644 bool result;
26645 void *argp1 = 0 ;
26646 int res1 = 0 ;
26647 void *argp2 = 0 ;
26648 int res2 = 0 ;
26649 PyObject * obj0 = 0 ;
26650 PyObject * obj1 = 0 ;
26651 char * kwnames[] = {
26652 (char *) "self",(char *) "datetime", NULL
26653 };
26654
26655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26657 if (!SWIG_IsOK(res1)) {
26658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26659 }
26660 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26661 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26662 if (!SWIG_IsOK(res2)) {
26663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26664 }
26665 if (!argp2) {
26666 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26667 }
26668 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26669 {
26670 PyThreadState* __tstate = wxPyBeginAllowThreads();
26671 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26672 wxPyEndAllowThreads(__tstate);
26673 if (PyErr_Occurred()) SWIG_fail;
26674 }
26675 {
26676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26677 }
26678 return resultobj;
26679 fail:
26680 return NULL;
26681 }
26682
26683
26684 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26685 PyObject *resultobj = 0;
26686 wxDateTime *arg1 = (wxDateTime *) 0 ;
26687 wxDateTime *arg2 = 0 ;
26688 bool result;
26689 void *argp1 = 0 ;
26690 int res1 = 0 ;
26691 void *argp2 = 0 ;
26692 int res2 = 0 ;
26693 PyObject * obj0 = 0 ;
26694 PyObject * obj1 = 0 ;
26695 char * kwnames[] = {
26696 (char *) "self",(char *) "datetime", NULL
26697 };
26698
26699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26701 if (!SWIG_IsOK(res1)) {
26702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26703 }
26704 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26705 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26706 if (!SWIG_IsOK(res2)) {
26707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26708 }
26709 if (!argp2) {
26710 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26711 }
26712 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26713 {
26714 PyThreadState* __tstate = wxPyBeginAllowThreads();
26715 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26716 wxPyEndAllowThreads(__tstate);
26717 if (PyErr_Occurred()) SWIG_fail;
26718 }
26719 {
26720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26721 }
26722 return resultobj;
26723 fail:
26724 return NULL;
26725 }
26726
26727
26728 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26729 PyObject *resultobj = 0;
26730 wxDateTime *arg1 = (wxDateTime *) 0 ;
26731 wxDateTime *arg2 = 0 ;
26732 wxDateTime *arg3 = 0 ;
26733 bool result;
26734 void *argp1 = 0 ;
26735 int res1 = 0 ;
26736 void *argp2 = 0 ;
26737 int res2 = 0 ;
26738 void *argp3 = 0 ;
26739 int res3 = 0 ;
26740 PyObject * obj0 = 0 ;
26741 PyObject * obj1 = 0 ;
26742 PyObject * obj2 = 0 ;
26743 char * kwnames[] = {
26744 (char *) "self",(char *) "t1",(char *) "t2", NULL
26745 };
26746
26747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26749 if (!SWIG_IsOK(res1)) {
26750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26751 }
26752 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26753 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26754 if (!SWIG_IsOK(res2)) {
26755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26756 }
26757 if (!argp2) {
26758 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26759 }
26760 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26761 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26762 if (!SWIG_IsOK(res3)) {
26763 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26764 }
26765 if (!argp3) {
26766 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26767 }
26768 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26769 {
26770 PyThreadState* __tstate = wxPyBeginAllowThreads();
26771 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26772 wxPyEndAllowThreads(__tstate);
26773 if (PyErr_Occurred()) SWIG_fail;
26774 }
26775 {
26776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26777 }
26778 return resultobj;
26779 fail:
26780 return NULL;
26781 }
26782
26783
26784 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26785 PyObject *resultobj = 0;
26786 wxDateTime *arg1 = (wxDateTime *) 0 ;
26787 wxDateTime *arg2 = 0 ;
26788 wxDateTime *arg3 = 0 ;
26789 bool result;
26790 void *argp1 = 0 ;
26791 int res1 = 0 ;
26792 void *argp2 = 0 ;
26793 int res2 = 0 ;
26794 void *argp3 = 0 ;
26795 int res3 = 0 ;
26796 PyObject * obj0 = 0 ;
26797 PyObject * obj1 = 0 ;
26798 PyObject * obj2 = 0 ;
26799 char * kwnames[] = {
26800 (char *) "self",(char *) "t1",(char *) "t2", NULL
26801 };
26802
26803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26805 if (!SWIG_IsOK(res1)) {
26806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26807 }
26808 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26809 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26810 if (!SWIG_IsOK(res2)) {
26811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26812 }
26813 if (!argp2) {
26814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26815 }
26816 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26817 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26818 if (!SWIG_IsOK(res3)) {
26819 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26820 }
26821 if (!argp3) {
26822 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26823 }
26824 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26825 {
26826 PyThreadState* __tstate = wxPyBeginAllowThreads();
26827 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26828 wxPyEndAllowThreads(__tstate);
26829 if (PyErr_Occurred()) SWIG_fail;
26830 }
26831 {
26832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26833 }
26834 return resultobj;
26835 fail:
26836 return NULL;
26837 }
26838
26839
26840 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26841 PyObject *resultobj = 0;
26842 wxDateTime *arg1 = (wxDateTime *) 0 ;
26843 wxDateTime *arg2 = 0 ;
26844 bool result;
26845 void *argp1 = 0 ;
26846 int res1 = 0 ;
26847 void *argp2 = 0 ;
26848 int res2 = 0 ;
26849 PyObject * obj0 = 0 ;
26850 PyObject * obj1 = 0 ;
26851 char * kwnames[] = {
26852 (char *) "self",(char *) "dt", NULL
26853 };
26854
26855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
26856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26857 if (!SWIG_IsOK(res1)) {
26858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26859 }
26860 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26861 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26862 if (!SWIG_IsOK(res2)) {
26863 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26864 }
26865 if (!argp2) {
26866 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26867 }
26868 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26869 {
26870 PyThreadState* __tstate = wxPyBeginAllowThreads();
26871 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
26872 wxPyEndAllowThreads(__tstate);
26873 if (PyErr_Occurred()) SWIG_fail;
26874 }
26875 {
26876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26877 }
26878 return resultobj;
26879 fail:
26880 return NULL;
26881 }
26882
26883
26884 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26885 PyObject *resultobj = 0;
26886 wxDateTime *arg1 = (wxDateTime *) 0 ;
26887 wxDateTime *arg2 = 0 ;
26888 bool result;
26889 void *argp1 = 0 ;
26890 int res1 = 0 ;
26891 void *argp2 = 0 ;
26892 int res2 = 0 ;
26893 PyObject * obj0 = 0 ;
26894 PyObject * obj1 = 0 ;
26895 char * kwnames[] = {
26896 (char *) "self",(char *) "dt", NULL
26897 };
26898
26899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
26900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26901 if (!SWIG_IsOK(res1)) {
26902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26903 }
26904 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26905 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26906 if (!SWIG_IsOK(res2)) {
26907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26908 }
26909 if (!argp2) {
26910 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26911 }
26912 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26913 {
26914 PyThreadState* __tstate = wxPyBeginAllowThreads();
26915 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
26916 wxPyEndAllowThreads(__tstate);
26917 if (PyErr_Occurred()) SWIG_fail;
26918 }
26919 {
26920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26921 }
26922 return resultobj;
26923 fail:
26924 return NULL;
26925 }
26926
26927
26928 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26929 PyObject *resultobj = 0;
26930 wxDateTime *arg1 = (wxDateTime *) 0 ;
26931 wxDateTime *arg2 = 0 ;
26932 wxTimeSpan *arg3 = 0 ;
26933 bool result;
26934 void *argp1 = 0 ;
26935 int res1 = 0 ;
26936 void *argp2 = 0 ;
26937 int res2 = 0 ;
26938 void *argp3 = 0 ;
26939 int res3 = 0 ;
26940 PyObject * obj0 = 0 ;
26941 PyObject * obj1 = 0 ;
26942 PyObject * obj2 = 0 ;
26943 char * kwnames[] = {
26944 (char *) "self",(char *) "dt",(char *) "ts", NULL
26945 };
26946
26947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26949 if (!SWIG_IsOK(res1)) {
26950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26951 }
26952 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26953 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26954 if (!SWIG_IsOK(res2)) {
26955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26956 }
26957 if (!argp2) {
26958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26959 }
26960 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26961 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26962 if (!SWIG_IsOK(res3)) {
26963 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26964 }
26965 if (!argp3) {
26966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26967 }
26968 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
26969 {
26970 PyThreadState* __tstate = wxPyBeginAllowThreads();
26971 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
26972 wxPyEndAllowThreads(__tstate);
26973 if (PyErr_Occurred()) SWIG_fail;
26974 }
26975 {
26976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26977 }
26978 return resultobj;
26979 fail:
26980 return NULL;
26981 }
26982
26983
26984 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26985 PyObject *resultobj = 0;
26986 wxDateTime *arg1 = (wxDateTime *) 0 ;
26987 wxTimeSpan *arg2 = 0 ;
26988 wxDateTime *result = 0 ;
26989 void *argp1 = 0 ;
26990 int res1 = 0 ;
26991 void *argp2 = 0 ;
26992 int res2 = 0 ;
26993 PyObject * obj0 = 0 ;
26994 PyObject * obj1 = 0 ;
26995 char * kwnames[] = {
26996 (char *) "self",(char *) "diff", NULL
26997 };
26998
26999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) 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_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27003 }
27004 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27005 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27006 if (!SWIG_IsOK(res2)) {
27007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27008 }
27009 if (!argp2) {
27010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27011 }
27012 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27013 {
27014 PyThreadState* __tstate = wxPyBeginAllowThreads();
27015 {
27016 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27017 result = (wxDateTime *) &_result_ref;
27018 }
27019 wxPyEndAllowThreads(__tstate);
27020 if (PyErr_Occurred()) SWIG_fail;
27021 }
27022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27023 return resultobj;
27024 fail:
27025 return NULL;
27026 }
27027
27028
27029 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27030 PyObject *resultobj = 0;
27031 wxDateTime *arg1 = (wxDateTime *) 0 ;
27032 wxDateSpan *arg2 = 0 ;
27033 wxDateTime *result = 0 ;
27034 void *argp1 = 0 ;
27035 int res1 = 0 ;
27036 void *argp2 = 0 ;
27037 int res2 = 0 ;
27038 PyObject * obj0 = 0 ;
27039 PyObject * obj1 = 0 ;
27040 char * kwnames[] = {
27041 (char *) "self",(char *) "diff", NULL
27042 };
27043
27044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27046 if (!SWIG_IsOK(res1)) {
27047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27048 }
27049 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27050 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27051 if (!SWIG_IsOK(res2)) {
27052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27053 }
27054 if (!argp2) {
27055 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27056 }
27057 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27058 {
27059 PyThreadState* __tstate = wxPyBeginAllowThreads();
27060 {
27061 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27062 result = (wxDateTime *) &_result_ref;
27063 }
27064 wxPyEndAllowThreads(__tstate);
27065 if (PyErr_Occurred()) SWIG_fail;
27066 }
27067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27068 return resultobj;
27069 fail:
27070 return NULL;
27071 }
27072
27073
27074 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27075 PyObject *resultobj = 0;
27076 wxDateTime *arg1 = (wxDateTime *) 0 ;
27077 wxTimeSpan *arg2 = 0 ;
27078 wxDateTime *result = 0 ;
27079 void *argp1 = 0 ;
27080 int res1 = 0 ;
27081 void *argp2 = 0 ;
27082 int res2 = 0 ;
27083 PyObject * obj0 = 0 ;
27084 PyObject * obj1 = 0 ;
27085 char * kwnames[] = {
27086 (char *) "self",(char *) "diff", NULL
27087 };
27088
27089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27091 if (!SWIG_IsOK(res1)) {
27092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27093 }
27094 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27095 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27096 if (!SWIG_IsOK(res2)) {
27097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27098 }
27099 if (!argp2) {
27100 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27101 }
27102 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27103 {
27104 PyThreadState* __tstate = wxPyBeginAllowThreads();
27105 {
27106 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27107 result = (wxDateTime *) &_result_ref;
27108 }
27109 wxPyEndAllowThreads(__tstate);
27110 if (PyErr_Occurred()) SWIG_fail;
27111 }
27112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27113 return resultobj;
27114 fail:
27115 return NULL;
27116 }
27117
27118
27119 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27120 PyObject *resultobj = 0;
27121 wxDateTime *arg1 = (wxDateTime *) 0 ;
27122 wxDateSpan *arg2 = 0 ;
27123 wxDateTime *result = 0 ;
27124 void *argp1 = 0 ;
27125 int res1 = 0 ;
27126 void *argp2 = 0 ;
27127 int res2 = 0 ;
27128 PyObject * obj0 = 0 ;
27129 PyObject * obj1 = 0 ;
27130 char * kwnames[] = {
27131 (char *) "self",(char *) "diff", NULL
27132 };
27133
27134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27136 if (!SWIG_IsOK(res1)) {
27137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27138 }
27139 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27140 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27141 if (!SWIG_IsOK(res2)) {
27142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27143 }
27144 if (!argp2) {
27145 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27146 }
27147 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27148 {
27149 PyThreadState* __tstate = wxPyBeginAllowThreads();
27150 {
27151 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27152 result = (wxDateTime *) &_result_ref;
27153 }
27154 wxPyEndAllowThreads(__tstate);
27155 if (PyErr_Occurred()) SWIG_fail;
27156 }
27157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27158 return resultobj;
27159 fail:
27160 return NULL;
27161 }
27162
27163
27164 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27165 PyObject *resultobj = 0;
27166 wxDateTime *arg1 = (wxDateTime *) 0 ;
27167 wxDateTime *arg2 = 0 ;
27168 wxTimeSpan result;
27169 void *argp1 = 0 ;
27170 int res1 = 0 ;
27171 void *argp2 = 0 ;
27172 int res2 = 0 ;
27173 PyObject * obj0 = 0 ;
27174 PyObject * obj1 = 0 ;
27175 char * kwnames[] = {
27176 (char *) "self",(char *) "dt", NULL
27177 };
27178
27179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27181 if (!SWIG_IsOK(res1)) {
27182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27183 }
27184 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27185 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27186 if (!SWIG_IsOK(res2)) {
27187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27188 }
27189 if (!argp2) {
27190 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27191 }
27192 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27193 {
27194 PyThreadState* __tstate = wxPyBeginAllowThreads();
27195 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27196 wxPyEndAllowThreads(__tstate);
27197 if (PyErr_Occurred()) SWIG_fail;
27198 }
27199 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27200 return resultobj;
27201 fail:
27202 return NULL;
27203 }
27204
27205
27206 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27207 PyObject *resultobj = 0;
27208 wxDateTime *arg1 = (wxDateTime *) 0 ;
27209 wxTimeSpan *arg2 = 0 ;
27210 wxDateTime *result = 0 ;
27211 void *argp1 = 0 ;
27212 int res1 = 0 ;
27213 void *argp2 = 0 ;
27214 int res2 = 0 ;
27215
27216 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27218 if (!SWIG_IsOK(res1)) {
27219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27220 }
27221 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27222 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27223 if (!SWIG_IsOK(res2)) {
27224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27225 }
27226 if (!argp2) {
27227 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27228 }
27229 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27230 {
27231 PyThreadState* __tstate = wxPyBeginAllowThreads();
27232 {
27233 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27234 result = (wxDateTime *) &_result_ref;
27235 }
27236 wxPyEndAllowThreads(__tstate);
27237 if (PyErr_Occurred()) SWIG_fail;
27238 }
27239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27240 return resultobj;
27241 fail:
27242 return NULL;
27243 }
27244
27245
27246 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27247 PyObject *resultobj = 0;
27248 wxDateTime *arg1 = (wxDateTime *) 0 ;
27249 wxDateSpan *arg2 = 0 ;
27250 wxDateTime *result = 0 ;
27251 void *argp1 = 0 ;
27252 int res1 = 0 ;
27253 void *argp2 = 0 ;
27254 int res2 = 0 ;
27255
27256 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27258 if (!SWIG_IsOK(res1)) {
27259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27260 }
27261 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27262 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27263 if (!SWIG_IsOK(res2)) {
27264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27265 }
27266 if (!argp2) {
27267 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27268 }
27269 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27270 {
27271 PyThreadState* __tstate = wxPyBeginAllowThreads();
27272 {
27273 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27274 result = (wxDateTime *) &_result_ref;
27275 }
27276 wxPyEndAllowThreads(__tstate);
27277 if (PyErr_Occurred()) SWIG_fail;
27278 }
27279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27280 return resultobj;
27281 fail:
27282 return NULL;
27283 }
27284
27285
27286 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27287 int argc;
27288 PyObject *argv[3];
27289
27290 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27291 --argc;
27292 if (argc == 2) {
27293 int _v = 0;
27294 {
27295 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27296 _v = SWIG_CheckState(res);
27297 }
27298 if (!_v) goto check_1;
27299 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27300 }
27301 check_1:
27302
27303 if (argc == 2) {
27304 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27305 }
27306
27307 fail:
27308 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27309 return NULL;
27310 }
27311
27312
27313 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27314 PyObject *resultobj = 0;
27315 wxDateTime *arg1 = (wxDateTime *) 0 ;
27316 wxTimeSpan *arg2 = 0 ;
27317 wxDateTime *result = 0 ;
27318 void *argp1 = 0 ;
27319 int res1 = 0 ;
27320 void *argp2 = 0 ;
27321 int res2 = 0 ;
27322
27323 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27325 if (!SWIG_IsOK(res1)) {
27326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27327 }
27328 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27329 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27330 if (!SWIG_IsOK(res2)) {
27331 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27332 }
27333 if (!argp2) {
27334 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27335 }
27336 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27337 {
27338 PyThreadState* __tstate = wxPyBeginAllowThreads();
27339 {
27340 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27341 result = (wxDateTime *) &_result_ref;
27342 }
27343 wxPyEndAllowThreads(__tstate);
27344 if (PyErr_Occurred()) SWIG_fail;
27345 }
27346 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27347 return resultobj;
27348 fail:
27349 return NULL;
27350 }
27351
27352
27353 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27354 PyObject *resultobj = 0;
27355 wxDateTime *arg1 = (wxDateTime *) 0 ;
27356 wxDateSpan *arg2 = 0 ;
27357 wxDateTime *result = 0 ;
27358 void *argp1 = 0 ;
27359 int res1 = 0 ;
27360 void *argp2 = 0 ;
27361 int res2 = 0 ;
27362
27363 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27365 if (!SWIG_IsOK(res1)) {
27366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27367 }
27368 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27369 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27370 if (!SWIG_IsOK(res2)) {
27371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27372 }
27373 if (!argp2) {
27374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27375 }
27376 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27377 {
27378 PyThreadState* __tstate = wxPyBeginAllowThreads();
27379 {
27380 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27381 result = (wxDateTime *) &_result_ref;
27382 }
27383 wxPyEndAllowThreads(__tstate);
27384 if (PyErr_Occurred()) SWIG_fail;
27385 }
27386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27387 return resultobj;
27388 fail:
27389 return NULL;
27390 }
27391
27392
27393 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27394 int argc;
27395 PyObject *argv[3];
27396
27397 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27398 --argc;
27399 if (argc == 2) {
27400 int _v = 0;
27401 {
27402 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27403 _v = SWIG_CheckState(res);
27404 }
27405 if (!_v) goto check_1;
27406 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27407 }
27408 check_1:
27409
27410 if (argc == 2) {
27411 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27412 }
27413
27414 fail:
27415 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27416 return NULL;
27417 }
27418
27419
27420 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27421 PyObject *resultobj = 0;
27422 wxDateTime *arg1 = (wxDateTime *) 0 ;
27423 wxTimeSpan *arg2 = 0 ;
27424 wxDateTime result;
27425 void *argp1 = 0 ;
27426 int res1 = 0 ;
27427 void *argp2 = 0 ;
27428 int res2 = 0 ;
27429
27430 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27432 if (!SWIG_IsOK(res1)) {
27433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27434 }
27435 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27436 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27437 if (!SWIG_IsOK(res2)) {
27438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27439 }
27440 if (!argp2) {
27441 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27442 }
27443 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27444 {
27445 PyThreadState* __tstate = wxPyBeginAllowThreads();
27446 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27447 wxPyEndAllowThreads(__tstate);
27448 if (PyErr_Occurred()) SWIG_fail;
27449 }
27450 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27451 return resultobj;
27452 fail:
27453 return NULL;
27454 }
27455
27456
27457 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27458 PyObject *resultobj = 0;
27459 wxDateTime *arg1 = (wxDateTime *) 0 ;
27460 wxDateSpan *arg2 = 0 ;
27461 wxDateTime result;
27462 void *argp1 = 0 ;
27463 int res1 = 0 ;
27464 void *argp2 = 0 ;
27465 int res2 = 0 ;
27466
27467 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27469 if (!SWIG_IsOK(res1)) {
27470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27471 }
27472 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27473 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27474 if (!SWIG_IsOK(res2)) {
27475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27476 }
27477 if (!argp2) {
27478 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27479 }
27480 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27481 {
27482 PyThreadState* __tstate = wxPyBeginAllowThreads();
27483 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27484 wxPyEndAllowThreads(__tstate);
27485 if (PyErr_Occurred()) SWIG_fail;
27486 }
27487 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27488 return resultobj;
27489 fail:
27490 return NULL;
27491 }
27492
27493
27494 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27495 int argc;
27496 PyObject *argv[3];
27497
27498 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27499 --argc;
27500 if (argc == 2) {
27501 int _v = 0;
27502 {
27503 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27504 _v = SWIG_CheckState(res);
27505 }
27506 if (!_v) goto check_1;
27507 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27508 }
27509 check_1:
27510
27511 if (argc == 2) {
27512 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27513 }
27514
27515 fail:
27516 Py_INCREF(Py_NotImplemented);
27517 return Py_NotImplemented;
27518 }
27519
27520
27521 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27522 PyObject *resultobj = 0;
27523 wxDateTime *arg1 = (wxDateTime *) 0 ;
27524 wxDateTime *arg2 = 0 ;
27525 wxTimeSpan result;
27526 void *argp1 = 0 ;
27527 int res1 = 0 ;
27528 void *argp2 = 0 ;
27529 int res2 = 0 ;
27530
27531 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27533 if (!SWIG_IsOK(res1)) {
27534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27535 }
27536 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27537 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27538 if (!SWIG_IsOK(res2)) {
27539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27540 }
27541 if (!argp2) {
27542 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27543 }
27544 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27545 {
27546 PyThreadState* __tstate = wxPyBeginAllowThreads();
27547 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27548 wxPyEndAllowThreads(__tstate);
27549 if (PyErr_Occurred()) SWIG_fail;
27550 }
27551 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27552 return resultobj;
27553 fail:
27554 return NULL;
27555 }
27556
27557
27558 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27559 PyObject *resultobj = 0;
27560 wxDateTime *arg1 = (wxDateTime *) 0 ;
27561 wxTimeSpan *arg2 = 0 ;
27562 wxDateTime result;
27563 void *argp1 = 0 ;
27564 int res1 = 0 ;
27565 void *argp2 = 0 ;
27566 int res2 = 0 ;
27567
27568 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27570 if (!SWIG_IsOK(res1)) {
27571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27572 }
27573 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27574 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27575 if (!SWIG_IsOK(res2)) {
27576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27577 }
27578 if (!argp2) {
27579 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27580 }
27581 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27582 {
27583 PyThreadState* __tstate = wxPyBeginAllowThreads();
27584 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27585 wxPyEndAllowThreads(__tstate);
27586 if (PyErr_Occurred()) SWIG_fail;
27587 }
27588 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27589 return resultobj;
27590 fail:
27591 return NULL;
27592 }
27593
27594
27595 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27596 PyObject *resultobj = 0;
27597 wxDateTime *arg1 = (wxDateTime *) 0 ;
27598 wxDateSpan *arg2 = 0 ;
27599 wxDateTime result;
27600 void *argp1 = 0 ;
27601 int res1 = 0 ;
27602 void *argp2 = 0 ;
27603 int res2 = 0 ;
27604
27605 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27607 if (!SWIG_IsOK(res1)) {
27608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27609 }
27610 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27611 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27612 if (!SWIG_IsOK(res2)) {
27613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27614 }
27615 if (!argp2) {
27616 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27617 }
27618 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27619 {
27620 PyThreadState* __tstate = wxPyBeginAllowThreads();
27621 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27622 wxPyEndAllowThreads(__tstate);
27623 if (PyErr_Occurred()) SWIG_fail;
27624 }
27625 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27626 return resultobj;
27627 fail:
27628 return NULL;
27629 }
27630
27631
27632 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27633 int argc;
27634 PyObject *argv[3];
27635
27636 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27637 --argc;
27638 if (argc == 2) {
27639 int _v = 0;
27640 {
27641 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27642 _v = SWIG_CheckState(res);
27643 }
27644 if (!_v) goto check_1;
27645 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27646 }
27647 check_1:
27648
27649 if (argc == 2) {
27650 int _v = 0;
27651 {
27652 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27653 _v = SWIG_CheckState(res);
27654 }
27655 if (!_v) goto check_2;
27656 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27657 }
27658 check_2:
27659
27660 if (argc == 2) {
27661 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27662 }
27663
27664 fail:
27665 Py_INCREF(Py_NotImplemented);
27666 return Py_NotImplemented;
27667 }
27668
27669
27670 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27671 PyObject *resultobj = 0;
27672 wxDateTime *arg1 = (wxDateTime *) 0 ;
27673 wxDateTime *arg2 = (wxDateTime *) 0 ;
27674 bool result;
27675 void *argp1 = 0 ;
27676 int res1 = 0 ;
27677 void *argp2 = 0 ;
27678 int res2 = 0 ;
27679 PyObject * obj0 = 0 ;
27680 PyObject * obj1 = 0 ;
27681 char * kwnames[] = {
27682 (char *) "self",(char *) "other", NULL
27683 };
27684
27685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27687 if (!SWIG_IsOK(res1)) {
27688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27689 }
27690 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27691 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27692 if (!SWIG_IsOK(res2)) {
27693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27694 }
27695 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27696 {
27697 PyThreadState* __tstate = wxPyBeginAllowThreads();
27698 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27699 wxPyEndAllowThreads(__tstate);
27700 if (PyErr_Occurred()) SWIG_fail;
27701 }
27702 {
27703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27704 }
27705 return resultobj;
27706 fail:
27707 return NULL;
27708 }
27709
27710
27711 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27712 PyObject *resultobj = 0;
27713 wxDateTime *arg1 = (wxDateTime *) 0 ;
27714 wxDateTime *arg2 = (wxDateTime *) 0 ;
27715 bool result;
27716 void *argp1 = 0 ;
27717 int res1 = 0 ;
27718 void *argp2 = 0 ;
27719 int res2 = 0 ;
27720 PyObject * obj0 = 0 ;
27721 PyObject * obj1 = 0 ;
27722 char * kwnames[] = {
27723 (char *) "self",(char *) "other", NULL
27724 };
27725
27726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27728 if (!SWIG_IsOK(res1)) {
27729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27730 }
27731 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27732 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27733 if (!SWIG_IsOK(res2)) {
27734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27735 }
27736 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27737 {
27738 PyThreadState* __tstate = wxPyBeginAllowThreads();
27739 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27740 wxPyEndAllowThreads(__tstate);
27741 if (PyErr_Occurred()) SWIG_fail;
27742 }
27743 {
27744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27745 }
27746 return resultobj;
27747 fail:
27748 return NULL;
27749 }
27750
27751
27752 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27753 PyObject *resultobj = 0;
27754 wxDateTime *arg1 = (wxDateTime *) 0 ;
27755 wxDateTime *arg2 = (wxDateTime *) 0 ;
27756 bool result;
27757 void *argp1 = 0 ;
27758 int res1 = 0 ;
27759 void *argp2 = 0 ;
27760 int res2 = 0 ;
27761 PyObject * obj0 = 0 ;
27762 PyObject * obj1 = 0 ;
27763 char * kwnames[] = {
27764 (char *) "self",(char *) "other", NULL
27765 };
27766
27767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
27768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27769 if (!SWIG_IsOK(res1)) {
27770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27771 }
27772 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27773 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27774 if (!SWIG_IsOK(res2)) {
27775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27776 }
27777 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27778 {
27779 PyThreadState* __tstate = wxPyBeginAllowThreads();
27780 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
27781 wxPyEndAllowThreads(__tstate);
27782 if (PyErr_Occurred()) SWIG_fail;
27783 }
27784 {
27785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27786 }
27787 return resultobj;
27788 fail:
27789 return NULL;
27790 }
27791
27792
27793 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27794 PyObject *resultobj = 0;
27795 wxDateTime *arg1 = (wxDateTime *) 0 ;
27796 wxDateTime *arg2 = (wxDateTime *) 0 ;
27797 bool result;
27798 void *argp1 = 0 ;
27799 int res1 = 0 ;
27800 void *argp2 = 0 ;
27801 int res2 = 0 ;
27802 PyObject * obj0 = 0 ;
27803 PyObject * obj1 = 0 ;
27804 char * kwnames[] = {
27805 (char *) "self",(char *) "other", NULL
27806 };
27807
27808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
27809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27810 if (!SWIG_IsOK(res1)) {
27811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27812 }
27813 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27814 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27815 if (!SWIG_IsOK(res2)) {
27816 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27817 }
27818 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27819 {
27820 PyThreadState* __tstate = wxPyBeginAllowThreads();
27821 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
27822 wxPyEndAllowThreads(__tstate);
27823 if (PyErr_Occurred()) SWIG_fail;
27824 }
27825 {
27826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27827 }
27828 return resultobj;
27829 fail:
27830 return NULL;
27831 }
27832
27833
27834 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27835 PyObject *resultobj = 0;
27836 wxDateTime *arg1 = (wxDateTime *) 0 ;
27837 wxDateTime *arg2 = (wxDateTime *) 0 ;
27838 bool result;
27839 void *argp1 = 0 ;
27840 int res1 = 0 ;
27841 void *argp2 = 0 ;
27842 int res2 = 0 ;
27843 PyObject * obj0 = 0 ;
27844 PyObject * obj1 = 0 ;
27845 char * kwnames[] = {
27846 (char *) "self",(char *) "other", NULL
27847 };
27848
27849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
27850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27851 if (!SWIG_IsOK(res1)) {
27852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27853 }
27854 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27855 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27856 if (!SWIG_IsOK(res2)) {
27857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27858 }
27859 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27860 {
27861 PyThreadState* __tstate = wxPyBeginAllowThreads();
27862 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
27863 wxPyEndAllowThreads(__tstate);
27864 if (PyErr_Occurred()) SWIG_fail;
27865 }
27866 {
27867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27868 }
27869 return resultobj;
27870 fail:
27871 return NULL;
27872 }
27873
27874
27875 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27876 PyObject *resultobj = 0;
27877 wxDateTime *arg1 = (wxDateTime *) 0 ;
27878 wxDateTime *arg2 = (wxDateTime *) 0 ;
27879 bool result;
27880 void *argp1 = 0 ;
27881 int res1 = 0 ;
27882 void *argp2 = 0 ;
27883 int res2 = 0 ;
27884 PyObject * obj0 = 0 ;
27885 PyObject * obj1 = 0 ;
27886 char * kwnames[] = {
27887 (char *) "self",(char *) "other", NULL
27888 };
27889
27890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
27891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27892 if (!SWIG_IsOK(res1)) {
27893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27894 }
27895 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27896 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27897 if (!SWIG_IsOK(res2)) {
27898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27899 }
27900 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27901 {
27902 PyThreadState* __tstate = wxPyBeginAllowThreads();
27903 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
27904 wxPyEndAllowThreads(__tstate);
27905 if (PyErr_Occurred()) SWIG_fail;
27906 }
27907 {
27908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27909 }
27910 return resultobj;
27911 fail:
27912 return NULL;
27913 }
27914
27915
27916 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27917 PyObject *resultobj = 0;
27918 wxDateTime *arg1 = (wxDateTime *) 0 ;
27919 wxString *arg2 = 0 ;
27920 int result;
27921 void *argp1 = 0 ;
27922 int res1 = 0 ;
27923 bool temp2 = false ;
27924 PyObject * obj0 = 0 ;
27925 PyObject * obj1 = 0 ;
27926 char * kwnames[] = {
27927 (char *) "self",(char *) "date", NULL
27928 };
27929
27930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
27931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27932 if (!SWIG_IsOK(res1)) {
27933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
27934 }
27935 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27936 {
27937 arg2 = wxString_in_helper(obj1);
27938 if (arg2 == NULL) SWIG_fail;
27939 temp2 = true;
27940 }
27941 {
27942 PyThreadState* __tstate = wxPyBeginAllowThreads();
27943 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
27944 wxPyEndAllowThreads(__tstate);
27945 if (PyErr_Occurred()) SWIG_fail;
27946 }
27947 resultobj = SWIG_From_int(static_cast< int >(result));
27948 {
27949 if (temp2)
27950 delete arg2;
27951 }
27952 return resultobj;
27953 fail:
27954 {
27955 if (temp2)
27956 delete arg2;
27957 }
27958 return NULL;
27959 }
27960
27961
27962 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27963 PyObject *resultobj = 0;
27964 wxDateTime *arg1 = (wxDateTime *) 0 ;
27965 wxString *arg2 = 0 ;
27966 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
27967 wxString *arg3 = (wxString *) &arg3_defvalue ;
27968 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
27969 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
27970 int result;
27971 void *argp1 = 0 ;
27972 int res1 = 0 ;
27973 bool temp2 = false ;
27974 bool temp3 = false ;
27975 void *argp4 = 0 ;
27976 int res4 = 0 ;
27977 PyObject * obj0 = 0 ;
27978 PyObject * obj1 = 0 ;
27979 PyObject * obj2 = 0 ;
27980 PyObject * obj3 = 0 ;
27981 char * kwnames[] = {
27982 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
27983 };
27984
27985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27987 if (!SWIG_IsOK(res1)) {
27988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
27989 }
27990 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27991 {
27992 arg2 = wxString_in_helper(obj1);
27993 if (arg2 == NULL) SWIG_fail;
27994 temp2 = true;
27995 }
27996 if (obj2) {
27997 {
27998 arg3 = wxString_in_helper(obj2);
27999 if (arg3 == NULL) SWIG_fail;
28000 temp3 = true;
28001 }
28002 }
28003 if (obj3) {
28004 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28005 if (!SWIG_IsOK(res4)) {
28006 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28007 }
28008 if (!argp4) {
28009 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28010 }
28011 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28012 }
28013 {
28014 PyThreadState* __tstate = wxPyBeginAllowThreads();
28015 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28016 wxPyEndAllowThreads(__tstate);
28017 if (PyErr_Occurred()) SWIG_fail;
28018 }
28019 resultobj = SWIG_From_int(static_cast< int >(result));
28020 {
28021 if (temp2)
28022 delete arg2;
28023 }
28024 {
28025 if (temp3)
28026 delete arg3;
28027 }
28028 return resultobj;
28029 fail:
28030 {
28031 if (temp2)
28032 delete arg2;
28033 }
28034 {
28035 if (temp3)
28036 delete arg3;
28037 }
28038 return NULL;
28039 }
28040
28041
28042 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28043 PyObject *resultobj = 0;
28044 wxDateTime *arg1 = (wxDateTime *) 0 ;
28045 wxString *arg2 = 0 ;
28046 int result;
28047 void *argp1 = 0 ;
28048 int res1 = 0 ;
28049 bool temp2 = false ;
28050 PyObject * obj0 = 0 ;
28051 PyObject * obj1 = 0 ;
28052 char * kwnames[] = {
28053 (char *) "self",(char *) "datetime", NULL
28054 };
28055
28056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28058 if (!SWIG_IsOK(res1)) {
28059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28060 }
28061 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28062 {
28063 arg2 = wxString_in_helper(obj1);
28064 if (arg2 == NULL) SWIG_fail;
28065 temp2 = true;
28066 }
28067 {
28068 PyThreadState* __tstate = wxPyBeginAllowThreads();
28069 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28070 wxPyEndAllowThreads(__tstate);
28071 if (PyErr_Occurred()) SWIG_fail;
28072 }
28073 resultobj = SWIG_From_int(static_cast< int >(result));
28074 {
28075 if (temp2)
28076 delete arg2;
28077 }
28078 return resultobj;
28079 fail:
28080 {
28081 if (temp2)
28082 delete arg2;
28083 }
28084 return NULL;
28085 }
28086
28087
28088 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28089 PyObject *resultobj = 0;
28090 wxDateTime *arg1 = (wxDateTime *) 0 ;
28091 wxString *arg2 = 0 ;
28092 int result;
28093 void *argp1 = 0 ;
28094 int res1 = 0 ;
28095 bool temp2 = false ;
28096 PyObject * obj0 = 0 ;
28097 PyObject * obj1 = 0 ;
28098 char * kwnames[] = {
28099 (char *) "self",(char *) "date", NULL
28100 };
28101
28102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28104 if (!SWIG_IsOK(res1)) {
28105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28106 }
28107 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28108 {
28109 arg2 = wxString_in_helper(obj1);
28110 if (arg2 == NULL) SWIG_fail;
28111 temp2 = true;
28112 }
28113 {
28114 PyThreadState* __tstate = wxPyBeginAllowThreads();
28115 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28116 wxPyEndAllowThreads(__tstate);
28117 if (PyErr_Occurred()) SWIG_fail;
28118 }
28119 resultobj = SWIG_From_int(static_cast< int >(result));
28120 {
28121 if (temp2)
28122 delete arg2;
28123 }
28124 return resultobj;
28125 fail:
28126 {
28127 if (temp2)
28128 delete arg2;
28129 }
28130 return NULL;
28131 }
28132
28133
28134 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28135 PyObject *resultobj = 0;
28136 wxDateTime *arg1 = (wxDateTime *) 0 ;
28137 wxString *arg2 = 0 ;
28138 int result;
28139 void *argp1 = 0 ;
28140 int res1 = 0 ;
28141 bool temp2 = false ;
28142 PyObject * obj0 = 0 ;
28143 PyObject * obj1 = 0 ;
28144 char * kwnames[] = {
28145 (char *) "self",(char *) "time", NULL
28146 };
28147
28148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28150 if (!SWIG_IsOK(res1)) {
28151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28152 }
28153 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28154 {
28155 arg2 = wxString_in_helper(obj1);
28156 if (arg2 == NULL) SWIG_fail;
28157 temp2 = true;
28158 }
28159 {
28160 PyThreadState* __tstate = wxPyBeginAllowThreads();
28161 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28162 wxPyEndAllowThreads(__tstate);
28163 if (PyErr_Occurred()) SWIG_fail;
28164 }
28165 resultobj = SWIG_From_int(static_cast< int >(result));
28166 {
28167 if (temp2)
28168 delete arg2;
28169 }
28170 return resultobj;
28171 fail:
28172 {
28173 if (temp2)
28174 delete arg2;
28175 }
28176 return NULL;
28177 }
28178
28179
28180 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28181 PyObject *resultobj = 0;
28182 wxDateTime *arg1 = (wxDateTime *) 0 ;
28183 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28184 wxString *arg2 = (wxString *) &arg2_defvalue ;
28185 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28186 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28187 wxString result;
28188 void *argp1 = 0 ;
28189 int res1 = 0 ;
28190 bool temp2 = false ;
28191 bool temp3 = false ;
28192 PyObject * obj0 = 0 ;
28193 PyObject * obj1 = 0 ;
28194 PyObject * obj2 = 0 ;
28195 char * kwnames[] = {
28196 (char *) "self",(char *) "format",(char *) "tz", NULL
28197 };
28198
28199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28201 if (!SWIG_IsOK(res1)) {
28202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28203 }
28204 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28205 if (obj1) {
28206 {
28207 arg2 = wxString_in_helper(obj1);
28208 if (arg2 == NULL) SWIG_fail;
28209 temp2 = true;
28210 }
28211 }
28212 if (obj2) {
28213 {
28214 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28215 temp3 = true;
28216 }
28217 }
28218 {
28219 PyThreadState* __tstate = wxPyBeginAllowThreads();
28220 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28221 wxPyEndAllowThreads(__tstate);
28222 if (PyErr_Occurred()) SWIG_fail;
28223 }
28224 {
28225 #if wxUSE_UNICODE
28226 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28227 #else
28228 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28229 #endif
28230 }
28231 {
28232 if (temp2)
28233 delete arg2;
28234 }
28235 {
28236 if (temp3) delete arg3;
28237 }
28238 return resultobj;
28239 fail:
28240 {
28241 if (temp2)
28242 delete arg2;
28243 }
28244 {
28245 if (temp3) delete arg3;
28246 }
28247 return NULL;
28248 }
28249
28250
28251 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28252 PyObject *resultobj = 0;
28253 wxDateTime *arg1 = (wxDateTime *) 0 ;
28254 wxString result;
28255 void *argp1 = 0 ;
28256 int res1 = 0 ;
28257 PyObject *swig_obj[1] ;
28258
28259 if (!args) SWIG_fail;
28260 swig_obj[0] = args;
28261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28262 if (!SWIG_IsOK(res1)) {
28263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28264 }
28265 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28266 {
28267 PyThreadState* __tstate = wxPyBeginAllowThreads();
28268 result = ((wxDateTime const *)arg1)->FormatDate();
28269 wxPyEndAllowThreads(__tstate);
28270 if (PyErr_Occurred()) SWIG_fail;
28271 }
28272 {
28273 #if wxUSE_UNICODE
28274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28275 #else
28276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28277 #endif
28278 }
28279 return resultobj;
28280 fail:
28281 return NULL;
28282 }
28283
28284
28285 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28286 PyObject *resultobj = 0;
28287 wxDateTime *arg1 = (wxDateTime *) 0 ;
28288 wxString result;
28289 void *argp1 = 0 ;
28290 int res1 = 0 ;
28291 PyObject *swig_obj[1] ;
28292
28293 if (!args) SWIG_fail;
28294 swig_obj[0] = args;
28295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28296 if (!SWIG_IsOK(res1)) {
28297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28298 }
28299 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28300 {
28301 PyThreadState* __tstate = wxPyBeginAllowThreads();
28302 result = ((wxDateTime const *)arg1)->FormatTime();
28303 wxPyEndAllowThreads(__tstate);
28304 if (PyErr_Occurred()) SWIG_fail;
28305 }
28306 {
28307 #if wxUSE_UNICODE
28308 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28309 #else
28310 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28311 #endif
28312 }
28313 return resultobj;
28314 fail:
28315 return NULL;
28316 }
28317
28318
28319 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28320 PyObject *resultobj = 0;
28321 wxDateTime *arg1 = (wxDateTime *) 0 ;
28322 wxString result;
28323 void *argp1 = 0 ;
28324 int res1 = 0 ;
28325 PyObject *swig_obj[1] ;
28326
28327 if (!args) SWIG_fail;
28328 swig_obj[0] = args;
28329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28330 if (!SWIG_IsOK(res1)) {
28331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28332 }
28333 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28334 {
28335 PyThreadState* __tstate = wxPyBeginAllowThreads();
28336 result = ((wxDateTime const *)arg1)->FormatISODate();
28337 wxPyEndAllowThreads(__tstate);
28338 if (PyErr_Occurred()) SWIG_fail;
28339 }
28340 {
28341 #if wxUSE_UNICODE
28342 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28343 #else
28344 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28345 #endif
28346 }
28347 return resultobj;
28348 fail:
28349 return NULL;
28350 }
28351
28352
28353 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28354 PyObject *resultobj = 0;
28355 wxDateTime *arg1 = (wxDateTime *) 0 ;
28356 wxString result;
28357 void *argp1 = 0 ;
28358 int res1 = 0 ;
28359 PyObject *swig_obj[1] ;
28360
28361 if (!args) SWIG_fail;
28362 swig_obj[0] = args;
28363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28364 if (!SWIG_IsOK(res1)) {
28365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28366 }
28367 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28368 {
28369 PyThreadState* __tstate = wxPyBeginAllowThreads();
28370 result = ((wxDateTime const *)arg1)->FormatISOTime();
28371 wxPyEndAllowThreads(__tstate);
28372 if (PyErr_Occurred()) SWIG_fail;
28373 }
28374 {
28375 #if wxUSE_UNICODE
28376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28377 #else
28378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28379 #endif
28380 }
28381 return resultobj;
28382 fail:
28383 return NULL;
28384 }
28385
28386
28387 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28388 PyObject *obj;
28389 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28390 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28391 return SWIG_Py_Void();
28392 }
28393
28394 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28395 return SWIG_Python_InitShadowInstance(args);
28396 }
28397
28398 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28399 PyObject *resultobj = 0;
28400 long arg1 ;
28401 wxTimeSpan result;
28402 long val1 ;
28403 int ecode1 = 0 ;
28404 PyObject * obj0 = 0 ;
28405 char * kwnames[] = {
28406 (char *) "ms", NULL
28407 };
28408
28409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28410 ecode1 = SWIG_AsVal_long(obj0, &val1);
28411 if (!SWIG_IsOK(ecode1)) {
28412 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28413 }
28414 arg1 = static_cast< long >(val1);
28415 {
28416 PyThreadState* __tstate = wxPyBeginAllowThreads();
28417 result = wxTimeSpan::Milliseconds(arg1);
28418 wxPyEndAllowThreads(__tstate);
28419 if (PyErr_Occurred()) SWIG_fail;
28420 }
28421 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28422 return resultobj;
28423 fail:
28424 return NULL;
28425 }
28426
28427
28428 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28429 PyObject *resultobj = 0;
28430 wxTimeSpan result;
28431
28432 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28433 {
28434 PyThreadState* __tstate = wxPyBeginAllowThreads();
28435 result = wxTimeSpan::Millisecond();
28436 wxPyEndAllowThreads(__tstate);
28437 if (PyErr_Occurred()) SWIG_fail;
28438 }
28439 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28440 return resultobj;
28441 fail:
28442 return NULL;
28443 }
28444
28445
28446 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28447 PyObject *resultobj = 0;
28448 long arg1 ;
28449 wxTimeSpan result;
28450 long val1 ;
28451 int ecode1 = 0 ;
28452 PyObject * obj0 = 0 ;
28453 char * kwnames[] = {
28454 (char *) "sec", NULL
28455 };
28456
28457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28458 ecode1 = SWIG_AsVal_long(obj0, &val1);
28459 if (!SWIG_IsOK(ecode1)) {
28460 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28461 }
28462 arg1 = static_cast< long >(val1);
28463 {
28464 PyThreadState* __tstate = wxPyBeginAllowThreads();
28465 result = wxTimeSpan::Seconds(arg1);
28466 wxPyEndAllowThreads(__tstate);
28467 if (PyErr_Occurred()) SWIG_fail;
28468 }
28469 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28470 return resultobj;
28471 fail:
28472 return NULL;
28473 }
28474
28475
28476 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28477 PyObject *resultobj = 0;
28478 wxTimeSpan result;
28479
28480 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28481 {
28482 PyThreadState* __tstate = wxPyBeginAllowThreads();
28483 result = wxTimeSpan::Second();
28484 wxPyEndAllowThreads(__tstate);
28485 if (PyErr_Occurred()) SWIG_fail;
28486 }
28487 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28488 return resultobj;
28489 fail:
28490 return NULL;
28491 }
28492
28493
28494 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28495 PyObject *resultobj = 0;
28496 long arg1 ;
28497 wxTimeSpan result;
28498 long val1 ;
28499 int ecode1 = 0 ;
28500 PyObject * obj0 = 0 ;
28501 char * kwnames[] = {
28502 (char *) "min", NULL
28503 };
28504
28505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28506 ecode1 = SWIG_AsVal_long(obj0, &val1);
28507 if (!SWIG_IsOK(ecode1)) {
28508 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28509 }
28510 arg1 = static_cast< long >(val1);
28511 {
28512 PyThreadState* __tstate = wxPyBeginAllowThreads();
28513 result = wxTimeSpan::Minutes(arg1);
28514 wxPyEndAllowThreads(__tstate);
28515 if (PyErr_Occurred()) SWIG_fail;
28516 }
28517 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28518 return resultobj;
28519 fail:
28520 return NULL;
28521 }
28522
28523
28524 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28525 PyObject *resultobj = 0;
28526 wxTimeSpan result;
28527
28528 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28529 {
28530 PyThreadState* __tstate = wxPyBeginAllowThreads();
28531 result = wxTimeSpan::Minute();
28532 wxPyEndAllowThreads(__tstate);
28533 if (PyErr_Occurred()) SWIG_fail;
28534 }
28535 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28536 return resultobj;
28537 fail:
28538 return NULL;
28539 }
28540
28541
28542 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28543 PyObject *resultobj = 0;
28544 long arg1 ;
28545 wxTimeSpan result;
28546 long val1 ;
28547 int ecode1 = 0 ;
28548 PyObject * obj0 = 0 ;
28549 char * kwnames[] = {
28550 (char *) "hours", NULL
28551 };
28552
28553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28554 ecode1 = SWIG_AsVal_long(obj0, &val1);
28555 if (!SWIG_IsOK(ecode1)) {
28556 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28557 }
28558 arg1 = static_cast< long >(val1);
28559 {
28560 PyThreadState* __tstate = wxPyBeginAllowThreads();
28561 result = wxTimeSpan::Hours(arg1);
28562 wxPyEndAllowThreads(__tstate);
28563 if (PyErr_Occurred()) SWIG_fail;
28564 }
28565 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28566 return resultobj;
28567 fail:
28568 return NULL;
28569 }
28570
28571
28572 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28573 PyObject *resultobj = 0;
28574 wxTimeSpan result;
28575
28576 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28577 {
28578 PyThreadState* __tstate = wxPyBeginAllowThreads();
28579 result = wxTimeSpan::Hour();
28580 wxPyEndAllowThreads(__tstate);
28581 if (PyErr_Occurred()) SWIG_fail;
28582 }
28583 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28584 return resultobj;
28585 fail:
28586 return NULL;
28587 }
28588
28589
28590 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28591 PyObject *resultobj = 0;
28592 long arg1 ;
28593 wxTimeSpan result;
28594 long val1 ;
28595 int ecode1 = 0 ;
28596 PyObject * obj0 = 0 ;
28597 char * kwnames[] = {
28598 (char *) "days", NULL
28599 };
28600
28601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28602 ecode1 = SWIG_AsVal_long(obj0, &val1);
28603 if (!SWIG_IsOK(ecode1)) {
28604 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28605 }
28606 arg1 = static_cast< long >(val1);
28607 {
28608 PyThreadState* __tstate = wxPyBeginAllowThreads();
28609 result = wxTimeSpan::Days(arg1);
28610 wxPyEndAllowThreads(__tstate);
28611 if (PyErr_Occurred()) SWIG_fail;
28612 }
28613 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28614 return resultobj;
28615 fail:
28616 return NULL;
28617 }
28618
28619
28620 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28621 PyObject *resultobj = 0;
28622 wxTimeSpan result;
28623
28624 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28625 {
28626 PyThreadState* __tstate = wxPyBeginAllowThreads();
28627 result = wxTimeSpan::Day();
28628 wxPyEndAllowThreads(__tstate);
28629 if (PyErr_Occurred()) SWIG_fail;
28630 }
28631 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28632 return resultobj;
28633 fail:
28634 return NULL;
28635 }
28636
28637
28638 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28639 PyObject *resultobj = 0;
28640 long arg1 ;
28641 wxTimeSpan result;
28642 long val1 ;
28643 int ecode1 = 0 ;
28644 PyObject * obj0 = 0 ;
28645 char * kwnames[] = {
28646 (char *) "days", NULL
28647 };
28648
28649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28650 ecode1 = SWIG_AsVal_long(obj0, &val1);
28651 if (!SWIG_IsOK(ecode1)) {
28652 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28653 }
28654 arg1 = static_cast< long >(val1);
28655 {
28656 PyThreadState* __tstate = wxPyBeginAllowThreads();
28657 result = wxTimeSpan::Weeks(arg1);
28658 wxPyEndAllowThreads(__tstate);
28659 if (PyErr_Occurred()) SWIG_fail;
28660 }
28661 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28662 return resultobj;
28663 fail:
28664 return NULL;
28665 }
28666
28667
28668 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28669 PyObject *resultobj = 0;
28670 wxTimeSpan result;
28671
28672 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28673 {
28674 PyThreadState* __tstate = wxPyBeginAllowThreads();
28675 result = wxTimeSpan::Week();
28676 wxPyEndAllowThreads(__tstate);
28677 if (PyErr_Occurred()) SWIG_fail;
28678 }
28679 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28680 return resultobj;
28681 fail:
28682 return NULL;
28683 }
28684
28685
28686 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28687 PyObject *resultobj = 0;
28688 long arg1 = (long) 0 ;
28689 long arg2 = (long) 0 ;
28690 long arg3 = (long) 0 ;
28691 long arg4 = (long) 0 ;
28692 wxTimeSpan *result = 0 ;
28693 long val1 ;
28694 int ecode1 = 0 ;
28695 long val2 ;
28696 int ecode2 = 0 ;
28697 long val3 ;
28698 int ecode3 = 0 ;
28699 long val4 ;
28700 int ecode4 = 0 ;
28701 PyObject * obj0 = 0 ;
28702 PyObject * obj1 = 0 ;
28703 PyObject * obj2 = 0 ;
28704 PyObject * obj3 = 0 ;
28705 char * kwnames[] = {
28706 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28707 };
28708
28709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28710 if (obj0) {
28711 ecode1 = SWIG_AsVal_long(obj0, &val1);
28712 if (!SWIG_IsOK(ecode1)) {
28713 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28714 }
28715 arg1 = static_cast< long >(val1);
28716 }
28717 if (obj1) {
28718 ecode2 = SWIG_AsVal_long(obj1, &val2);
28719 if (!SWIG_IsOK(ecode2)) {
28720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28721 }
28722 arg2 = static_cast< long >(val2);
28723 }
28724 if (obj2) {
28725 ecode3 = SWIG_AsVal_long(obj2, &val3);
28726 if (!SWIG_IsOK(ecode3)) {
28727 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28728 }
28729 arg3 = static_cast< long >(val3);
28730 }
28731 if (obj3) {
28732 ecode4 = SWIG_AsVal_long(obj3, &val4);
28733 if (!SWIG_IsOK(ecode4)) {
28734 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28735 }
28736 arg4 = static_cast< long >(val4);
28737 }
28738 {
28739 PyThreadState* __tstate = wxPyBeginAllowThreads();
28740 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28741 wxPyEndAllowThreads(__tstate);
28742 if (PyErr_Occurred()) SWIG_fail;
28743 }
28744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28745 return resultobj;
28746 fail:
28747 return NULL;
28748 }
28749
28750
28751 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28752 PyObject *resultobj = 0;
28753 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28754 void *argp1 = 0 ;
28755 int res1 = 0 ;
28756 PyObject *swig_obj[1] ;
28757
28758 if (!args) SWIG_fail;
28759 swig_obj[0] = args;
28760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28761 if (!SWIG_IsOK(res1)) {
28762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28763 }
28764 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28765 {
28766 PyThreadState* __tstate = wxPyBeginAllowThreads();
28767 delete arg1;
28768
28769 wxPyEndAllowThreads(__tstate);
28770 if (PyErr_Occurred()) SWIG_fail;
28771 }
28772 resultobj = SWIG_Py_Void();
28773 return resultobj;
28774 fail:
28775 return NULL;
28776 }
28777
28778
28779 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28780 PyObject *resultobj = 0;
28781 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28782 wxTimeSpan *arg2 = 0 ;
28783 wxTimeSpan *result = 0 ;
28784 void *argp1 = 0 ;
28785 int res1 = 0 ;
28786 void *argp2 = 0 ;
28787 int res2 = 0 ;
28788 PyObject * obj0 = 0 ;
28789 PyObject * obj1 = 0 ;
28790 char * kwnames[] = {
28791 (char *) "self",(char *) "diff", NULL
28792 };
28793
28794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
28795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28796 if (!SWIG_IsOK(res1)) {
28797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28798 }
28799 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28800 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28801 if (!SWIG_IsOK(res2)) {
28802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28803 }
28804 if (!argp2) {
28805 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28806 }
28807 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28808 {
28809 PyThreadState* __tstate = wxPyBeginAllowThreads();
28810 {
28811 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
28812 result = (wxTimeSpan *) &_result_ref;
28813 }
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28825 PyObject *resultobj = 0;
28826 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28827 wxTimeSpan *arg2 = 0 ;
28828 wxTimeSpan *result = 0 ;
28829 void *argp1 = 0 ;
28830 int res1 = 0 ;
28831 void *argp2 = 0 ;
28832 int res2 = 0 ;
28833 PyObject * obj0 = 0 ;
28834 PyObject * obj1 = 0 ;
28835 char * kwnames[] = {
28836 (char *) "self",(char *) "diff", NULL
28837 };
28838
28839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
28840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28841 if (!SWIG_IsOK(res1)) {
28842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28843 }
28844 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28845 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28846 if (!SWIG_IsOK(res2)) {
28847 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28848 }
28849 if (!argp2) {
28850 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28851 }
28852 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28853 {
28854 PyThreadState* __tstate = wxPyBeginAllowThreads();
28855 {
28856 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
28857 result = (wxTimeSpan *) &_result_ref;
28858 }
28859 wxPyEndAllowThreads(__tstate);
28860 if (PyErr_Occurred()) SWIG_fail;
28861 }
28862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28863 return resultobj;
28864 fail:
28865 return NULL;
28866 }
28867
28868
28869 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28870 PyObject *resultobj = 0;
28871 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28872 int arg2 ;
28873 wxTimeSpan *result = 0 ;
28874 void *argp1 = 0 ;
28875 int res1 = 0 ;
28876 int val2 ;
28877 int ecode2 = 0 ;
28878 PyObject * obj0 = 0 ;
28879 PyObject * obj1 = 0 ;
28880 char * kwnames[] = {
28881 (char *) "self",(char *) "n", NULL
28882 };
28883
28884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
28885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28886 if (!SWIG_IsOK(res1)) {
28887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28888 }
28889 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28890 ecode2 = SWIG_AsVal_int(obj1, &val2);
28891 if (!SWIG_IsOK(ecode2)) {
28892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
28893 }
28894 arg2 = static_cast< int >(val2);
28895 {
28896 PyThreadState* __tstate = wxPyBeginAllowThreads();
28897 {
28898 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
28899 result = (wxTimeSpan *) &_result_ref;
28900 }
28901 wxPyEndAllowThreads(__tstate);
28902 if (PyErr_Occurred()) SWIG_fail;
28903 }
28904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28905 return resultobj;
28906 fail:
28907 return NULL;
28908 }
28909
28910
28911 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28912 PyObject *resultobj = 0;
28913 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28914 wxTimeSpan *result = 0 ;
28915 void *argp1 = 0 ;
28916 int res1 = 0 ;
28917 PyObject *swig_obj[1] ;
28918
28919 if (!args) SWIG_fail;
28920 swig_obj[0] = args;
28921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28922 if (!SWIG_IsOK(res1)) {
28923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28924 }
28925 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28926 {
28927 PyThreadState* __tstate = wxPyBeginAllowThreads();
28928 {
28929 wxTimeSpan &_result_ref = (arg1)->Neg();
28930 result = (wxTimeSpan *) &_result_ref;
28931 }
28932 wxPyEndAllowThreads(__tstate);
28933 if (PyErr_Occurred()) SWIG_fail;
28934 }
28935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28936 return resultobj;
28937 fail:
28938 return NULL;
28939 }
28940
28941
28942 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28943 PyObject *resultobj = 0;
28944 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28945 wxTimeSpan result;
28946 void *argp1 = 0 ;
28947 int res1 = 0 ;
28948 PyObject *swig_obj[1] ;
28949
28950 if (!args) SWIG_fail;
28951 swig_obj[0] = args;
28952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28953 if (!SWIG_IsOK(res1)) {
28954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28955 }
28956 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28957 {
28958 PyThreadState* __tstate = wxPyBeginAllowThreads();
28959 result = ((wxTimeSpan const *)arg1)->Abs();
28960 wxPyEndAllowThreads(__tstate);
28961 if (PyErr_Occurred()) SWIG_fail;
28962 }
28963 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28964 return resultobj;
28965 fail:
28966 return NULL;
28967 }
28968
28969
28970 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28971 PyObject *resultobj = 0;
28972 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28973 wxTimeSpan *arg2 = 0 ;
28974 wxTimeSpan *result = 0 ;
28975 void *argp1 = 0 ;
28976 int res1 = 0 ;
28977 void *argp2 = 0 ;
28978 int res2 = 0 ;
28979 PyObject * obj0 = 0 ;
28980 PyObject * obj1 = 0 ;
28981 char * kwnames[] = {
28982 (char *) "self",(char *) "diff", NULL
28983 };
28984
28985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
28986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28987 if (!SWIG_IsOK(res1)) {
28988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28989 }
28990 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28991 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28992 if (!SWIG_IsOK(res2)) {
28993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28994 }
28995 if (!argp2) {
28996 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28997 }
28998 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28999 {
29000 PyThreadState* __tstate = wxPyBeginAllowThreads();
29001 {
29002 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29003 result = (wxTimeSpan *) &_result_ref;
29004 }
29005 wxPyEndAllowThreads(__tstate);
29006 if (PyErr_Occurred()) SWIG_fail;
29007 }
29008 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29009 return resultobj;
29010 fail:
29011 return NULL;
29012 }
29013
29014
29015 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29016 PyObject *resultobj = 0;
29017 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29018 wxTimeSpan *arg2 = 0 ;
29019 wxTimeSpan *result = 0 ;
29020 void *argp1 = 0 ;
29021 int res1 = 0 ;
29022 void *argp2 = 0 ;
29023 int res2 = 0 ;
29024 PyObject * obj0 = 0 ;
29025 PyObject * obj1 = 0 ;
29026 char * kwnames[] = {
29027 (char *) "self",(char *) "diff", NULL
29028 };
29029
29030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29032 if (!SWIG_IsOK(res1)) {
29033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29034 }
29035 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29036 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29037 if (!SWIG_IsOK(res2)) {
29038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29039 }
29040 if (!argp2) {
29041 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29042 }
29043 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29044 {
29045 PyThreadState* __tstate = wxPyBeginAllowThreads();
29046 {
29047 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29048 result = (wxTimeSpan *) &_result_ref;
29049 }
29050 wxPyEndAllowThreads(__tstate);
29051 if (PyErr_Occurred()) SWIG_fail;
29052 }
29053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29054 return resultobj;
29055 fail:
29056 return NULL;
29057 }
29058
29059
29060 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29061 PyObject *resultobj = 0;
29062 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29063 int arg2 ;
29064 wxTimeSpan *result = 0 ;
29065 void *argp1 = 0 ;
29066 int res1 = 0 ;
29067 int val2 ;
29068 int ecode2 = 0 ;
29069 PyObject * obj0 = 0 ;
29070 PyObject * obj1 = 0 ;
29071 char * kwnames[] = {
29072 (char *) "self",(char *) "n", NULL
29073 };
29074
29075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29077 if (!SWIG_IsOK(res1)) {
29078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29079 }
29080 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29081 ecode2 = SWIG_AsVal_int(obj1, &val2);
29082 if (!SWIG_IsOK(ecode2)) {
29083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29084 }
29085 arg2 = static_cast< int >(val2);
29086 {
29087 PyThreadState* __tstate = wxPyBeginAllowThreads();
29088 {
29089 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29090 result = (wxTimeSpan *) &_result_ref;
29091 }
29092 wxPyEndAllowThreads(__tstate);
29093 if (PyErr_Occurred()) SWIG_fail;
29094 }
29095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29096 return resultobj;
29097 fail:
29098 return NULL;
29099 }
29100
29101
29102 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29103 PyObject *resultobj = 0;
29104 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29105 wxTimeSpan *result = 0 ;
29106 void *argp1 = 0 ;
29107 int res1 = 0 ;
29108 PyObject *swig_obj[1] ;
29109
29110 if (!args) SWIG_fail;
29111 swig_obj[0] = args;
29112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29113 if (!SWIG_IsOK(res1)) {
29114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29115 }
29116 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29117 {
29118 PyThreadState* __tstate = wxPyBeginAllowThreads();
29119 {
29120 wxTimeSpan &_result_ref = (arg1)->operator -();
29121 result = (wxTimeSpan *) &_result_ref;
29122 }
29123 wxPyEndAllowThreads(__tstate);
29124 if (PyErr_Occurred()) SWIG_fail;
29125 }
29126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29127 return resultobj;
29128 fail:
29129 return NULL;
29130 }
29131
29132
29133 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29134 PyObject *resultobj = 0;
29135 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29136 wxTimeSpan *arg2 = 0 ;
29137 wxTimeSpan result;
29138 void *argp1 = 0 ;
29139 int res1 = 0 ;
29140 void *argp2 = 0 ;
29141 int res2 = 0 ;
29142 PyObject * obj0 = 0 ;
29143 PyObject * obj1 = 0 ;
29144 char * kwnames[] = {
29145 (char *) "self",(char *) "other", NULL
29146 };
29147
29148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29150 if (!SWIG_IsOK(res1)) {
29151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29152 }
29153 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29154 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29155 if (!SWIG_IsOK(res2)) {
29156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29157 }
29158 if (!argp2) {
29159 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29160 }
29161 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29162 {
29163 PyThreadState* __tstate = wxPyBeginAllowThreads();
29164 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29165 wxPyEndAllowThreads(__tstate);
29166 if (PyErr_Occurred()) SWIG_fail;
29167 }
29168 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29169 return resultobj;
29170 fail:
29171 return NULL;
29172 }
29173
29174
29175 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29176 PyObject *resultobj = 0;
29177 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29178 wxTimeSpan *arg2 = 0 ;
29179 wxTimeSpan result;
29180 void *argp1 = 0 ;
29181 int res1 = 0 ;
29182 void *argp2 = 0 ;
29183 int res2 = 0 ;
29184 PyObject * obj0 = 0 ;
29185 PyObject * obj1 = 0 ;
29186 char * kwnames[] = {
29187 (char *) "self",(char *) "other", NULL
29188 };
29189
29190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29192 if (!SWIG_IsOK(res1)) {
29193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29194 }
29195 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29196 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29197 if (!SWIG_IsOK(res2)) {
29198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29199 }
29200 if (!argp2) {
29201 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29202 }
29203 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29204 {
29205 PyThreadState* __tstate = wxPyBeginAllowThreads();
29206 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29207 wxPyEndAllowThreads(__tstate);
29208 if (PyErr_Occurred()) SWIG_fail;
29209 }
29210 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29211 return resultobj;
29212 fail:
29213 return NULL;
29214 }
29215
29216
29217 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29218 PyObject *resultobj = 0;
29219 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29220 int arg2 ;
29221 wxTimeSpan result;
29222 void *argp1 = 0 ;
29223 int res1 = 0 ;
29224 int val2 ;
29225 int ecode2 = 0 ;
29226 PyObject * obj0 = 0 ;
29227 PyObject * obj1 = 0 ;
29228 char * kwnames[] = {
29229 (char *) "self",(char *) "n", NULL
29230 };
29231
29232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29234 if (!SWIG_IsOK(res1)) {
29235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29236 }
29237 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29238 ecode2 = SWIG_AsVal_int(obj1, &val2);
29239 if (!SWIG_IsOK(ecode2)) {
29240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29241 }
29242 arg2 = static_cast< int >(val2);
29243 {
29244 PyThreadState* __tstate = wxPyBeginAllowThreads();
29245 result = wxTimeSpan___mul__(arg1,arg2);
29246 wxPyEndAllowThreads(__tstate);
29247 if (PyErr_Occurred()) SWIG_fail;
29248 }
29249 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29250 return resultobj;
29251 fail:
29252 return NULL;
29253 }
29254
29255
29256 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29257 PyObject *resultobj = 0;
29258 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29259 int arg2 ;
29260 wxTimeSpan result;
29261 void *argp1 = 0 ;
29262 int res1 = 0 ;
29263 int val2 ;
29264 int ecode2 = 0 ;
29265 PyObject * obj0 = 0 ;
29266 PyObject * obj1 = 0 ;
29267 char * kwnames[] = {
29268 (char *) "self",(char *) "n", NULL
29269 };
29270
29271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29273 if (!SWIG_IsOK(res1)) {
29274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29275 }
29276 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29277 ecode2 = SWIG_AsVal_int(obj1, &val2);
29278 if (!SWIG_IsOK(ecode2)) {
29279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29280 }
29281 arg2 = static_cast< int >(val2);
29282 {
29283 PyThreadState* __tstate = wxPyBeginAllowThreads();
29284 result = wxTimeSpan___rmul__(arg1,arg2);
29285 wxPyEndAllowThreads(__tstate);
29286 if (PyErr_Occurred()) SWIG_fail;
29287 }
29288 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29289 return resultobj;
29290 fail:
29291 return NULL;
29292 }
29293
29294
29295 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29296 PyObject *resultobj = 0;
29297 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29298 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29299 bool result;
29300 void *argp1 = 0 ;
29301 int res1 = 0 ;
29302 void *argp2 = 0 ;
29303 int res2 = 0 ;
29304 PyObject * obj0 = 0 ;
29305 PyObject * obj1 = 0 ;
29306 char * kwnames[] = {
29307 (char *) "self",(char *) "other", NULL
29308 };
29309
29310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29312 if (!SWIG_IsOK(res1)) {
29313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29314 }
29315 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29316 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29317 if (!SWIG_IsOK(res2)) {
29318 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29319 }
29320 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29321 {
29322 PyThreadState* __tstate = wxPyBeginAllowThreads();
29323 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29324 wxPyEndAllowThreads(__tstate);
29325 if (PyErr_Occurred()) SWIG_fail;
29326 }
29327 {
29328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29329 }
29330 return resultobj;
29331 fail:
29332 return NULL;
29333 }
29334
29335
29336 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29337 PyObject *resultobj = 0;
29338 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29339 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29340 bool result;
29341 void *argp1 = 0 ;
29342 int res1 = 0 ;
29343 void *argp2 = 0 ;
29344 int res2 = 0 ;
29345 PyObject * obj0 = 0 ;
29346 PyObject * obj1 = 0 ;
29347 char * kwnames[] = {
29348 (char *) "self",(char *) "other", NULL
29349 };
29350
29351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29353 if (!SWIG_IsOK(res1)) {
29354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29355 }
29356 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29357 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29358 if (!SWIG_IsOK(res2)) {
29359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29360 }
29361 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29365 wxPyEndAllowThreads(__tstate);
29366 if (PyErr_Occurred()) SWIG_fail;
29367 }
29368 {
29369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29370 }
29371 return resultobj;
29372 fail:
29373 return NULL;
29374 }
29375
29376
29377 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29378 PyObject *resultobj = 0;
29379 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29380 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29381 bool result;
29382 void *argp1 = 0 ;
29383 int res1 = 0 ;
29384 void *argp2 = 0 ;
29385 int res2 = 0 ;
29386 PyObject * obj0 = 0 ;
29387 PyObject * obj1 = 0 ;
29388 char * kwnames[] = {
29389 (char *) "self",(char *) "other", NULL
29390 };
29391
29392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29394 if (!SWIG_IsOK(res1)) {
29395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29396 }
29397 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29398 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29399 if (!SWIG_IsOK(res2)) {
29400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29401 }
29402 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29403 {
29404 PyThreadState* __tstate = wxPyBeginAllowThreads();
29405 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29406 wxPyEndAllowThreads(__tstate);
29407 if (PyErr_Occurred()) SWIG_fail;
29408 }
29409 {
29410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29411 }
29412 return resultobj;
29413 fail:
29414 return NULL;
29415 }
29416
29417
29418 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29419 PyObject *resultobj = 0;
29420 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29421 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29422 bool result;
29423 void *argp1 = 0 ;
29424 int res1 = 0 ;
29425 void *argp2 = 0 ;
29426 int res2 = 0 ;
29427 PyObject * obj0 = 0 ;
29428 PyObject * obj1 = 0 ;
29429 char * kwnames[] = {
29430 (char *) "self",(char *) "other", NULL
29431 };
29432
29433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29435 if (!SWIG_IsOK(res1)) {
29436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29437 }
29438 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29439 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29440 if (!SWIG_IsOK(res2)) {
29441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29442 }
29443 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29444 {
29445 PyThreadState* __tstate = wxPyBeginAllowThreads();
29446 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29447 wxPyEndAllowThreads(__tstate);
29448 if (PyErr_Occurred()) SWIG_fail;
29449 }
29450 {
29451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29452 }
29453 return resultobj;
29454 fail:
29455 return NULL;
29456 }
29457
29458
29459 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29460 PyObject *resultobj = 0;
29461 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29462 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29463 bool result;
29464 void *argp1 = 0 ;
29465 int res1 = 0 ;
29466 void *argp2 = 0 ;
29467 int res2 = 0 ;
29468 PyObject * obj0 = 0 ;
29469 PyObject * obj1 = 0 ;
29470 char * kwnames[] = {
29471 (char *) "self",(char *) "other", NULL
29472 };
29473
29474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29476 if (!SWIG_IsOK(res1)) {
29477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29478 }
29479 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29480 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29481 if (!SWIG_IsOK(res2)) {
29482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29483 }
29484 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29485 {
29486 PyThreadState* __tstate = wxPyBeginAllowThreads();
29487 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29488 wxPyEndAllowThreads(__tstate);
29489 if (PyErr_Occurred()) SWIG_fail;
29490 }
29491 {
29492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29493 }
29494 return resultobj;
29495 fail:
29496 return NULL;
29497 }
29498
29499
29500 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29501 PyObject *resultobj = 0;
29502 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29503 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29504 bool result;
29505 void *argp1 = 0 ;
29506 int res1 = 0 ;
29507 void *argp2 = 0 ;
29508 int res2 = 0 ;
29509 PyObject * obj0 = 0 ;
29510 PyObject * obj1 = 0 ;
29511 char * kwnames[] = {
29512 (char *) "self",(char *) "other", NULL
29513 };
29514
29515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29517 if (!SWIG_IsOK(res1)) {
29518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29519 }
29520 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29521 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29522 if (!SWIG_IsOK(res2)) {
29523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29524 }
29525 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29526 {
29527 PyThreadState* __tstate = wxPyBeginAllowThreads();
29528 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29529 wxPyEndAllowThreads(__tstate);
29530 if (PyErr_Occurred()) SWIG_fail;
29531 }
29532 {
29533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29534 }
29535 return resultobj;
29536 fail:
29537 return NULL;
29538 }
29539
29540
29541 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29542 PyObject *resultobj = 0;
29543 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29544 bool result;
29545 void *argp1 = 0 ;
29546 int res1 = 0 ;
29547 PyObject *swig_obj[1] ;
29548
29549 if (!args) SWIG_fail;
29550 swig_obj[0] = args;
29551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29552 if (!SWIG_IsOK(res1)) {
29553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29554 }
29555 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29556 {
29557 PyThreadState* __tstate = wxPyBeginAllowThreads();
29558 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29559 wxPyEndAllowThreads(__tstate);
29560 if (PyErr_Occurred()) SWIG_fail;
29561 }
29562 {
29563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29564 }
29565 return resultobj;
29566 fail:
29567 return NULL;
29568 }
29569
29570
29571 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29572 PyObject *resultobj = 0;
29573 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29574 bool result;
29575 void *argp1 = 0 ;
29576 int res1 = 0 ;
29577 PyObject *swig_obj[1] ;
29578
29579 if (!args) SWIG_fail;
29580 swig_obj[0] = args;
29581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29582 if (!SWIG_IsOK(res1)) {
29583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29584 }
29585 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29586 {
29587 PyThreadState* __tstate = wxPyBeginAllowThreads();
29588 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29589 wxPyEndAllowThreads(__tstate);
29590 if (PyErr_Occurred()) SWIG_fail;
29591 }
29592 {
29593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29594 }
29595 return resultobj;
29596 fail:
29597 return NULL;
29598 }
29599
29600
29601 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29602 PyObject *resultobj = 0;
29603 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29604 bool result;
29605 void *argp1 = 0 ;
29606 int res1 = 0 ;
29607 PyObject *swig_obj[1] ;
29608
29609 if (!args) SWIG_fail;
29610 swig_obj[0] = args;
29611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29612 if (!SWIG_IsOK(res1)) {
29613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29614 }
29615 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29616 {
29617 PyThreadState* __tstate = wxPyBeginAllowThreads();
29618 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29619 wxPyEndAllowThreads(__tstate);
29620 if (PyErr_Occurred()) SWIG_fail;
29621 }
29622 {
29623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29624 }
29625 return resultobj;
29626 fail:
29627 return NULL;
29628 }
29629
29630
29631 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29632 PyObject *resultobj = 0;
29633 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29634 wxTimeSpan *arg2 = 0 ;
29635 bool result;
29636 void *argp1 = 0 ;
29637 int res1 = 0 ;
29638 void *argp2 = 0 ;
29639 int res2 = 0 ;
29640 PyObject * obj0 = 0 ;
29641 PyObject * obj1 = 0 ;
29642 char * kwnames[] = {
29643 (char *) "self",(char *) "ts", NULL
29644 };
29645
29646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29648 if (!SWIG_IsOK(res1)) {
29649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29650 }
29651 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29652 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29653 if (!SWIG_IsOK(res2)) {
29654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29655 }
29656 if (!argp2) {
29657 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29658 }
29659 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29660 {
29661 PyThreadState* __tstate = wxPyBeginAllowThreads();
29662 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29663 wxPyEndAllowThreads(__tstate);
29664 if (PyErr_Occurred()) SWIG_fail;
29665 }
29666 {
29667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29668 }
29669 return resultobj;
29670 fail:
29671 return NULL;
29672 }
29673
29674
29675 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29676 PyObject *resultobj = 0;
29677 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29678 wxTimeSpan *arg2 = 0 ;
29679 bool result;
29680 void *argp1 = 0 ;
29681 int res1 = 0 ;
29682 void *argp2 = 0 ;
29683 int res2 = 0 ;
29684 PyObject * obj0 = 0 ;
29685 PyObject * obj1 = 0 ;
29686 char * kwnames[] = {
29687 (char *) "self",(char *) "ts", NULL
29688 };
29689
29690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29692 if (!SWIG_IsOK(res1)) {
29693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29694 }
29695 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29696 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29697 if (!SWIG_IsOK(res2)) {
29698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29699 }
29700 if (!argp2) {
29701 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29702 }
29703 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29704 {
29705 PyThreadState* __tstate = wxPyBeginAllowThreads();
29706 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29707 wxPyEndAllowThreads(__tstate);
29708 if (PyErr_Occurred()) SWIG_fail;
29709 }
29710 {
29711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29712 }
29713 return resultobj;
29714 fail:
29715 return NULL;
29716 }
29717
29718
29719 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29720 PyObject *resultobj = 0;
29721 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29722 wxTimeSpan *arg2 = 0 ;
29723 bool result;
29724 void *argp1 = 0 ;
29725 int res1 = 0 ;
29726 void *argp2 = 0 ;
29727 int res2 = 0 ;
29728 PyObject * obj0 = 0 ;
29729 PyObject * obj1 = 0 ;
29730 char * kwnames[] = {
29731 (char *) "self",(char *) "t", NULL
29732 };
29733
29734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29736 if (!SWIG_IsOK(res1)) {
29737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29738 }
29739 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29740 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29741 if (!SWIG_IsOK(res2)) {
29742 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29743 }
29744 if (!argp2) {
29745 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29746 }
29747 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29748 {
29749 PyThreadState* __tstate = wxPyBeginAllowThreads();
29750 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
29751 wxPyEndAllowThreads(__tstate);
29752 if (PyErr_Occurred()) SWIG_fail;
29753 }
29754 {
29755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29756 }
29757 return resultobj;
29758 fail:
29759 return NULL;
29760 }
29761
29762
29763 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29764 PyObject *resultobj = 0;
29765 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29766 int result;
29767 void *argp1 = 0 ;
29768 int res1 = 0 ;
29769 PyObject *swig_obj[1] ;
29770
29771 if (!args) SWIG_fail;
29772 swig_obj[0] = args;
29773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29774 if (!SWIG_IsOK(res1)) {
29775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29776 }
29777 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29778 {
29779 PyThreadState* __tstate = wxPyBeginAllowThreads();
29780 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
29781 wxPyEndAllowThreads(__tstate);
29782 if (PyErr_Occurred()) SWIG_fail;
29783 }
29784 resultobj = SWIG_From_int(static_cast< int >(result));
29785 return resultobj;
29786 fail:
29787 return NULL;
29788 }
29789
29790
29791 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29792 PyObject *resultobj = 0;
29793 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29794 int result;
29795 void *argp1 = 0 ;
29796 int res1 = 0 ;
29797 PyObject *swig_obj[1] ;
29798
29799 if (!args) SWIG_fail;
29800 swig_obj[0] = args;
29801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29802 if (!SWIG_IsOK(res1)) {
29803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29804 }
29805 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29806 {
29807 PyThreadState* __tstate = wxPyBeginAllowThreads();
29808 result = (int)((wxTimeSpan const *)arg1)->GetDays();
29809 wxPyEndAllowThreads(__tstate);
29810 if (PyErr_Occurred()) SWIG_fail;
29811 }
29812 resultobj = SWIG_From_int(static_cast< int >(result));
29813 return resultobj;
29814 fail:
29815 return NULL;
29816 }
29817
29818
29819 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29820 PyObject *resultobj = 0;
29821 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29822 int result;
29823 void *argp1 = 0 ;
29824 int res1 = 0 ;
29825 PyObject *swig_obj[1] ;
29826
29827 if (!args) SWIG_fail;
29828 swig_obj[0] = args;
29829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29830 if (!SWIG_IsOK(res1)) {
29831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29832 }
29833 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29834 {
29835 PyThreadState* __tstate = wxPyBeginAllowThreads();
29836 result = (int)((wxTimeSpan const *)arg1)->GetHours();
29837 wxPyEndAllowThreads(__tstate);
29838 if (PyErr_Occurred()) SWIG_fail;
29839 }
29840 resultobj = SWIG_From_int(static_cast< int >(result));
29841 return resultobj;
29842 fail:
29843 return NULL;
29844 }
29845
29846
29847 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29848 PyObject *resultobj = 0;
29849 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29850 int result;
29851 void *argp1 = 0 ;
29852 int res1 = 0 ;
29853 PyObject *swig_obj[1] ;
29854
29855 if (!args) SWIG_fail;
29856 swig_obj[0] = args;
29857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29858 if (!SWIG_IsOK(res1)) {
29859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29860 }
29861 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29862 {
29863 PyThreadState* __tstate = wxPyBeginAllowThreads();
29864 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
29865 wxPyEndAllowThreads(__tstate);
29866 if (PyErr_Occurred()) SWIG_fail;
29867 }
29868 resultobj = SWIG_From_int(static_cast< int >(result));
29869 return resultobj;
29870 fail:
29871 return NULL;
29872 }
29873
29874
29875 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29876 PyObject *resultobj = 0;
29877 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29878 wxLongLong result;
29879 void *argp1 = 0 ;
29880 int res1 = 0 ;
29881 PyObject *swig_obj[1] ;
29882
29883 if (!args) SWIG_fail;
29884 swig_obj[0] = args;
29885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29886 if (!SWIG_IsOK(res1)) {
29887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29888 }
29889 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29890 {
29891 PyThreadState* __tstate = wxPyBeginAllowThreads();
29892 result = ((wxTimeSpan const *)arg1)->GetSeconds();
29893 wxPyEndAllowThreads(__tstate);
29894 if (PyErr_Occurred()) SWIG_fail;
29895 }
29896 {
29897 PyObject *hi, *lo, *shifter, *shifted;
29898 hi = PyLong_FromLong( (&result)->GetHi() );
29899 lo = PyLong_FromLong( (&result)->GetLo() );
29900 shifter = PyLong_FromLong(32);
29901 shifted = PyNumber_Lshift(hi, shifter);
29902 resultobj = PyNumber_Or(shifted, lo);
29903 Py_DECREF(hi);
29904 Py_DECREF(lo);
29905 Py_DECREF(shifter);
29906 Py_DECREF(shifted);
29907 }
29908 return resultobj;
29909 fail:
29910 return NULL;
29911 }
29912
29913
29914 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29915 PyObject *resultobj = 0;
29916 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29917 wxLongLong result;
29918 void *argp1 = 0 ;
29919 int res1 = 0 ;
29920 PyObject *swig_obj[1] ;
29921
29922 if (!args) SWIG_fail;
29923 swig_obj[0] = args;
29924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29925 if (!SWIG_IsOK(res1)) {
29926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29927 }
29928 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29929 {
29930 PyThreadState* __tstate = wxPyBeginAllowThreads();
29931 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
29932 wxPyEndAllowThreads(__tstate);
29933 if (PyErr_Occurred()) SWIG_fail;
29934 }
29935 {
29936 PyObject *hi, *lo, *shifter, *shifted;
29937 hi = PyLong_FromLong( (&result)->GetHi() );
29938 lo = PyLong_FromLong( (&result)->GetLo() );
29939 shifter = PyLong_FromLong(32);
29940 shifted = PyNumber_Lshift(hi, shifter);
29941 resultobj = PyNumber_Or(shifted, lo);
29942 Py_DECREF(hi);
29943 Py_DECREF(lo);
29944 Py_DECREF(shifter);
29945 Py_DECREF(shifted);
29946 }
29947 return resultobj;
29948 fail:
29949 return NULL;
29950 }
29951
29952
29953 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29954 PyObject *resultobj = 0;
29955 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29956 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
29957 wxString *arg2 = (wxString *) &arg2_defvalue ;
29958 wxString result;
29959 void *argp1 = 0 ;
29960 int res1 = 0 ;
29961 bool temp2 = false ;
29962 PyObject * obj0 = 0 ;
29963 PyObject * obj1 = 0 ;
29964 char * kwnames[] = {
29965 (char *) "self",(char *) "format", NULL
29966 };
29967
29968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
29969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29970 if (!SWIG_IsOK(res1)) {
29971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29972 }
29973 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29974 if (obj1) {
29975 {
29976 arg2 = wxString_in_helper(obj1);
29977 if (arg2 == NULL) SWIG_fail;
29978 temp2 = true;
29979 }
29980 }
29981 {
29982 PyThreadState* __tstate = wxPyBeginAllowThreads();
29983 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
29984 wxPyEndAllowThreads(__tstate);
29985 if (PyErr_Occurred()) SWIG_fail;
29986 }
29987 {
29988 #if wxUSE_UNICODE
29989 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29990 #else
29991 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29992 #endif
29993 }
29994 {
29995 if (temp2)
29996 delete arg2;
29997 }
29998 return resultobj;
29999 fail:
30000 {
30001 if (temp2)
30002 delete arg2;
30003 }
30004 return NULL;
30005 }
30006
30007
30008 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30009 PyObject *obj;
30010 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30011 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30012 return SWIG_Py_Void();
30013 }
30014
30015 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30016 return SWIG_Python_InitShadowInstance(args);
30017 }
30018
30019 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30020 PyObject *resultobj = 0;
30021 int arg1 = (int) 0 ;
30022 int arg2 = (int) 0 ;
30023 int arg3 = (int) 0 ;
30024 int arg4 = (int) 0 ;
30025 wxDateSpan *result = 0 ;
30026 int val1 ;
30027 int ecode1 = 0 ;
30028 int val2 ;
30029 int ecode2 = 0 ;
30030 int val3 ;
30031 int ecode3 = 0 ;
30032 int val4 ;
30033 int ecode4 = 0 ;
30034 PyObject * obj0 = 0 ;
30035 PyObject * obj1 = 0 ;
30036 PyObject * obj2 = 0 ;
30037 PyObject * obj3 = 0 ;
30038 char * kwnames[] = {
30039 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30040 };
30041
30042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30043 if (obj0) {
30044 ecode1 = SWIG_AsVal_int(obj0, &val1);
30045 if (!SWIG_IsOK(ecode1)) {
30046 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30047 }
30048 arg1 = static_cast< int >(val1);
30049 }
30050 if (obj1) {
30051 ecode2 = SWIG_AsVal_int(obj1, &val2);
30052 if (!SWIG_IsOK(ecode2)) {
30053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30054 }
30055 arg2 = static_cast< int >(val2);
30056 }
30057 if (obj2) {
30058 ecode3 = SWIG_AsVal_int(obj2, &val3);
30059 if (!SWIG_IsOK(ecode3)) {
30060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30061 }
30062 arg3 = static_cast< int >(val3);
30063 }
30064 if (obj3) {
30065 ecode4 = SWIG_AsVal_int(obj3, &val4);
30066 if (!SWIG_IsOK(ecode4)) {
30067 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30068 }
30069 arg4 = static_cast< int >(val4);
30070 }
30071 {
30072 PyThreadState* __tstate = wxPyBeginAllowThreads();
30073 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30074 wxPyEndAllowThreads(__tstate);
30075 if (PyErr_Occurred()) SWIG_fail;
30076 }
30077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30078 return resultobj;
30079 fail:
30080 return NULL;
30081 }
30082
30083
30084 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30085 PyObject *resultobj = 0;
30086 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30087 void *argp1 = 0 ;
30088 int res1 = 0 ;
30089 PyObject *swig_obj[1] ;
30090
30091 if (!args) SWIG_fail;
30092 swig_obj[0] = args;
30093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30094 if (!SWIG_IsOK(res1)) {
30095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30096 }
30097 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30098 {
30099 PyThreadState* __tstate = wxPyBeginAllowThreads();
30100 delete arg1;
30101
30102 wxPyEndAllowThreads(__tstate);
30103 if (PyErr_Occurred()) SWIG_fail;
30104 }
30105 resultobj = SWIG_Py_Void();
30106 return resultobj;
30107 fail:
30108 return NULL;
30109 }
30110
30111
30112 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30113 PyObject *resultobj = 0;
30114 int arg1 ;
30115 wxDateSpan result;
30116 int val1 ;
30117 int ecode1 = 0 ;
30118 PyObject * obj0 = 0 ;
30119 char * kwnames[] = {
30120 (char *) "days", NULL
30121 };
30122
30123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30124 ecode1 = SWIG_AsVal_int(obj0, &val1);
30125 if (!SWIG_IsOK(ecode1)) {
30126 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30127 }
30128 arg1 = static_cast< int >(val1);
30129 {
30130 PyThreadState* __tstate = wxPyBeginAllowThreads();
30131 result = wxDateSpan::Days(arg1);
30132 wxPyEndAllowThreads(__tstate);
30133 if (PyErr_Occurred()) SWIG_fail;
30134 }
30135 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30136 return resultobj;
30137 fail:
30138 return NULL;
30139 }
30140
30141
30142 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30143 PyObject *resultobj = 0;
30144 wxDateSpan result;
30145
30146 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30147 {
30148 PyThreadState* __tstate = wxPyBeginAllowThreads();
30149 result = wxDateSpan::Day();
30150 wxPyEndAllowThreads(__tstate);
30151 if (PyErr_Occurred()) SWIG_fail;
30152 }
30153 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30154 return resultobj;
30155 fail:
30156 return NULL;
30157 }
30158
30159
30160 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30161 PyObject *resultobj = 0;
30162 int arg1 ;
30163 wxDateSpan result;
30164 int val1 ;
30165 int ecode1 = 0 ;
30166 PyObject * obj0 = 0 ;
30167 char * kwnames[] = {
30168 (char *) "weeks", NULL
30169 };
30170
30171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30172 ecode1 = SWIG_AsVal_int(obj0, &val1);
30173 if (!SWIG_IsOK(ecode1)) {
30174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30175 }
30176 arg1 = static_cast< int >(val1);
30177 {
30178 PyThreadState* __tstate = wxPyBeginAllowThreads();
30179 result = wxDateSpan::Weeks(arg1);
30180 wxPyEndAllowThreads(__tstate);
30181 if (PyErr_Occurred()) SWIG_fail;
30182 }
30183 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30184 return resultobj;
30185 fail:
30186 return NULL;
30187 }
30188
30189
30190 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30191 PyObject *resultobj = 0;
30192 wxDateSpan result;
30193
30194 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30195 {
30196 PyThreadState* __tstate = wxPyBeginAllowThreads();
30197 result = wxDateSpan::Week();
30198 wxPyEndAllowThreads(__tstate);
30199 if (PyErr_Occurred()) SWIG_fail;
30200 }
30201 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30202 return resultobj;
30203 fail:
30204 return NULL;
30205 }
30206
30207
30208 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30209 PyObject *resultobj = 0;
30210 int arg1 ;
30211 wxDateSpan result;
30212 int val1 ;
30213 int ecode1 = 0 ;
30214 PyObject * obj0 = 0 ;
30215 char * kwnames[] = {
30216 (char *) "mon", NULL
30217 };
30218
30219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30220 ecode1 = SWIG_AsVal_int(obj0, &val1);
30221 if (!SWIG_IsOK(ecode1)) {
30222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30223 }
30224 arg1 = static_cast< int >(val1);
30225 {
30226 PyThreadState* __tstate = wxPyBeginAllowThreads();
30227 result = wxDateSpan::Months(arg1);
30228 wxPyEndAllowThreads(__tstate);
30229 if (PyErr_Occurred()) SWIG_fail;
30230 }
30231 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30232 return resultobj;
30233 fail:
30234 return NULL;
30235 }
30236
30237
30238 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30239 PyObject *resultobj = 0;
30240 wxDateSpan result;
30241
30242 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30243 {
30244 PyThreadState* __tstate = wxPyBeginAllowThreads();
30245 result = wxDateSpan::Month();
30246 wxPyEndAllowThreads(__tstate);
30247 if (PyErr_Occurred()) SWIG_fail;
30248 }
30249 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30250 return resultobj;
30251 fail:
30252 return NULL;
30253 }
30254
30255
30256 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30257 PyObject *resultobj = 0;
30258 int arg1 ;
30259 wxDateSpan result;
30260 int val1 ;
30261 int ecode1 = 0 ;
30262 PyObject * obj0 = 0 ;
30263 char * kwnames[] = {
30264 (char *) "years", NULL
30265 };
30266
30267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30268 ecode1 = SWIG_AsVal_int(obj0, &val1);
30269 if (!SWIG_IsOK(ecode1)) {
30270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30271 }
30272 arg1 = static_cast< int >(val1);
30273 {
30274 PyThreadState* __tstate = wxPyBeginAllowThreads();
30275 result = wxDateSpan::Years(arg1);
30276 wxPyEndAllowThreads(__tstate);
30277 if (PyErr_Occurred()) SWIG_fail;
30278 }
30279 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30280 return resultobj;
30281 fail:
30282 return NULL;
30283 }
30284
30285
30286 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30287 PyObject *resultobj = 0;
30288 wxDateSpan result;
30289
30290 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30291 {
30292 PyThreadState* __tstate = wxPyBeginAllowThreads();
30293 result = wxDateSpan::Year();
30294 wxPyEndAllowThreads(__tstate);
30295 if (PyErr_Occurred()) SWIG_fail;
30296 }
30297 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30298 return resultobj;
30299 fail:
30300 return NULL;
30301 }
30302
30303
30304 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30305 PyObject *resultobj = 0;
30306 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30307 int arg2 ;
30308 wxDateSpan *result = 0 ;
30309 void *argp1 = 0 ;
30310 int res1 = 0 ;
30311 int val2 ;
30312 int ecode2 = 0 ;
30313 PyObject * obj0 = 0 ;
30314 PyObject * obj1 = 0 ;
30315 char * kwnames[] = {
30316 (char *) "self",(char *) "n", NULL
30317 };
30318
30319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30321 if (!SWIG_IsOK(res1)) {
30322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30323 }
30324 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30325 ecode2 = SWIG_AsVal_int(obj1, &val2);
30326 if (!SWIG_IsOK(ecode2)) {
30327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30328 }
30329 arg2 = static_cast< int >(val2);
30330 {
30331 PyThreadState* __tstate = wxPyBeginAllowThreads();
30332 {
30333 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30334 result = (wxDateSpan *) &_result_ref;
30335 }
30336 wxPyEndAllowThreads(__tstate);
30337 if (PyErr_Occurred()) SWIG_fail;
30338 }
30339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30340 return resultobj;
30341 fail:
30342 return NULL;
30343 }
30344
30345
30346 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30347 PyObject *resultobj = 0;
30348 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30349 int arg2 ;
30350 wxDateSpan *result = 0 ;
30351 void *argp1 = 0 ;
30352 int res1 = 0 ;
30353 int val2 ;
30354 int ecode2 = 0 ;
30355 PyObject * obj0 = 0 ;
30356 PyObject * obj1 = 0 ;
30357 char * kwnames[] = {
30358 (char *) "self",(char *) "n", NULL
30359 };
30360
30361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30363 if (!SWIG_IsOK(res1)) {
30364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30365 }
30366 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30367 ecode2 = SWIG_AsVal_int(obj1, &val2);
30368 if (!SWIG_IsOK(ecode2)) {
30369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30370 }
30371 arg2 = static_cast< int >(val2);
30372 {
30373 PyThreadState* __tstate = wxPyBeginAllowThreads();
30374 {
30375 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30376 result = (wxDateSpan *) &_result_ref;
30377 }
30378 wxPyEndAllowThreads(__tstate);
30379 if (PyErr_Occurred()) SWIG_fail;
30380 }
30381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30382 return resultobj;
30383 fail:
30384 return NULL;
30385 }
30386
30387
30388 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30389 PyObject *resultobj = 0;
30390 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30391 int arg2 ;
30392 wxDateSpan *result = 0 ;
30393 void *argp1 = 0 ;
30394 int res1 = 0 ;
30395 int val2 ;
30396 int ecode2 = 0 ;
30397 PyObject * obj0 = 0 ;
30398 PyObject * obj1 = 0 ;
30399 char * kwnames[] = {
30400 (char *) "self",(char *) "n", NULL
30401 };
30402
30403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30405 if (!SWIG_IsOK(res1)) {
30406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30407 }
30408 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30409 ecode2 = SWIG_AsVal_int(obj1, &val2);
30410 if (!SWIG_IsOK(ecode2)) {
30411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30412 }
30413 arg2 = static_cast< int >(val2);
30414 {
30415 PyThreadState* __tstate = wxPyBeginAllowThreads();
30416 {
30417 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30418 result = (wxDateSpan *) &_result_ref;
30419 }
30420 wxPyEndAllowThreads(__tstate);
30421 if (PyErr_Occurred()) SWIG_fail;
30422 }
30423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30424 return resultobj;
30425 fail:
30426 return NULL;
30427 }
30428
30429
30430 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30431 PyObject *resultobj = 0;
30432 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30433 int arg2 ;
30434 wxDateSpan *result = 0 ;
30435 void *argp1 = 0 ;
30436 int res1 = 0 ;
30437 int val2 ;
30438 int ecode2 = 0 ;
30439 PyObject * obj0 = 0 ;
30440 PyObject * obj1 = 0 ;
30441 char * kwnames[] = {
30442 (char *) "self",(char *) "n", NULL
30443 };
30444
30445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30447 if (!SWIG_IsOK(res1)) {
30448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30449 }
30450 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30451 ecode2 = SWIG_AsVal_int(obj1, &val2);
30452 if (!SWIG_IsOK(ecode2)) {
30453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30454 }
30455 arg2 = static_cast< int >(val2);
30456 {
30457 PyThreadState* __tstate = wxPyBeginAllowThreads();
30458 {
30459 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30460 result = (wxDateSpan *) &_result_ref;
30461 }
30462 wxPyEndAllowThreads(__tstate);
30463 if (PyErr_Occurred()) SWIG_fail;
30464 }
30465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30466 return resultobj;
30467 fail:
30468 return NULL;
30469 }
30470
30471
30472 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30473 PyObject *resultobj = 0;
30474 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30475 int result;
30476 void *argp1 = 0 ;
30477 int res1 = 0 ;
30478 PyObject *swig_obj[1] ;
30479
30480 if (!args) SWIG_fail;
30481 swig_obj[0] = args;
30482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30483 if (!SWIG_IsOK(res1)) {
30484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30485 }
30486 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30487 {
30488 PyThreadState* __tstate = wxPyBeginAllowThreads();
30489 result = (int)((wxDateSpan const *)arg1)->GetYears();
30490 wxPyEndAllowThreads(__tstate);
30491 if (PyErr_Occurred()) SWIG_fail;
30492 }
30493 resultobj = SWIG_From_int(static_cast< int >(result));
30494 return resultobj;
30495 fail:
30496 return NULL;
30497 }
30498
30499
30500 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30501 PyObject *resultobj = 0;
30502 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30503 int result;
30504 void *argp1 = 0 ;
30505 int res1 = 0 ;
30506 PyObject *swig_obj[1] ;
30507
30508 if (!args) SWIG_fail;
30509 swig_obj[0] = args;
30510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30511 if (!SWIG_IsOK(res1)) {
30512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30513 }
30514 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30515 {
30516 PyThreadState* __tstate = wxPyBeginAllowThreads();
30517 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30518 wxPyEndAllowThreads(__tstate);
30519 if (PyErr_Occurred()) SWIG_fail;
30520 }
30521 resultobj = SWIG_From_int(static_cast< int >(result));
30522 return resultobj;
30523 fail:
30524 return NULL;
30525 }
30526
30527
30528 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30529 PyObject *resultobj = 0;
30530 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30531 int result;
30532 void *argp1 = 0 ;
30533 int res1 = 0 ;
30534 PyObject *swig_obj[1] ;
30535
30536 if (!args) SWIG_fail;
30537 swig_obj[0] = args;
30538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30539 if (!SWIG_IsOK(res1)) {
30540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30541 }
30542 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30543 {
30544 PyThreadState* __tstate = wxPyBeginAllowThreads();
30545 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30546 wxPyEndAllowThreads(__tstate);
30547 if (PyErr_Occurred()) SWIG_fail;
30548 }
30549 resultobj = SWIG_From_int(static_cast< int >(result));
30550 return resultobj;
30551 fail:
30552 return NULL;
30553 }
30554
30555
30556 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30557 PyObject *resultobj = 0;
30558 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30559 int result;
30560 void *argp1 = 0 ;
30561 int res1 = 0 ;
30562 PyObject *swig_obj[1] ;
30563
30564 if (!args) SWIG_fail;
30565 swig_obj[0] = args;
30566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30567 if (!SWIG_IsOK(res1)) {
30568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30569 }
30570 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30571 {
30572 PyThreadState* __tstate = wxPyBeginAllowThreads();
30573 result = (int)((wxDateSpan const *)arg1)->GetDays();
30574 wxPyEndAllowThreads(__tstate);
30575 if (PyErr_Occurred()) SWIG_fail;
30576 }
30577 resultobj = SWIG_From_int(static_cast< int >(result));
30578 return resultobj;
30579 fail:
30580 return NULL;
30581 }
30582
30583
30584 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30585 PyObject *resultobj = 0;
30586 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30587 int result;
30588 void *argp1 = 0 ;
30589 int res1 = 0 ;
30590 PyObject *swig_obj[1] ;
30591
30592 if (!args) SWIG_fail;
30593 swig_obj[0] = args;
30594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30595 if (!SWIG_IsOK(res1)) {
30596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30597 }
30598 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30599 {
30600 PyThreadState* __tstate = wxPyBeginAllowThreads();
30601 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30602 wxPyEndAllowThreads(__tstate);
30603 if (PyErr_Occurred()) SWIG_fail;
30604 }
30605 resultobj = SWIG_From_int(static_cast< int >(result));
30606 return resultobj;
30607 fail:
30608 return NULL;
30609 }
30610
30611
30612 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30613 PyObject *resultobj = 0;
30614 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30615 wxDateSpan *arg2 = 0 ;
30616 wxDateSpan *result = 0 ;
30617 void *argp1 = 0 ;
30618 int res1 = 0 ;
30619 void *argp2 = 0 ;
30620 int res2 = 0 ;
30621 PyObject * obj0 = 0 ;
30622 PyObject * obj1 = 0 ;
30623 char * kwnames[] = {
30624 (char *) "self",(char *) "other", NULL
30625 };
30626
30627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30629 if (!SWIG_IsOK(res1)) {
30630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30631 }
30632 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30633 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30634 if (!SWIG_IsOK(res2)) {
30635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30636 }
30637 if (!argp2) {
30638 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30639 }
30640 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30641 {
30642 PyThreadState* __tstate = wxPyBeginAllowThreads();
30643 {
30644 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30645 result = (wxDateSpan *) &_result_ref;
30646 }
30647 wxPyEndAllowThreads(__tstate);
30648 if (PyErr_Occurred()) SWIG_fail;
30649 }
30650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30651 return resultobj;
30652 fail:
30653 return NULL;
30654 }
30655
30656
30657 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30658 PyObject *resultobj = 0;
30659 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30660 wxDateSpan *arg2 = 0 ;
30661 wxDateSpan *result = 0 ;
30662 void *argp1 = 0 ;
30663 int res1 = 0 ;
30664 void *argp2 = 0 ;
30665 int res2 = 0 ;
30666 PyObject * obj0 = 0 ;
30667 PyObject * obj1 = 0 ;
30668 char * kwnames[] = {
30669 (char *) "self",(char *) "other", NULL
30670 };
30671
30672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30674 if (!SWIG_IsOK(res1)) {
30675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30676 }
30677 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30678 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30679 if (!SWIG_IsOK(res2)) {
30680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30681 }
30682 if (!argp2) {
30683 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30684 }
30685 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30686 {
30687 PyThreadState* __tstate = wxPyBeginAllowThreads();
30688 {
30689 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30690 result = (wxDateSpan *) &_result_ref;
30691 }
30692 wxPyEndAllowThreads(__tstate);
30693 if (PyErr_Occurred()) SWIG_fail;
30694 }
30695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30696 return resultobj;
30697 fail:
30698 return NULL;
30699 }
30700
30701
30702 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30703 PyObject *resultobj = 0;
30704 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30705 wxDateSpan *result = 0 ;
30706 void *argp1 = 0 ;
30707 int res1 = 0 ;
30708 PyObject *swig_obj[1] ;
30709
30710 if (!args) SWIG_fail;
30711 swig_obj[0] = args;
30712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30713 if (!SWIG_IsOK(res1)) {
30714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30715 }
30716 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30717 {
30718 PyThreadState* __tstate = wxPyBeginAllowThreads();
30719 {
30720 wxDateSpan &_result_ref = (arg1)->Neg();
30721 result = (wxDateSpan *) &_result_ref;
30722 }
30723 wxPyEndAllowThreads(__tstate);
30724 if (PyErr_Occurred()) SWIG_fail;
30725 }
30726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30727 return resultobj;
30728 fail:
30729 return NULL;
30730 }
30731
30732
30733 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30734 PyObject *resultobj = 0;
30735 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30736 int arg2 ;
30737 wxDateSpan *result = 0 ;
30738 void *argp1 = 0 ;
30739 int res1 = 0 ;
30740 int val2 ;
30741 int ecode2 = 0 ;
30742 PyObject * obj0 = 0 ;
30743 PyObject * obj1 = 0 ;
30744 char * kwnames[] = {
30745 (char *) "self",(char *) "factor", NULL
30746 };
30747
30748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
30749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30750 if (!SWIG_IsOK(res1)) {
30751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30752 }
30753 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30754 ecode2 = SWIG_AsVal_int(obj1, &val2);
30755 if (!SWIG_IsOK(ecode2)) {
30756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
30757 }
30758 arg2 = static_cast< int >(val2);
30759 {
30760 PyThreadState* __tstate = wxPyBeginAllowThreads();
30761 {
30762 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
30763 result = (wxDateSpan *) &_result_ref;
30764 }
30765 wxPyEndAllowThreads(__tstate);
30766 if (PyErr_Occurred()) SWIG_fail;
30767 }
30768 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30769 return resultobj;
30770 fail:
30771 return NULL;
30772 }
30773
30774
30775 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30776 PyObject *resultobj = 0;
30777 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30778 wxDateSpan *arg2 = 0 ;
30779 wxDateSpan *result = 0 ;
30780 void *argp1 = 0 ;
30781 int res1 = 0 ;
30782 void *argp2 = 0 ;
30783 int res2 = 0 ;
30784 PyObject * obj0 = 0 ;
30785 PyObject * obj1 = 0 ;
30786 char * kwnames[] = {
30787 (char *) "self",(char *) "other", NULL
30788 };
30789
30790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
30791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30792 if (!SWIG_IsOK(res1)) {
30793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30794 }
30795 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30796 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30797 if (!SWIG_IsOK(res2)) {
30798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30799 }
30800 if (!argp2) {
30801 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30802 }
30803 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30804 {
30805 PyThreadState* __tstate = wxPyBeginAllowThreads();
30806 {
30807 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
30808 result = (wxDateSpan *) &_result_ref;
30809 }
30810 wxPyEndAllowThreads(__tstate);
30811 if (PyErr_Occurred()) SWIG_fail;
30812 }
30813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30814 return resultobj;
30815 fail:
30816 return NULL;
30817 }
30818
30819
30820 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30821 PyObject *resultobj = 0;
30822 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30823 wxDateSpan *arg2 = 0 ;
30824 wxDateSpan *result = 0 ;
30825 void *argp1 = 0 ;
30826 int res1 = 0 ;
30827 void *argp2 = 0 ;
30828 int res2 = 0 ;
30829 PyObject * obj0 = 0 ;
30830 PyObject * obj1 = 0 ;
30831 char * kwnames[] = {
30832 (char *) "self",(char *) "other", NULL
30833 };
30834
30835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
30836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30837 if (!SWIG_IsOK(res1)) {
30838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30839 }
30840 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30841 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30842 if (!SWIG_IsOK(res2)) {
30843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30844 }
30845 if (!argp2) {
30846 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30847 }
30848 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30849 {
30850 PyThreadState* __tstate = wxPyBeginAllowThreads();
30851 {
30852 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
30853 result = (wxDateSpan *) &_result_ref;
30854 }
30855 wxPyEndAllowThreads(__tstate);
30856 if (PyErr_Occurred()) SWIG_fail;
30857 }
30858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30859 return resultobj;
30860 fail:
30861 return NULL;
30862 }
30863
30864
30865 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30866 PyObject *resultobj = 0;
30867 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30868 wxDateSpan *result = 0 ;
30869 void *argp1 = 0 ;
30870 int res1 = 0 ;
30871 PyObject *swig_obj[1] ;
30872
30873 if (!args) SWIG_fail;
30874 swig_obj[0] = args;
30875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30876 if (!SWIG_IsOK(res1)) {
30877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30878 }
30879 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30880 {
30881 PyThreadState* __tstate = wxPyBeginAllowThreads();
30882 {
30883 wxDateSpan &_result_ref = (arg1)->operator -();
30884 result = (wxDateSpan *) &_result_ref;
30885 }
30886 wxPyEndAllowThreads(__tstate);
30887 if (PyErr_Occurred()) SWIG_fail;
30888 }
30889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30890 return resultobj;
30891 fail:
30892 return NULL;
30893 }
30894
30895
30896 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30897 PyObject *resultobj = 0;
30898 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30899 int arg2 ;
30900 wxDateSpan *result = 0 ;
30901 void *argp1 = 0 ;
30902 int res1 = 0 ;
30903 int val2 ;
30904 int ecode2 = 0 ;
30905 PyObject * obj0 = 0 ;
30906 PyObject * obj1 = 0 ;
30907 char * kwnames[] = {
30908 (char *) "self",(char *) "factor", NULL
30909 };
30910
30911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
30912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30913 if (!SWIG_IsOK(res1)) {
30914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30915 }
30916 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30917 ecode2 = SWIG_AsVal_int(obj1, &val2);
30918 if (!SWIG_IsOK(ecode2)) {
30919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
30920 }
30921 arg2 = static_cast< int >(val2);
30922 {
30923 PyThreadState* __tstate = wxPyBeginAllowThreads();
30924 {
30925 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
30926 result = (wxDateSpan *) &_result_ref;
30927 }
30928 wxPyEndAllowThreads(__tstate);
30929 if (PyErr_Occurred()) SWIG_fail;
30930 }
30931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30932 return resultobj;
30933 fail:
30934 return NULL;
30935 }
30936
30937
30938 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30939 PyObject *resultobj = 0;
30940 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30941 wxDateSpan *arg2 = 0 ;
30942 wxDateSpan result;
30943 void *argp1 = 0 ;
30944 int res1 = 0 ;
30945 void *argp2 = 0 ;
30946 int res2 = 0 ;
30947 PyObject * obj0 = 0 ;
30948 PyObject * obj1 = 0 ;
30949 char * kwnames[] = {
30950 (char *) "self",(char *) "other", NULL
30951 };
30952
30953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
30954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30955 if (!SWIG_IsOK(res1)) {
30956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30957 }
30958 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30959 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30960 if (!SWIG_IsOK(res2)) {
30961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30962 }
30963 if (!argp2) {
30964 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30965 }
30966 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30967 {
30968 PyThreadState* __tstate = wxPyBeginAllowThreads();
30969 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
30970 wxPyEndAllowThreads(__tstate);
30971 if (PyErr_Occurred()) SWIG_fail;
30972 }
30973 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30974 return resultobj;
30975 fail:
30976 return NULL;
30977 }
30978
30979
30980 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30981 PyObject *resultobj = 0;
30982 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30983 wxDateSpan *arg2 = 0 ;
30984 wxDateSpan result;
30985 void *argp1 = 0 ;
30986 int res1 = 0 ;
30987 void *argp2 = 0 ;
30988 int res2 = 0 ;
30989 PyObject * obj0 = 0 ;
30990 PyObject * obj1 = 0 ;
30991 char * kwnames[] = {
30992 (char *) "self",(char *) "other", NULL
30993 };
30994
30995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
30996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30997 if (!SWIG_IsOK(res1)) {
30998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30999 }
31000 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31001 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31002 if (!SWIG_IsOK(res2)) {
31003 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31004 }
31005 if (!argp2) {
31006 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31007 }
31008 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31009 {
31010 PyThreadState* __tstate = wxPyBeginAllowThreads();
31011 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31012 wxPyEndAllowThreads(__tstate);
31013 if (PyErr_Occurred()) SWIG_fail;
31014 }
31015 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31016 return resultobj;
31017 fail:
31018 return NULL;
31019 }
31020
31021
31022 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31023 PyObject *resultobj = 0;
31024 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31025 int arg2 ;
31026 wxDateSpan result;
31027 void *argp1 = 0 ;
31028 int res1 = 0 ;
31029 int val2 ;
31030 int ecode2 = 0 ;
31031 PyObject * obj0 = 0 ;
31032 PyObject * obj1 = 0 ;
31033 char * kwnames[] = {
31034 (char *) "self",(char *) "n", NULL
31035 };
31036
31037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31039 if (!SWIG_IsOK(res1)) {
31040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31041 }
31042 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31043 ecode2 = SWIG_AsVal_int(obj1, &val2);
31044 if (!SWIG_IsOK(ecode2)) {
31045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31046 }
31047 arg2 = static_cast< int >(val2);
31048 {
31049 PyThreadState* __tstate = wxPyBeginAllowThreads();
31050 result = wxDateSpan___mul__(arg1,arg2);
31051 wxPyEndAllowThreads(__tstate);
31052 if (PyErr_Occurred()) SWIG_fail;
31053 }
31054 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31055 return resultobj;
31056 fail:
31057 return NULL;
31058 }
31059
31060
31061 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31062 PyObject *resultobj = 0;
31063 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31064 int arg2 ;
31065 wxDateSpan result;
31066 void *argp1 = 0 ;
31067 int res1 = 0 ;
31068 int val2 ;
31069 int ecode2 = 0 ;
31070 PyObject * obj0 = 0 ;
31071 PyObject * obj1 = 0 ;
31072 char * kwnames[] = {
31073 (char *) "self",(char *) "n", NULL
31074 };
31075
31076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31078 if (!SWIG_IsOK(res1)) {
31079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31080 }
31081 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31082 ecode2 = SWIG_AsVal_int(obj1, &val2);
31083 if (!SWIG_IsOK(ecode2)) {
31084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31085 }
31086 arg2 = static_cast< int >(val2);
31087 {
31088 PyThreadState* __tstate = wxPyBeginAllowThreads();
31089 result = wxDateSpan___rmul__(arg1,arg2);
31090 wxPyEndAllowThreads(__tstate);
31091 if (PyErr_Occurred()) SWIG_fail;
31092 }
31093 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31094 return resultobj;
31095 fail:
31096 return NULL;
31097 }
31098
31099
31100 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31101 PyObject *resultobj = 0;
31102 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31103 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31104 bool result;
31105 void *argp1 = 0 ;
31106 int res1 = 0 ;
31107 void *argp2 = 0 ;
31108 int res2 = 0 ;
31109 PyObject * obj0 = 0 ;
31110 PyObject * obj1 = 0 ;
31111 char * kwnames[] = {
31112 (char *) "self",(char *) "other", NULL
31113 };
31114
31115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31117 if (!SWIG_IsOK(res1)) {
31118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31119 }
31120 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31121 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31122 if (!SWIG_IsOK(res2)) {
31123 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31124 }
31125 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31126 {
31127 PyThreadState* __tstate = wxPyBeginAllowThreads();
31128 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31129 wxPyEndAllowThreads(__tstate);
31130 if (PyErr_Occurred()) SWIG_fail;
31131 }
31132 {
31133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31134 }
31135 return resultobj;
31136 fail:
31137 return NULL;
31138 }
31139
31140
31141 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31142 PyObject *resultobj = 0;
31143 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31144 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31145 bool result;
31146 void *argp1 = 0 ;
31147 int res1 = 0 ;
31148 void *argp2 = 0 ;
31149 int res2 = 0 ;
31150 PyObject * obj0 = 0 ;
31151 PyObject * obj1 = 0 ;
31152 char * kwnames[] = {
31153 (char *) "self",(char *) "other", NULL
31154 };
31155
31156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31158 if (!SWIG_IsOK(res1)) {
31159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31160 }
31161 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31162 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31163 if (!SWIG_IsOK(res2)) {
31164 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31165 }
31166 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31167 {
31168 PyThreadState* __tstate = wxPyBeginAllowThreads();
31169 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31170 wxPyEndAllowThreads(__tstate);
31171 if (PyErr_Occurred()) SWIG_fail;
31172 }
31173 {
31174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31175 }
31176 return resultobj;
31177 fail:
31178 return NULL;
31179 }
31180
31181
31182 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31183 PyObject *obj;
31184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31185 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31186 return SWIG_Py_Void();
31187 }
31188
31189 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31190 return SWIG_Python_InitShadowInstance(args);
31191 }
31192
31193 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31194 PyObject *resultobj = 0;
31195 long result;
31196
31197 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31198 {
31199 PyThreadState* __tstate = wxPyBeginAllowThreads();
31200 result = (long)wxGetLocalTime();
31201 wxPyEndAllowThreads(__tstate);
31202 if (PyErr_Occurred()) SWIG_fail;
31203 }
31204 resultobj = SWIG_From_long(static_cast< long >(result));
31205 return resultobj;
31206 fail:
31207 return NULL;
31208 }
31209
31210
31211 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31212 PyObject *resultobj = 0;
31213 long result;
31214
31215 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31216 {
31217 PyThreadState* __tstate = wxPyBeginAllowThreads();
31218 result = (long)wxGetUTCTime();
31219 wxPyEndAllowThreads(__tstate);
31220 if (PyErr_Occurred()) SWIG_fail;
31221 }
31222 resultobj = SWIG_From_long(static_cast< long >(result));
31223 return resultobj;
31224 fail:
31225 return NULL;
31226 }
31227
31228
31229 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31230 PyObject *resultobj = 0;
31231 long result;
31232
31233 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31234 {
31235 PyThreadState* __tstate = wxPyBeginAllowThreads();
31236 result = (long)wxGetCurrentTime();
31237 wxPyEndAllowThreads(__tstate);
31238 if (PyErr_Occurred()) SWIG_fail;
31239 }
31240 resultobj = SWIG_From_long(static_cast< long >(result));
31241 return resultobj;
31242 fail:
31243 return NULL;
31244 }
31245
31246
31247 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31248 PyObject *resultobj = 0;
31249 wxLongLong result;
31250
31251 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31252 {
31253 PyThreadState* __tstate = wxPyBeginAllowThreads();
31254 result = wxGetLocalTimeMillis();
31255 wxPyEndAllowThreads(__tstate);
31256 if (PyErr_Occurred()) SWIG_fail;
31257 }
31258 {
31259 PyObject *hi, *lo, *shifter, *shifted;
31260 hi = PyLong_FromLong( (&result)->GetHi() );
31261 lo = PyLong_FromLong( (&result)->GetLo() );
31262 shifter = PyLong_FromLong(32);
31263 shifted = PyNumber_Lshift(hi, shifter);
31264 resultobj = PyNumber_Or(shifted, lo);
31265 Py_DECREF(hi);
31266 Py_DECREF(lo);
31267 Py_DECREF(shifter);
31268 Py_DECREF(shifted);
31269 }
31270 return resultobj;
31271 fail:
31272 return NULL;
31273 }
31274
31275
31276 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31277 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31278 return 1;
31279 }
31280
31281
31282 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31283 PyObject *pyobj = 0;
31284
31285 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31286 return pyobj;
31287 }
31288
31289
31290 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31291 PyObject *resultobj = 0;
31292 wxDataFormatId arg1 ;
31293 wxDataFormat *result = 0 ;
31294 int val1 ;
31295 int ecode1 = 0 ;
31296 PyObject * obj0 = 0 ;
31297 char * kwnames[] = {
31298 (char *) "type", NULL
31299 };
31300
31301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31302 ecode1 = SWIG_AsVal_int(obj0, &val1);
31303 if (!SWIG_IsOK(ecode1)) {
31304 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31305 }
31306 arg1 = static_cast< wxDataFormatId >(val1);
31307 {
31308 PyThreadState* __tstate = wxPyBeginAllowThreads();
31309 result = (wxDataFormat *)new wxDataFormat(arg1);
31310 wxPyEndAllowThreads(__tstate);
31311 if (PyErr_Occurred()) SWIG_fail;
31312 }
31313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31314 return resultobj;
31315 fail:
31316 return NULL;
31317 }
31318
31319
31320 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31321 PyObject *resultobj = 0;
31322 wxString *arg1 = 0 ;
31323 wxDataFormat *result = 0 ;
31324 bool temp1 = false ;
31325 PyObject * obj0 = 0 ;
31326 char * kwnames[] = {
31327 (char *) "format", NULL
31328 };
31329
31330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31331 {
31332 arg1 = wxString_in_helper(obj0);
31333 if (arg1 == NULL) SWIG_fail;
31334 temp1 = true;
31335 }
31336 {
31337 PyThreadState* __tstate = wxPyBeginAllowThreads();
31338 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31339 wxPyEndAllowThreads(__tstate);
31340 if (PyErr_Occurred()) SWIG_fail;
31341 }
31342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31343 {
31344 if (temp1)
31345 delete arg1;
31346 }
31347 return resultobj;
31348 fail:
31349 {
31350 if (temp1)
31351 delete arg1;
31352 }
31353 return NULL;
31354 }
31355
31356
31357 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31358 PyObject *resultobj = 0;
31359 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31360 void *argp1 = 0 ;
31361 int res1 = 0 ;
31362 PyObject *swig_obj[1] ;
31363
31364 if (!args) SWIG_fail;
31365 swig_obj[0] = args;
31366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31367 if (!SWIG_IsOK(res1)) {
31368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31369 }
31370 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31371 {
31372 PyThreadState* __tstate = wxPyBeginAllowThreads();
31373 delete arg1;
31374
31375 wxPyEndAllowThreads(__tstate);
31376 if (PyErr_Occurred()) SWIG_fail;
31377 }
31378 resultobj = SWIG_Py_Void();
31379 return resultobj;
31380 fail:
31381 return NULL;
31382 }
31383
31384
31385 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31386 PyObject *resultobj = 0;
31387 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31388 wxDataFormatId arg2 ;
31389 bool result;
31390 void *argp1 = 0 ;
31391 int res1 = 0 ;
31392 int val2 ;
31393 int ecode2 = 0 ;
31394
31395 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31397 if (!SWIG_IsOK(res1)) {
31398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31399 }
31400 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31401 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31402 if (!SWIG_IsOK(ecode2)) {
31403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31404 }
31405 arg2 = static_cast< wxDataFormatId >(val2);
31406 {
31407 PyThreadState* __tstate = wxPyBeginAllowThreads();
31408 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31409 wxPyEndAllowThreads(__tstate);
31410 if (PyErr_Occurred()) SWIG_fail;
31411 }
31412 {
31413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31414 }
31415 return resultobj;
31416 fail:
31417 return NULL;
31418 }
31419
31420
31421 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31422 PyObject *resultobj = 0;
31423 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31424 wxDataFormatId arg2 ;
31425 bool result;
31426 void *argp1 = 0 ;
31427 int res1 = 0 ;
31428 int val2 ;
31429 int ecode2 = 0 ;
31430
31431 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31433 if (!SWIG_IsOK(res1)) {
31434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31435 }
31436 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31437 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31438 if (!SWIG_IsOK(ecode2)) {
31439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31440 }
31441 arg2 = static_cast< wxDataFormatId >(val2);
31442 {
31443 PyThreadState* __tstate = wxPyBeginAllowThreads();
31444 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31445 wxPyEndAllowThreads(__tstate);
31446 if (PyErr_Occurred()) SWIG_fail;
31447 }
31448 {
31449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31450 }
31451 return resultobj;
31452 fail:
31453 return NULL;
31454 }
31455
31456
31457 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31458 PyObject *resultobj = 0;
31459 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31460 wxDataFormat *arg2 = 0 ;
31461 bool result;
31462 void *argp1 = 0 ;
31463 int res1 = 0 ;
31464 void *argp2 = 0 ;
31465 int res2 = 0 ;
31466
31467 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31469 if (!SWIG_IsOK(res1)) {
31470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31471 }
31472 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31473 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31474 if (!SWIG_IsOK(res2)) {
31475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31476 }
31477 if (!argp2) {
31478 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31479 }
31480 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31481 {
31482 PyThreadState* __tstate = wxPyBeginAllowThreads();
31483 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31484 wxPyEndAllowThreads(__tstate);
31485 if (PyErr_Occurred()) SWIG_fail;
31486 }
31487 {
31488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31489 }
31490 return resultobj;
31491 fail:
31492 return NULL;
31493 }
31494
31495
31496 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31497 int argc;
31498 PyObject *argv[3];
31499
31500 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31501 --argc;
31502 if (argc == 2) {
31503 int _v = 0;
31504 {
31505 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31506 _v = SWIG_CheckState(res);
31507 }
31508 if (!_v) goto check_1;
31509 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31510 }
31511 check_1:
31512
31513 if (argc == 2) {
31514 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31515 }
31516
31517 fail:
31518 Py_INCREF(Py_NotImplemented);
31519 return Py_NotImplemented;
31520 }
31521
31522
31523 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31524 PyObject *resultobj = 0;
31525 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31526 wxDataFormat *arg2 = 0 ;
31527 bool result;
31528 void *argp1 = 0 ;
31529 int res1 = 0 ;
31530 void *argp2 = 0 ;
31531 int res2 = 0 ;
31532
31533 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31535 if (!SWIG_IsOK(res1)) {
31536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31537 }
31538 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31539 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31540 if (!SWIG_IsOK(res2)) {
31541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31542 }
31543 if (!argp2) {
31544 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31545 }
31546 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31547 {
31548 PyThreadState* __tstate = wxPyBeginAllowThreads();
31549 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31550 wxPyEndAllowThreads(__tstate);
31551 if (PyErr_Occurred()) SWIG_fail;
31552 }
31553 {
31554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31555 }
31556 return resultobj;
31557 fail:
31558 return NULL;
31559 }
31560
31561
31562 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31563 int argc;
31564 PyObject *argv[3];
31565
31566 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31567 --argc;
31568 if (argc == 2) {
31569 int _v = 0;
31570 {
31571 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31572 _v = SWIG_CheckState(res);
31573 }
31574 if (!_v) goto check_1;
31575 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31576 }
31577 check_1:
31578
31579 if (argc == 2) {
31580 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31581 }
31582
31583 fail:
31584 Py_INCREF(Py_NotImplemented);
31585 return Py_NotImplemented;
31586 }
31587
31588
31589 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31590 PyObject *resultobj = 0;
31591 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31592 wxDataFormatId arg2 ;
31593 void *argp1 = 0 ;
31594 int res1 = 0 ;
31595 int val2 ;
31596 int ecode2 = 0 ;
31597 PyObject * obj0 = 0 ;
31598 PyObject * obj1 = 0 ;
31599 char * kwnames[] = {
31600 (char *) "self",(char *) "format", NULL
31601 };
31602
31603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31605 if (!SWIG_IsOK(res1)) {
31606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31607 }
31608 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31609 ecode2 = SWIG_AsVal_int(obj1, &val2);
31610 if (!SWIG_IsOK(ecode2)) {
31611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31612 }
31613 arg2 = static_cast< wxDataFormatId >(val2);
31614 {
31615 PyThreadState* __tstate = wxPyBeginAllowThreads();
31616 (arg1)->SetType(arg2);
31617 wxPyEndAllowThreads(__tstate);
31618 if (PyErr_Occurred()) SWIG_fail;
31619 }
31620 resultobj = SWIG_Py_Void();
31621 return resultobj;
31622 fail:
31623 return NULL;
31624 }
31625
31626
31627 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31628 PyObject *resultobj = 0;
31629 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31630 wxDataFormatId result;
31631 void *argp1 = 0 ;
31632 int res1 = 0 ;
31633 PyObject *swig_obj[1] ;
31634
31635 if (!args) SWIG_fail;
31636 swig_obj[0] = args;
31637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31638 if (!SWIG_IsOK(res1)) {
31639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31640 }
31641 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31642 {
31643 PyThreadState* __tstate = wxPyBeginAllowThreads();
31644 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31645 wxPyEndAllowThreads(__tstate);
31646 if (PyErr_Occurred()) SWIG_fail;
31647 }
31648 resultobj = SWIG_From_int(static_cast< int >(result));
31649 return resultobj;
31650 fail:
31651 return NULL;
31652 }
31653
31654
31655 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31656 PyObject *resultobj = 0;
31657 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31658 wxString result;
31659 void *argp1 = 0 ;
31660 int res1 = 0 ;
31661 PyObject *swig_obj[1] ;
31662
31663 if (!args) SWIG_fail;
31664 swig_obj[0] = args;
31665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31666 if (!SWIG_IsOK(res1)) {
31667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31668 }
31669 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31670 {
31671 PyThreadState* __tstate = wxPyBeginAllowThreads();
31672 result = ((wxDataFormat const *)arg1)->GetId();
31673 wxPyEndAllowThreads(__tstate);
31674 if (PyErr_Occurred()) SWIG_fail;
31675 }
31676 {
31677 #if wxUSE_UNICODE
31678 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31679 #else
31680 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31681 #endif
31682 }
31683 return resultobj;
31684 fail:
31685 return NULL;
31686 }
31687
31688
31689 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31690 PyObject *resultobj = 0;
31691 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31692 wxString *arg2 = 0 ;
31693 void *argp1 = 0 ;
31694 int res1 = 0 ;
31695 bool temp2 = false ;
31696 PyObject * obj0 = 0 ;
31697 PyObject * obj1 = 0 ;
31698 char * kwnames[] = {
31699 (char *) "self",(char *) "format", NULL
31700 };
31701
31702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31704 if (!SWIG_IsOK(res1)) {
31705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31706 }
31707 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31708 {
31709 arg2 = wxString_in_helper(obj1);
31710 if (arg2 == NULL) SWIG_fail;
31711 temp2 = true;
31712 }
31713 {
31714 PyThreadState* __tstate = wxPyBeginAllowThreads();
31715 (arg1)->SetId((wxString const &)*arg2);
31716 wxPyEndAllowThreads(__tstate);
31717 if (PyErr_Occurred()) SWIG_fail;
31718 }
31719 resultobj = SWIG_Py_Void();
31720 {
31721 if (temp2)
31722 delete arg2;
31723 }
31724 return resultobj;
31725 fail:
31726 {
31727 if (temp2)
31728 delete arg2;
31729 }
31730 return NULL;
31731 }
31732
31733
31734 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31735 PyObject *obj;
31736 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31737 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31738 return SWIG_Py_Void();
31739 }
31740
31741 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31742 return SWIG_Python_InitShadowInstance(args);
31743 }
31744
31745 SWIGINTERN int FormatInvalid_set(PyObject *) {
31746 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31747 return 1;
31748 }
31749
31750
31751 SWIGINTERN PyObject *FormatInvalid_get(void) {
31752 PyObject *pyobj = 0;
31753
31754 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
31755 return pyobj;
31756 }
31757
31758
31759 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31760 PyObject *resultobj = 0;
31761 wxDataObject *arg1 = (wxDataObject *) 0 ;
31762 void *argp1 = 0 ;
31763 int res1 = 0 ;
31764 PyObject *swig_obj[1] ;
31765
31766 if (!args) SWIG_fail;
31767 swig_obj[0] = args;
31768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
31769 if (!SWIG_IsOK(res1)) {
31770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
31771 }
31772 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31773 {
31774 PyThreadState* __tstate = wxPyBeginAllowThreads();
31775 delete arg1;
31776
31777 wxPyEndAllowThreads(__tstate);
31778 if (PyErr_Occurred()) SWIG_fail;
31779 }
31780 resultobj = SWIG_Py_Void();
31781 return resultobj;
31782 fail:
31783 return NULL;
31784 }
31785
31786
31787 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31788 PyObject *resultobj = 0;
31789 wxDataObject *arg1 = (wxDataObject *) 0 ;
31790 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31791 SwigValueWrapper<wxDataFormat > result;
31792 void *argp1 = 0 ;
31793 int res1 = 0 ;
31794 int val2 ;
31795 int ecode2 = 0 ;
31796 PyObject * obj0 = 0 ;
31797 PyObject * obj1 = 0 ;
31798 char * kwnames[] = {
31799 (char *) "self",(char *) "dir", NULL
31800 };
31801
31802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31804 if (!SWIG_IsOK(res1)) {
31805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31806 }
31807 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31808 if (obj1) {
31809 ecode2 = SWIG_AsVal_int(obj1, &val2);
31810 if (!SWIG_IsOK(ecode2)) {
31811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31812 }
31813 arg2 = static_cast< wxDataObject::Direction >(val2);
31814 }
31815 {
31816 PyThreadState* __tstate = wxPyBeginAllowThreads();
31817 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
31818 wxPyEndAllowThreads(__tstate);
31819 if (PyErr_Occurred()) SWIG_fail;
31820 }
31821 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31822 return resultobj;
31823 fail:
31824 return NULL;
31825 }
31826
31827
31828 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31829 PyObject *resultobj = 0;
31830 wxDataObject *arg1 = (wxDataObject *) 0 ;
31831 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31832 size_t result;
31833 void *argp1 = 0 ;
31834 int res1 = 0 ;
31835 int val2 ;
31836 int ecode2 = 0 ;
31837 PyObject * obj0 = 0 ;
31838 PyObject * obj1 = 0 ;
31839 char * kwnames[] = {
31840 (char *) "self",(char *) "dir", NULL
31841 };
31842
31843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
31844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31845 if (!SWIG_IsOK(res1)) {
31846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31847 }
31848 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31849 if (obj1) {
31850 ecode2 = SWIG_AsVal_int(obj1, &val2);
31851 if (!SWIG_IsOK(ecode2)) {
31852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31853 }
31854 arg2 = static_cast< wxDataObject::Direction >(val2);
31855 }
31856 {
31857 PyThreadState* __tstate = wxPyBeginAllowThreads();
31858 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
31859 wxPyEndAllowThreads(__tstate);
31860 if (PyErr_Occurred()) SWIG_fail;
31861 }
31862 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31863 return resultobj;
31864 fail:
31865 return NULL;
31866 }
31867
31868
31869 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31870 PyObject *resultobj = 0;
31871 wxDataObject *arg1 = (wxDataObject *) 0 ;
31872 wxDataFormat *arg2 = 0 ;
31873 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
31874 bool result;
31875 void *argp1 = 0 ;
31876 int res1 = 0 ;
31877 void *argp2 = 0 ;
31878 int res2 = 0 ;
31879 int val3 ;
31880 int ecode3 = 0 ;
31881 PyObject * obj0 = 0 ;
31882 PyObject * obj1 = 0 ;
31883 PyObject * obj2 = 0 ;
31884 char * kwnames[] = {
31885 (char *) "self",(char *) "format",(char *) "dir", NULL
31886 };
31887
31888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31890 if (!SWIG_IsOK(res1)) {
31891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31892 }
31893 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31894 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31895 if (!SWIG_IsOK(res2)) {
31896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31897 }
31898 if (!argp2) {
31899 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31900 }
31901 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31902 if (obj2) {
31903 ecode3 = SWIG_AsVal_int(obj2, &val3);
31904 if (!SWIG_IsOK(ecode3)) {
31905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
31906 }
31907 arg3 = static_cast< wxDataObject::Direction >(val3);
31908 }
31909 {
31910 PyThreadState* __tstate = wxPyBeginAllowThreads();
31911 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
31912 wxPyEndAllowThreads(__tstate);
31913 if (PyErr_Occurred()) SWIG_fail;
31914 }
31915 {
31916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31917 }
31918 return resultobj;
31919 fail:
31920 return NULL;
31921 }
31922
31923
31924 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31925 PyObject *resultobj = 0;
31926 wxDataObject *arg1 = (wxDataObject *) 0 ;
31927 wxDataFormat *arg2 = 0 ;
31928 size_t result;
31929 void *argp1 = 0 ;
31930 int res1 = 0 ;
31931 void *argp2 = 0 ;
31932 int res2 = 0 ;
31933 PyObject * obj0 = 0 ;
31934 PyObject * obj1 = 0 ;
31935 char * kwnames[] = {
31936 (char *) "self",(char *) "format", NULL
31937 };
31938
31939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
31940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31941 if (!SWIG_IsOK(res1)) {
31942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31943 }
31944 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31945 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31946 if (!SWIG_IsOK(res2)) {
31947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31948 }
31949 if (!argp2) {
31950 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31951 }
31952 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31953 {
31954 PyThreadState* __tstate = wxPyBeginAllowThreads();
31955 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
31956 wxPyEndAllowThreads(__tstate);
31957 if (PyErr_Occurred()) SWIG_fail;
31958 }
31959 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31960 return resultobj;
31961 fail:
31962 return NULL;
31963 }
31964
31965
31966 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31967 PyObject *resultobj = 0;
31968 wxDataObject *arg1 = (wxDataObject *) 0 ;
31969 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31970 PyObject *result = 0 ;
31971 void *argp1 = 0 ;
31972 int res1 = 0 ;
31973 int val2 ;
31974 int ecode2 = 0 ;
31975 PyObject * obj0 = 0 ;
31976 PyObject * obj1 = 0 ;
31977 char * kwnames[] = {
31978 (char *) "self",(char *) "dir", NULL
31979 };
31980
31981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
31982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31983 if (!SWIG_IsOK(res1)) {
31984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
31985 }
31986 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31987 if (obj1) {
31988 ecode2 = SWIG_AsVal_int(obj1, &val2);
31989 if (!SWIG_IsOK(ecode2)) {
31990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31991 }
31992 arg2 = static_cast< wxDataObject::Direction >(val2);
31993 }
31994 {
31995 PyThreadState* __tstate = wxPyBeginAllowThreads();
31996 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
31997 wxPyEndAllowThreads(__tstate);
31998 if (PyErr_Occurred()) SWIG_fail;
31999 }
32000 resultobj = result;
32001 return resultobj;
32002 fail:
32003 return NULL;
32004 }
32005
32006
32007 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32008 PyObject *resultobj = 0;
32009 wxDataObject *arg1 = (wxDataObject *) 0 ;
32010 wxDataFormat *arg2 = 0 ;
32011 PyObject *result = 0 ;
32012 void *argp1 = 0 ;
32013 int res1 = 0 ;
32014 void *argp2 = 0 ;
32015 int res2 = 0 ;
32016 PyObject * obj0 = 0 ;
32017 PyObject * obj1 = 0 ;
32018 char * kwnames[] = {
32019 (char *) "self",(char *) "format", NULL
32020 };
32021
32022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32024 if (!SWIG_IsOK(res1)) {
32025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32026 }
32027 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32028 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32029 if (!SWIG_IsOK(res2)) {
32030 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32031 }
32032 if (!argp2) {
32033 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32034 }
32035 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32036 {
32037 PyThreadState* __tstate = wxPyBeginAllowThreads();
32038 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32039 wxPyEndAllowThreads(__tstate);
32040 if (PyErr_Occurred()) SWIG_fail;
32041 }
32042 resultobj = result;
32043 return resultobj;
32044 fail:
32045 return NULL;
32046 }
32047
32048
32049 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32050 PyObject *resultobj = 0;
32051 wxDataObject *arg1 = (wxDataObject *) 0 ;
32052 wxDataFormat *arg2 = 0 ;
32053 PyObject *arg3 = (PyObject *) 0 ;
32054 bool result;
32055 void *argp1 = 0 ;
32056 int res1 = 0 ;
32057 void *argp2 = 0 ;
32058 int res2 = 0 ;
32059 PyObject * obj0 = 0 ;
32060 PyObject * obj1 = 0 ;
32061 PyObject * obj2 = 0 ;
32062 char * kwnames[] = {
32063 (char *) "self",(char *) "format",(char *) "data", NULL
32064 };
32065
32066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32068 if (!SWIG_IsOK(res1)) {
32069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32070 }
32071 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32072 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32073 if (!SWIG_IsOK(res2)) {
32074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32075 }
32076 if (!argp2) {
32077 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32078 }
32079 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32080 arg3 = obj2;
32081 {
32082 PyThreadState* __tstate = wxPyBeginAllowThreads();
32083 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32084 wxPyEndAllowThreads(__tstate);
32085 if (PyErr_Occurred()) SWIG_fail;
32086 }
32087 {
32088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32089 }
32090 return resultobj;
32091 fail:
32092 return NULL;
32093 }
32094
32095
32096 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32097 PyObject *obj;
32098 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32099 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32100 return SWIG_Py_Void();
32101 }
32102
32103 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32104 PyObject *resultobj = 0;
32105 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32106 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32107 wxDataObjectSimple *result = 0 ;
32108 void *argp1 = 0 ;
32109 int res1 = 0 ;
32110 PyObject * obj0 = 0 ;
32111 char * kwnames[] = {
32112 (char *) "format", NULL
32113 };
32114
32115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32116 if (obj0) {
32117 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32118 if (!SWIG_IsOK(res1)) {
32119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32120 }
32121 if (!argp1) {
32122 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32123 }
32124 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32125 }
32126 {
32127 PyThreadState* __tstate = wxPyBeginAllowThreads();
32128 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32129 wxPyEndAllowThreads(__tstate);
32130 if (PyErr_Occurred()) SWIG_fail;
32131 }
32132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32133 return resultobj;
32134 fail:
32135 return NULL;
32136 }
32137
32138
32139 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32140 PyObject *resultobj = 0;
32141 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32142 wxDataFormat *result = 0 ;
32143 void *argp1 = 0 ;
32144 int res1 = 0 ;
32145 PyObject *swig_obj[1] ;
32146
32147 if (!args) SWIG_fail;
32148 swig_obj[0] = args;
32149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32150 if (!SWIG_IsOK(res1)) {
32151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32152 }
32153 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32154 {
32155 PyThreadState* __tstate = wxPyBeginAllowThreads();
32156 {
32157 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32158 result = (wxDataFormat *) &_result_ref;
32159 }
32160 wxPyEndAllowThreads(__tstate);
32161 if (PyErr_Occurred()) SWIG_fail;
32162 }
32163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32164 return resultobj;
32165 fail:
32166 return NULL;
32167 }
32168
32169
32170 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32171 PyObject *resultobj = 0;
32172 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32173 wxDataFormat *arg2 = 0 ;
32174 void *argp1 = 0 ;
32175 int res1 = 0 ;
32176 void *argp2 = 0 ;
32177 int res2 = 0 ;
32178 PyObject * obj0 = 0 ;
32179 PyObject * obj1 = 0 ;
32180 char * kwnames[] = {
32181 (char *) "self",(char *) "format", NULL
32182 };
32183
32184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32186 if (!SWIG_IsOK(res1)) {
32187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32188 }
32189 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32190 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32191 if (!SWIG_IsOK(res2)) {
32192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32193 }
32194 if (!argp2) {
32195 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32196 }
32197 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32198 {
32199 PyThreadState* __tstate = wxPyBeginAllowThreads();
32200 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32201 wxPyEndAllowThreads(__tstate);
32202 if (PyErr_Occurred()) SWIG_fail;
32203 }
32204 resultobj = SWIG_Py_Void();
32205 return resultobj;
32206 fail:
32207 return NULL;
32208 }
32209
32210
32211 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32212 PyObject *resultobj = 0;
32213 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32214 size_t result;
32215 void *argp1 = 0 ;
32216 int res1 = 0 ;
32217 PyObject *swig_obj[1] ;
32218
32219 if (!args) SWIG_fail;
32220 swig_obj[0] = args;
32221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32222 if (!SWIG_IsOK(res1)) {
32223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32224 }
32225 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32226 {
32227 PyThreadState* __tstate = wxPyBeginAllowThreads();
32228 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32229 wxPyEndAllowThreads(__tstate);
32230 if (PyErr_Occurred()) SWIG_fail;
32231 }
32232 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32233 return resultobj;
32234 fail:
32235 return NULL;
32236 }
32237
32238
32239 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32240 PyObject *resultobj = 0;
32241 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32242 PyObject *result = 0 ;
32243 void *argp1 = 0 ;
32244 int res1 = 0 ;
32245 PyObject *swig_obj[1] ;
32246
32247 if (!args) SWIG_fail;
32248 swig_obj[0] = args;
32249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32250 if (!SWIG_IsOK(res1)) {
32251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32252 }
32253 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32254 {
32255 PyThreadState* __tstate = wxPyBeginAllowThreads();
32256 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32257 wxPyEndAllowThreads(__tstate);
32258 if (PyErr_Occurred()) SWIG_fail;
32259 }
32260 resultobj = result;
32261 return resultobj;
32262 fail:
32263 return NULL;
32264 }
32265
32266
32267 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32268 PyObject *resultobj = 0;
32269 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32270 PyObject *arg2 = (PyObject *) 0 ;
32271 bool result;
32272 void *argp1 = 0 ;
32273 int res1 = 0 ;
32274 PyObject * obj0 = 0 ;
32275 PyObject * obj1 = 0 ;
32276 char * kwnames[] = {
32277 (char *) "self",(char *) "data", NULL
32278 };
32279
32280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32282 if (!SWIG_IsOK(res1)) {
32283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32284 }
32285 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32286 arg2 = obj1;
32287 {
32288 PyThreadState* __tstate = wxPyBeginAllowThreads();
32289 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32290 wxPyEndAllowThreads(__tstate);
32291 if (PyErr_Occurred()) SWIG_fail;
32292 }
32293 {
32294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32295 }
32296 return resultobj;
32297 fail:
32298 return NULL;
32299 }
32300
32301
32302 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32303 PyObject *obj;
32304 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32305 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32306 return SWIG_Py_Void();
32307 }
32308
32309 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32310 return SWIG_Python_InitShadowInstance(args);
32311 }
32312
32313 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32314 PyObject *resultobj = 0;
32315 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32316 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32317 wxPyDataObjectSimple *result = 0 ;
32318 void *argp1 = 0 ;
32319 int res1 = 0 ;
32320 PyObject * obj0 = 0 ;
32321 char * kwnames[] = {
32322 (char *) "format", NULL
32323 };
32324
32325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32326 if (obj0) {
32327 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32328 if (!SWIG_IsOK(res1)) {
32329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32330 }
32331 if (!argp1) {
32332 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32333 }
32334 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32335 }
32336 {
32337 PyThreadState* __tstate = wxPyBeginAllowThreads();
32338 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32339 wxPyEndAllowThreads(__tstate);
32340 if (PyErr_Occurred()) SWIG_fail;
32341 }
32342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32343 return resultobj;
32344 fail:
32345 return NULL;
32346 }
32347
32348
32349 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32350 PyObject *resultobj = 0;
32351 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32352 PyObject *arg2 = (PyObject *) 0 ;
32353 PyObject *arg3 = (PyObject *) 0 ;
32354 void *argp1 = 0 ;
32355 int res1 = 0 ;
32356 PyObject * obj0 = 0 ;
32357 PyObject * obj1 = 0 ;
32358 PyObject * obj2 = 0 ;
32359 char * kwnames[] = {
32360 (char *) "self",(char *) "self",(char *) "_class", NULL
32361 };
32362
32363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32365 if (!SWIG_IsOK(res1)) {
32366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32367 }
32368 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32369 arg2 = obj1;
32370 arg3 = obj2;
32371 {
32372 PyThreadState* __tstate = wxPyBeginAllowThreads();
32373 (arg1)->_setCallbackInfo(arg2,arg3);
32374 wxPyEndAllowThreads(__tstate);
32375 if (PyErr_Occurred()) SWIG_fail;
32376 }
32377 resultobj = SWIG_Py_Void();
32378 return resultobj;
32379 fail:
32380 return NULL;
32381 }
32382
32383
32384 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32385 PyObject *obj;
32386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32387 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32388 return SWIG_Py_Void();
32389 }
32390
32391 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32392 return SWIG_Python_InitShadowInstance(args);
32393 }
32394
32395 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32396 PyObject *resultobj = 0;
32397 wxDataObjectComposite *result = 0 ;
32398
32399 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32400 {
32401 PyThreadState* __tstate = wxPyBeginAllowThreads();
32402 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32403 wxPyEndAllowThreads(__tstate);
32404 if (PyErr_Occurred()) SWIG_fail;
32405 }
32406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32407 return resultobj;
32408 fail:
32409 return NULL;
32410 }
32411
32412
32413 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32414 PyObject *resultobj = 0;
32415 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32416 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32417 bool arg3 = (bool) false ;
32418 void *argp1 = 0 ;
32419 int res1 = 0 ;
32420 int res2 = 0 ;
32421 bool val3 ;
32422 int ecode3 = 0 ;
32423 PyObject * obj0 = 0 ;
32424 PyObject * obj1 = 0 ;
32425 PyObject * obj2 = 0 ;
32426 char * kwnames[] = {
32427 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32428 };
32429
32430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32432 if (!SWIG_IsOK(res1)) {
32433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32434 }
32435 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32436 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32437 if (!SWIG_IsOK(res2)) {
32438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32439 }
32440 if (obj2) {
32441 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32442 if (!SWIG_IsOK(ecode3)) {
32443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32444 }
32445 arg3 = static_cast< bool >(val3);
32446 }
32447 {
32448 PyThreadState* __tstate = wxPyBeginAllowThreads();
32449 (arg1)->Add(arg2,arg3);
32450 wxPyEndAllowThreads(__tstate);
32451 if (PyErr_Occurred()) SWIG_fail;
32452 }
32453 resultobj = SWIG_Py_Void();
32454 return resultobj;
32455 fail:
32456 return NULL;
32457 }
32458
32459
32460 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32461 PyObject *resultobj = 0;
32462 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32463 SwigValueWrapper<wxDataFormat > result;
32464 void *argp1 = 0 ;
32465 int res1 = 0 ;
32466 PyObject *swig_obj[1] ;
32467
32468 if (!args) SWIG_fail;
32469 swig_obj[0] = args;
32470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32471 if (!SWIG_IsOK(res1)) {
32472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32473 }
32474 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32475 {
32476 PyThreadState* __tstate = wxPyBeginAllowThreads();
32477 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32478 wxPyEndAllowThreads(__tstate);
32479 if (PyErr_Occurred()) SWIG_fail;
32480 }
32481 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32482 return resultobj;
32483 fail:
32484 return NULL;
32485 }
32486
32487
32488 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32489 PyObject *obj;
32490 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32491 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32492 return SWIG_Py_Void();
32493 }
32494
32495 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32496 return SWIG_Python_InitShadowInstance(args);
32497 }
32498
32499 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32500 PyObject *resultobj = 0;
32501 wxString const &arg1_defvalue = wxPyEmptyString ;
32502 wxString *arg1 = (wxString *) &arg1_defvalue ;
32503 wxTextDataObject *result = 0 ;
32504 bool temp1 = false ;
32505 PyObject * obj0 = 0 ;
32506 char * kwnames[] = {
32507 (char *) "text", NULL
32508 };
32509
32510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32511 if (obj0) {
32512 {
32513 arg1 = wxString_in_helper(obj0);
32514 if (arg1 == NULL) SWIG_fail;
32515 temp1 = true;
32516 }
32517 }
32518 {
32519 PyThreadState* __tstate = wxPyBeginAllowThreads();
32520 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32521 wxPyEndAllowThreads(__tstate);
32522 if (PyErr_Occurred()) SWIG_fail;
32523 }
32524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32525 {
32526 if (temp1)
32527 delete arg1;
32528 }
32529 return resultobj;
32530 fail:
32531 {
32532 if (temp1)
32533 delete arg1;
32534 }
32535 return NULL;
32536 }
32537
32538
32539 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32540 PyObject *resultobj = 0;
32541 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32542 size_t result;
32543 void *argp1 = 0 ;
32544 int res1 = 0 ;
32545 PyObject *swig_obj[1] ;
32546
32547 if (!args) SWIG_fail;
32548 swig_obj[0] = args;
32549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32550 if (!SWIG_IsOK(res1)) {
32551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32552 }
32553 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32554 {
32555 PyThreadState* __tstate = wxPyBeginAllowThreads();
32556 result = (size_t)(arg1)->GetTextLength();
32557 wxPyEndAllowThreads(__tstate);
32558 if (PyErr_Occurred()) SWIG_fail;
32559 }
32560 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32561 return resultobj;
32562 fail:
32563 return NULL;
32564 }
32565
32566
32567 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32568 PyObject *resultobj = 0;
32569 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32570 wxString result;
32571 void *argp1 = 0 ;
32572 int res1 = 0 ;
32573 PyObject *swig_obj[1] ;
32574
32575 if (!args) SWIG_fail;
32576 swig_obj[0] = args;
32577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32578 if (!SWIG_IsOK(res1)) {
32579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32580 }
32581 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32582 {
32583 PyThreadState* __tstate = wxPyBeginAllowThreads();
32584 result = (arg1)->GetText();
32585 wxPyEndAllowThreads(__tstate);
32586 if (PyErr_Occurred()) SWIG_fail;
32587 }
32588 {
32589 #if wxUSE_UNICODE
32590 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32591 #else
32592 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32593 #endif
32594 }
32595 return resultobj;
32596 fail:
32597 return NULL;
32598 }
32599
32600
32601 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32602 PyObject *resultobj = 0;
32603 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32604 wxString *arg2 = 0 ;
32605 void *argp1 = 0 ;
32606 int res1 = 0 ;
32607 bool temp2 = false ;
32608 PyObject * obj0 = 0 ;
32609 PyObject * obj1 = 0 ;
32610 char * kwnames[] = {
32611 (char *) "self",(char *) "text", NULL
32612 };
32613
32614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32616 if (!SWIG_IsOK(res1)) {
32617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32618 }
32619 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32620 {
32621 arg2 = wxString_in_helper(obj1);
32622 if (arg2 == NULL) SWIG_fail;
32623 temp2 = true;
32624 }
32625 {
32626 PyThreadState* __tstate = wxPyBeginAllowThreads();
32627 (arg1)->SetText((wxString const &)*arg2);
32628 wxPyEndAllowThreads(__tstate);
32629 if (PyErr_Occurred()) SWIG_fail;
32630 }
32631 resultobj = SWIG_Py_Void();
32632 {
32633 if (temp2)
32634 delete arg2;
32635 }
32636 return resultobj;
32637 fail:
32638 {
32639 if (temp2)
32640 delete arg2;
32641 }
32642 return NULL;
32643 }
32644
32645
32646 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32647 PyObject *obj;
32648 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32649 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32650 return SWIG_Py_Void();
32651 }
32652
32653 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32654 return SWIG_Python_InitShadowInstance(args);
32655 }
32656
32657 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32658 PyObject *resultobj = 0;
32659 wxString const &arg1_defvalue = wxPyEmptyString ;
32660 wxString *arg1 = (wxString *) &arg1_defvalue ;
32661 wxPyTextDataObject *result = 0 ;
32662 bool temp1 = false ;
32663 PyObject * obj0 = 0 ;
32664 char * kwnames[] = {
32665 (char *) "text", NULL
32666 };
32667
32668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32669 if (obj0) {
32670 {
32671 arg1 = wxString_in_helper(obj0);
32672 if (arg1 == NULL) SWIG_fail;
32673 temp1 = true;
32674 }
32675 }
32676 {
32677 PyThreadState* __tstate = wxPyBeginAllowThreads();
32678 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32679 wxPyEndAllowThreads(__tstate);
32680 if (PyErr_Occurred()) SWIG_fail;
32681 }
32682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32683 {
32684 if (temp1)
32685 delete arg1;
32686 }
32687 return resultobj;
32688 fail:
32689 {
32690 if (temp1)
32691 delete arg1;
32692 }
32693 return NULL;
32694 }
32695
32696
32697 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32698 PyObject *resultobj = 0;
32699 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32700 PyObject *arg2 = (PyObject *) 0 ;
32701 PyObject *arg3 = (PyObject *) 0 ;
32702 void *argp1 = 0 ;
32703 int res1 = 0 ;
32704 PyObject * obj0 = 0 ;
32705 PyObject * obj1 = 0 ;
32706 PyObject * obj2 = 0 ;
32707 char * kwnames[] = {
32708 (char *) "self",(char *) "self",(char *) "_class", NULL
32709 };
32710
32711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32713 if (!SWIG_IsOK(res1)) {
32714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32715 }
32716 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32717 arg2 = obj1;
32718 arg3 = obj2;
32719 {
32720 PyThreadState* __tstate = wxPyBeginAllowThreads();
32721 (arg1)->_setCallbackInfo(arg2,arg3);
32722 wxPyEndAllowThreads(__tstate);
32723 if (PyErr_Occurred()) SWIG_fail;
32724 }
32725 resultobj = SWIG_Py_Void();
32726 return resultobj;
32727 fail:
32728 return NULL;
32729 }
32730
32731
32732 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32733 PyObject *obj;
32734 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32735 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32736 return SWIG_Py_Void();
32737 }
32738
32739 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32740 return SWIG_Python_InitShadowInstance(args);
32741 }
32742
32743 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32744 PyObject *resultobj = 0;
32745 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32746 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32747 wxBitmapDataObject *result = 0 ;
32748 void *argp1 = 0 ;
32749 int res1 = 0 ;
32750 PyObject * obj0 = 0 ;
32751 char * kwnames[] = {
32752 (char *) "bitmap", NULL
32753 };
32754
32755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
32756 if (obj0) {
32757 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32758 if (!SWIG_IsOK(res1)) {
32759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32760 }
32761 if (!argp1) {
32762 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32763 }
32764 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32765 }
32766 {
32767 PyThreadState* __tstate = wxPyBeginAllowThreads();
32768 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
32769 wxPyEndAllowThreads(__tstate);
32770 if (PyErr_Occurred()) SWIG_fail;
32771 }
32772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
32773 return resultobj;
32774 fail:
32775 return NULL;
32776 }
32777
32778
32779 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32780 PyObject *resultobj = 0;
32781 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32782 wxBitmap result;
32783 void *argp1 = 0 ;
32784 int res1 = 0 ;
32785 PyObject *swig_obj[1] ;
32786
32787 if (!args) SWIG_fail;
32788 swig_obj[0] = args;
32789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32790 if (!SWIG_IsOK(res1)) {
32791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
32792 }
32793 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32794 {
32795 PyThreadState* __tstate = wxPyBeginAllowThreads();
32796 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
32797 wxPyEndAllowThreads(__tstate);
32798 if (PyErr_Occurred()) SWIG_fail;
32799 }
32800 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
32801 return resultobj;
32802 fail:
32803 return NULL;
32804 }
32805
32806
32807 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32808 PyObject *resultobj = 0;
32809 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32810 wxBitmap *arg2 = 0 ;
32811 void *argp1 = 0 ;
32812 int res1 = 0 ;
32813 void *argp2 = 0 ;
32814 int res2 = 0 ;
32815 PyObject * obj0 = 0 ;
32816 PyObject * obj1 = 0 ;
32817 char * kwnames[] = {
32818 (char *) "self",(char *) "bitmap", NULL
32819 };
32820
32821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
32822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32823 if (!SWIG_IsOK(res1)) {
32824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
32825 }
32826 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32827 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
32828 if (!SWIG_IsOK(res2)) {
32829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32830 }
32831 if (!argp2) {
32832 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32833 }
32834 arg2 = reinterpret_cast< wxBitmap * >(argp2);
32835 {
32836 PyThreadState* __tstate = wxPyBeginAllowThreads();
32837 (arg1)->SetBitmap((wxBitmap const &)*arg2);
32838 wxPyEndAllowThreads(__tstate);
32839 if (PyErr_Occurred()) SWIG_fail;
32840 }
32841 resultobj = SWIG_Py_Void();
32842 return resultobj;
32843 fail:
32844 return NULL;
32845 }
32846
32847
32848 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32849 PyObject *obj;
32850 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32851 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
32852 return SWIG_Py_Void();
32853 }
32854
32855 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32856 return SWIG_Python_InitShadowInstance(args);
32857 }
32858
32859 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32860 PyObject *resultobj = 0;
32861 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32862 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32863 wxPyBitmapDataObject *result = 0 ;
32864 void *argp1 = 0 ;
32865 int res1 = 0 ;
32866 PyObject * obj0 = 0 ;
32867 char * kwnames[] = {
32868 (char *) "bitmap", NULL
32869 };
32870
32871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
32872 if (obj0) {
32873 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32874 if (!SWIG_IsOK(res1)) {
32875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32876 }
32877 if (!argp1) {
32878 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32879 }
32880 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32881 }
32882 {
32883 PyThreadState* __tstate = wxPyBeginAllowThreads();
32884 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
32885 wxPyEndAllowThreads(__tstate);
32886 if (PyErr_Occurred()) SWIG_fail;
32887 }
32888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
32889 return resultobj;
32890 fail:
32891 return NULL;
32892 }
32893
32894
32895 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32896 PyObject *resultobj = 0;
32897 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
32898 PyObject *arg2 = (PyObject *) 0 ;
32899 PyObject *arg3 = (PyObject *) 0 ;
32900 void *argp1 = 0 ;
32901 int res1 = 0 ;
32902 PyObject * obj0 = 0 ;
32903 PyObject * obj1 = 0 ;
32904 PyObject * obj2 = 0 ;
32905 char * kwnames[] = {
32906 (char *) "self",(char *) "self",(char *) "_class", NULL
32907 };
32908
32909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
32911 if (!SWIG_IsOK(res1)) {
32912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
32913 }
32914 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
32915 arg2 = obj1;
32916 arg3 = obj2;
32917 {
32918 PyThreadState* __tstate = wxPyBeginAllowThreads();
32919 (arg1)->_setCallbackInfo(arg2,arg3);
32920 wxPyEndAllowThreads(__tstate);
32921 if (PyErr_Occurred()) SWIG_fail;
32922 }
32923 resultobj = SWIG_Py_Void();
32924 return resultobj;
32925 fail:
32926 return NULL;
32927 }
32928
32929
32930 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32931 PyObject *obj;
32932 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32933 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
32934 return SWIG_Py_Void();
32935 }
32936
32937 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32938 return SWIG_Python_InitShadowInstance(args);
32939 }
32940
32941 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32942 PyObject *resultobj = 0;
32943 wxFileDataObject *result = 0 ;
32944
32945 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
32946 {
32947 PyThreadState* __tstate = wxPyBeginAllowThreads();
32948 result = (wxFileDataObject *)new wxFileDataObject();
32949 wxPyEndAllowThreads(__tstate);
32950 if (PyErr_Occurred()) SWIG_fail;
32951 }
32952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
32953 return resultobj;
32954 fail:
32955 return NULL;
32956 }
32957
32958
32959 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32960 PyObject *resultobj = 0;
32961 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32962 wxArrayString *result = 0 ;
32963 void *argp1 = 0 ;
32964 int res1 = 0 ;
32965 PyObject *swig_obj[1] ;
32966
32967 if (!args) SWIG_fail;
32968 swig_obj[0] = args;
32969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32970 if (!SWIG_IsOK(res1)) {
32971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32972 }
32973 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
32974 {
32975 PyThreadState* __tstate = wxPyBeginAllowThreads();
32976 {
32977 wxArrayString const &_result_ref = (arg1)->GetFilenames();
32978 result = (wxArrayString *) &_result_ref;
32979 }
32980 wxPyEndAllowThreads(__tstate);
32981 if (PyErr_Occurred()) SWIG_fail;
32982 }
32983 {
32984 resultobj = wxArrayString2PyList_helper(*result);
32985 }
32986 return resultobj;
32987 fail:
32988 return NULL;
32989 }
32990
32991
32992 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32993 PyObject *resultobj = 0;
32994 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32995 wxString *arg2 = 0 ;
32996 void *argp1 = 0 ;
32997 int res1 = 0 ;
32998 bool temp2 = false ;
32999 PyObject * obj0 = 0 ;
33000 PyObject * obj1 = 0 ;
33001 char * kwnames[] = {
33002 (char *) "self",(char *) "filename", NULL
33003 };
33004
33005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33007 if (!SWIG_IsOK(res1)) {
33008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33009 }
33010 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33011 {
33012 arg2 = wxString_in_helper(obj1);
33013 if (arg2 == NULL) SWIG_fail;
33014 temp2 = true;
33015 }
33016 {
33017 PyThreadState* __tstate = wxPyBeginAllowThreads();
33018 (arg1)->AddFile((wxString const &)*arg2);
33019 wxPyEndAllowThreads(__tstate);
33020 if (PyErr_Occurred()) SWIG_fail;
33021 }
33022 resultobj = SWIG_Py_Void();
33023 {
33024 if (temp2)
33025 delete arg2;
33026 }
33027 return resultobj;
33028 fail:
33029 {
33030 if (temp2)
33031 delete arg2;
33032 }
33033 return NULL;
33034 }
33035
33036
33037 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33038 PyObject *obj;
33039 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33040 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33041 return SWIG_Py_Void();
33042 }
33043
33044 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33045 return SWIG_Python_InitShadowInstance(args);
33046 }
33047
33048 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33049 PyObject *resultobj = 0;
33050 wxDataFormat *arg1 = 0 ;
33051 wxCustomDataObject *result = 0 ;
33052 void *argp1 = 0 ;
33053 int res1 = 0 ;
33054
33055 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33057 if (!SWIG_IsOK(res1)) {
33058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33059 }
33060 if (!argp1) {
33061 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33062 }
33063 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33064 {
33065 PyThreadState* __tstate = wxPyBeginAllowThreads();
33066 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33067 wxPyEndAllowThreads(__tstate);
33068 if (PyErr_Occurred()) SWIG_fail;
33069 }
33070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33071 return resultobj;
33072 fail:
33073 return NULL;
33074 }
33075
33076
33077 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33078 PyObject *resultobj = 0;
33079 wxString *arg1 = 0 ;
33080 wxCustomDataObject *result = 0 ;
33081 bool temp1 = false ;
33082
33083 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33084 {
33085 arg1 = wxString_in_helper(swig_obj[0]);
33086 if (arg1 == NULL) SWIG_fail;
33087 temp1 = true;
33088 }
33089 {
33090 PyThreadState* __tstate = wxPyBeginAllowThreads();
33091 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33092 wxPyEndAllowThreads(__tstate);
33093 if (PyErr_Occurred()) SWIG_fail;
33094 }
33095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33096 {
33097 if (temp1)
33098 delete arg1;
33099 }
33100 return resultobj;
33101 fail:
33102 {
33103 if (temp1)
33104 delete arg1;
33105 }
33106 return NULL;
33107 }
33108
33109
33110 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33111 PyObject *resultobj = 0;
33112 wxCustomDataObject *result = 0 ;
33113
33114 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33115 {
33116 PyThreadState* __tstate = wxPyBeginAllowThreads();
33117 result = (wxCustomDataObject *)new wxCustomDataObject();
33118 wxPyEndAllowThreads(__tstate);
33119 if (PyErr_Occurred()) SWIG_fail;
33120 }
33121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33122 return resultobj;
33123 fail:
33124 return NULL;
33125 }
33126
33127
33128 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33129 int argc;
33130 PyObject *argv[2];
33131
33132 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33133 --argc;
33134 if (argc == 0) {
33135 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33136 }
33137 if (argc == 1) {
33138 int _v = 0;
33139 {
33140 {
33141 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33142 }
33143 }
33144 if (!_v) goto check_2;
33145 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33146 }
33147 check_2:
33148
33149 if (argc == 1) {
33150 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33151 }
33152
33153 fail:
33154 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33155 return NULL;
33156 }
33157
33158
33159 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33160 PyObject *resultobj = 0;
33161 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33162 PyObject *arg2 = (PyObject *) 0 ;
33163 bool result;
33164 void *argp1 = 0 ;
33165 int res1 = 0 ;
33166 PyObject * obj0 = 0 ;
33167 PyObject * obj1 = 0 ;
33168 char * kwnames[] = {
33169 (char *) "self",(char *) "data", NULL
33170 };
33171
33172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33174 if (!SWIG_IsOK(res1)) {
33175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33176 }
33177 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33178 arg2 = obj1;
33179 {
33180 PyThreadState* __tstate = wxPyBeginAllowThreads();
33181 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33182 wxPyEndAllowThreads(__tstate);
33183 if (PyErr_Occurred()) SWIG_fail;
33184 }
33185 {
33186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33187 }
33188 return resultobj;
33189 fail:
33190 return NULL;
33191 }
33192
33193
33194 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33195 PyObject *resultobj = 0;
33196 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33197 size_t result;
33198 void *argp1 = 0 ;
33199 int res1 = 0 ;
33200 PyObject *swig_obj[1] ;
33201
33202 if (!args) SWIG_fail;
33203 swig_obj[0] = args;
33204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33205 if (!SWIG_IsOK(res1)) {
33206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33207 }
33208 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33209 {
33210 PyThreadState* __tstate = wxPyBeginAllowThreads();
33211 result = (size_t)(arg1)->GetSize();
33212 wxPyEndAllowThreads(__tstate);
33213 if (PyErr_Occurred()) SWIG_fail;
33214 }
33215 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33216 return resultobj;
33217 fail:
33218 return NULL;
33219 }
33220
33221
33222 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33223 PyObject *resultobj = 0;
33224 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33225 PyObject *result = 0 ;
33226 void *argp1 = 0 ;
33227 int res1 = 0 ;
33228 PyObject *swig_obj[1] ;
33229
33230 if (!args) SWIG_fail;
33231 swig_obj[0] = args;
33232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33233 if (!SWIG_IsOK(res1)) {
33234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33235 }
33236 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33237 {
33238 PyThreadState* __tstate = wxPyBeginAllowThreads();
33239 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33240 wxPyEndAllowThreads(__tstate);
33241 if (PyErr_Occurred()) SWIG_fail;
33242 }
33243 resultobj = result;
33244 return resultobj;
33245 fail:
33246 return NULL;
33247 }
33248
33249
33250 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33251 PyObject *obj;
33252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33253 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33254 return SWIG_Py_Void();
33255 }
33256
33257 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33258 return SWIG_Python_InitShadowInstance(args);
33259 }
33260
33261 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33262 PyObject *resultobj = 0;
33263 wxString const &arg1_defvalue = wxPyEmptyString ;
33264 wxString *arg1 = (wxString *) &arg1_defvalue ;
33265 wxURLDataObject *result = 0 ;
33266 bool temp1 = false ;
33267 PyObject * obj0 = 0 ;
33268 char * kwnames[] = {
33269 (char *) "url", NULL
33270 };
33271
33272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33273 if (obj0) {
33274 {
33275 arg1 = wxString_in_helper(obj0);
33276 if (arg1 == NULL) SWIG_fail;
33277 temp1 = true;
33278 }
33279 }
33280 {
33281 PyThreadState* __tstate = wxPyBeginAllowThreads();
33282 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33283 wxPyEndAllowThreads(__tstate);
33284 if (PyErr_Occurred()) SWIG_fail;
33285 }
33286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33287 {
33288 if (temp1)
33289 delete arg1;
33290 }
33291 return resultobj;
33292 fail:
33293 {
33294 if (temp1)
33295 delete arg1;
33296 }
33297 return NULL;
33298 }
33299
33300
33301 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33302 PyObject *resultobj = 0;
33303 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33304 wxString result;
33305 void *argp1 = 0 ;
33306 int res1 = 0 ;
33307 PyObject *swig_obj[1] ;
33308
33309 if (!args) SWIG_fail;
33310 swig_obj[0] = args;
33311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33312 if (!SWIG_IsOK(res1)) {
33313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33314 }
33315 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33316 {
33317 PyThreadState* __tstate = wxPyBeginAllowThreads();
33318 result = (arg1)->GetURL();
33319 wxPyEndAllowThreads(__tstate);
33320 if (PyErr_Occurred()) SWIG_fail;
33321 }
33322 {
33323 #if wxUSE_UNICODE
33324 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33325 #else
33326 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33327 #endif
33328 }
33329 return resultobj;
33330 fail:
33331 return NULL;
33332 }
33333
33334
33335 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33336 PyObject *resultobj = 0;
33337 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33338 wxString *arg2 = 0 ;
33339 void *argp1 = 0 ;
33340 int res1 = 0 ;
33341 bool temp2 = false ;
33342 PyObject * obj0 = 0 ;
33343 PyObject * obj1 = 0 ;
33344 char * kwnames[] = {
33345 (char *) "self",(char *) "url", NULL
33346 };
33347
33348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33350 if (!SWIG_IsOK(res1)) {
33351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33352 }
33353 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33354 {
33355 arg2 = wxString_in_helper(obj1);
33356 if (arg2 == NULL) SWIG_fail;
33357 temp2 = true;
33358 }
33359 {
33360 PyThreadState* __tstate = wxPyBeginAllowThreads();
33361 (arg1)->SetURL((wxString const &)*arg2);
33362 wxPyEndAllowThreads(__tstate);
33363 if (PyErr_Occurred()) SWIG_fail;
33364 }
33365 resultobj = SWIG_Py_Void();
33366 {
33367 if (temp2)
33368 delete arg2;
33369 }
33370 return resultobj;
33371 fail:
33372 {
33373 if (temp2)
33374 delete arg2;
33375 }
33376 return NULL;
33377 }
33378
33379
33380 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33381 PyObject *obj;
33382 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33383 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33384 return SWIG_Py_Void();
33385 }
33386
33387 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33388 return SWIG_Python_InitShadowInstance(args);
33389 }
33390
33391 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33392 PyObject *resultobj = 0;
33393 wxMetafileDataObject *result = 0 ;
33394
33395 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33396 {
33397 PyThreadState* __tstate = wxPyBeginAllowThreads();
33398 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33399 wxPyEndAllowThreads(__tstate);
33400 if (PyErr_Occurred()) SWIG_fail;
33401 }
33402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33403 return resultobj;
33404 fail:
33405 return NULL;
33406 }
33407
33408
33409 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33410 PyObject *obj;
33411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33412 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33413 return SWIG_Py_Void();
33414 }
33415
33416 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33417 return SWIG_Python_InitShadowInstance(args);
33418 }
33419
33420 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33421 PyObject *resultobj = 0;
33422 wxDragResult arg1 ;
33423 bool result;
33424 int val1 ;
33425 int ecode1 = 0 ;
33426 PyObject * obj0 = 0 ;
33427 char * kwnames[] = {
33428 (char *) "res", NULL
33429 };
33430
33431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33432 ecode1 = SWIG_AsVal_int(obj0, &val1);
33433 if (!SWIG_IsOK(ecode1)) {
33434 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33435 }
33436 arg1 = static_cast< wxDragResult >(val1);
33437 {
33438 PyThreadState* __tstate = wxPyBeginAllowThreads();
33439 result = (bool)wxIsDragResultOk(arg1);
33440 wxPyEndAllowThreads(__tstate);
33441 if (PyErr_Occurred()) SWIG_fail;
33442 }
33443 {
33444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33445 }
33446 return resultobj;
33447 fail:
33448 return NULL;
33449 }
33450
33451
33452 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33453 PyObject *resultobj = 0;
33454 wxWindow *arg1 = (wxWindow *) 0 ;
33455 wxIcon const &arg2_defvalue = wxNullIcon ;
33456 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
33457 wxIcon const &arg3_defvalue = wxNullIcon ;
33458 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
33459 wxIcon const &arg4_defvalue = wxNullIcon ;
33460 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
33461 wxPyDropSource *result = 0 ;
33462 void *argp1 = 0 ;
33463 int res1 = 0 ;
33464 void *argp2 = 0 ;
33465 int res2 = 0 ;
33466 void *argp3 = 0 ;
33467 int res3 = 0 ;
33468 void *argp4 = 0 ;
33469 int res4 = 0 ;
33470 PyObject * obj0 = 0 ;
33471 PyObject * obj1 = 0 ;
33472 PyObject * obj2 = 0 ;
33473 PyObject * obj3 = 0 ;
33474 char * kwnames[] = {
33475 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33476 };
33477
33478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33480 if (!SWIG_IsOK(res1)) {
33481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33482 }
33483 arg1 = reinterpret_cast< wxWindow * >(argp1);
33484 if (obj1) {
33485 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
33486 if (!SWIG_IsOK(res2)) {
33487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33488 }
33489 if (!argp2) {
33490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33491 }
33492 arg2 = reinterpret_cast< wxIcon * >(argp2);
33493 }
33494 if (obj2) {
33495 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
33496 if (!SWIG_IsOK(res3)) {
33497 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33498 }
33499 if (!argp3) {
33500 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33501 }
33502 arg3 = reinterpret_cast< wxIcon * >(argp3);
33503 }
33504 if (obj3) {
33505 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
33506 if (!SWIG_IsOK(res4)) {
33507 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33508 }
33509 if (!argp4) {
33510 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33511 }
33512 arg4 = reinterpret_cast< wxIcon * >(argp4);
33513 }
33514 {
33515 PyThreadState* __tstate = wxPyBeginAllowThreads();
33516 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
33517 wxPyEndAllowThreads(__tstate);
33518 if (PyErr_Occurred()) SWIG_fail;
33519 }
33520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33521 return resultobj;
33522 fail:
33523 return NULL;
33524 }
33525
33526
33527 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33528 PyObject *resultobj = 0;
33529 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33530 PyObject *arg2 = (PyObject *) 0 ;
33531 PyObject *arg3 = (PyObject *) 0 ;
33532 int arg4 ;
33533 void *argp1 = 0 ;
33534 int res1 = 0 ;
33535 int val4 ;
33536 int ecode4 = 0 ;
33537 PyObject * obj0 = 0 ;
33538 PyObject * obj1 = 0 ;
33539 PyObject * obj2 = 0 ;
33540 PyObject * obj3 = 0 ;
33541 char * kwnames[] = {
33542 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33543 };
33544
33545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33547 if (!SWIG_IsOK(res1)) {
33548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33549 }
33550 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33551 arg2 = obj1;
33552 arg3 = obj2;
33553 ecode4 = SWIG_AsVal_int(obj3, &val4);
33554 if (!SWIG_IsOK(ecode4)) {
33555 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33556 }
33557 arg4 = static_cast< int >(val4);
33558 {
33559 PyThreadState* __tstate = wxPyBeginAllowThreads();
33560 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33561 wxPyEndAllowThreads(__tstate);
33562 if (PyErr_Occurred()) SWIG_fail;
33563 }
33564 resultobj = SWIG_Py_Void();
33565 return resultobj;
33566 fail:
33567 return NULL;
33568 }
33569
33570
33571 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33572 PyObject *resultobj = 0;
33573 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33574 void *argp1 = 0 ;
33575 int res1 = 0 ;
33576 PyObject *swig_obj[1] ;
33577
33578 if (!args) SWIG_fail;
33579 swig_obj[0] = args;
33580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33581 if (!SWIG_IsOK(res1)) {
33582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33583 }
33584 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33585 {
33586 PyThreadState* __tstate = wxPyBeginAllowThreads();
33587 delete arg1;
33588
33589 wxPyEndAllowThreads(__tstate);
33590 if (PyErr_Occurred()) SWIG_fail;
33591 }
33592 resultobj = SWIG_Py_Void();
33593 return resultobj;
33594 fail:
33595 return NULL;
33596 }
33597
33598
33599 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33600 PyObject *resultobj = 0;
33601 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33602 wxDataObject *arg2 = 0 ;
33603 void *argp1 = 0 ;
33604 int res1 = 0 ;
33605 void *argp2 = 0 ;
33606 int res2 = 0 ;
33607 PyObject * obj0 = 0 ;
33608 PyObject * obj1 = 0 ;
33609 char * kwnames[] = {
33610 (char *) "self",(char *) "data", NULL
33611 };
33612
33613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33615 if (!SWIG_IsOK(res1)) {
33616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33617 }
33618 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33619 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33620 if (!SWIG_IsOK(res2)) {
33621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33622 }
33623 if (!argp2) {
33624 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33625 }
33626 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33627 {
33628 PyThreadState* __tstate = wxPyBeginAllowThreads();
33629 (arg1)->SetData(*arg2);
33630 wxPyEndAllowThreads(__tstate);
33631 if (PyErr_Occurred()) SWIG_fail;
33632 }
33633 resultobj = SWIG_Py_Void();
33634 return resultobj;
33635 fail:
33636 return NULL;
33637 }
33638
33639
33640 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33641 PyObject *resultobj = 0;
33642 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33643 wxDataObject *result = 0 ;
33644 void *argp1 = 0 ;
33645 int res1 = 0 ;
33646 PyObject *swig_obj[1] ;
33647
33648 if (!args) SWIG_fail;
33649 swig_obj[0] = args;
33650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33651 if (!SWIG_IsOK(res1)) {
33652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33653 }
33654 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33655 {
33656 PyThreadState* __tstate = wxPyBeginAllowThreads();
33657 result = (wxDataObject *)(arg1)->GetDataObject();
33658 wxPyEndAllowThreads(__tstate);
33659 if (PyErr_Occurred()) SWIG_fail;
33660 }
33661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33662 return resultobj;
33663 fail:
33664 return NULL;
33665 }
33666
33667
33668 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33669 PyObject *resultobj = 0;
33670 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33671 wxDragResult arg2 ;
33672 wxCursor *arg3 = 0 ;
33673 void *argp1 = 0 ;
33674 int res1 = 0 ;
33675 int val2 ;
33676 int ecode2 = 0 ;
33677 void *argp3 = 0 ;
33678 int res3 = 0 ;
33679 PyObject * obj0 = 0 ;
33680 PyObject * obj1 = 0 ;
33681 PyObject * obj2 = 0 ;
33682 char * kwnames[] = {
33683 (char *) "self",(char *) "res",(char *) "cursor", NULL
33684 };
33685
33686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33688 if (!SWIG_IsOK(res1)) {
33689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33690 }
33691 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33692 ecode2 = SWIG_AsVal_int(obj1, &val2);
33693 if (!SWIG_IsOK(ecode2)) {
33694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33695 }
33696 arg2 = static_cast< wxDragResult >(val2);
33697 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33698 if (!SWIG_IsOK(res3)) {
33699 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33700 }
33701 if (!argp3) {
33702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33703 }
33704 arg3 = reinterpret_cast< wxCursor * >(argp3);
33705 {
33706 PyThreadState* __tstate = wxPyBeginAllowThreads();
33707 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33708 wxPyEndAllowThreads(__tstate);
33709 if (PyErr_Occurred()) SWIG_fail;
33710 }
33711 resultobj = SWIG_Py_Void();
33712 return resultobj;
33713 fail:
33714 return NULL;
33715 }
33716
33717
33718 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33719 PyObject *resultobj = 0;
33720 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33721 int arg2 = (int) wxDrag_CopyOnly ;
33722 wxDragResult result;
33723 void *argp1 = 0 ;
33724 int res1 = 0 ;
33725 int val2 ;
33726 int ecode2 = 0 ;
33727 PyObject * obj0 = 0 ;
33728 PyObject * obj1 = 0 ;
33729 char * kwnames[] = {
33730 (char *) "self",(char *) "flags", NULL
33731 };
33732
33733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
33734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33735 if (!SWIG_IsOK(res1)) {
33736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33737 }
33738 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33739 if (obj1) {
33740 ecode2 = SWIG_AsVal_int(obj1, &val2);
33741 if (!SWIG_IsOK(ecode2)) {
33742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
33743 }
33744 arg2 = static_cast< int >(val2);
33745 }
33746 {
33747 PyThreadState* __tstate = wxPyBeginAllowThreads();
33748 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
33749 wxPyEndAllowThreads(__tstate);
33750 if (PyErr_Occurred()) SWIG_fail;
33751 }
33752 resultobj = SWIG_From_int(static_cast< int >(result));
33753 return resultobj;
33754 fail:
33755 return NULL;
33756 }
33757
33758
33759 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33760 PyObject *resultobj = 0;
33761 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33762 wxDragResult arg2 ;
33763 bool result;
33764 void *argp1 = 0 ;
33765 int res1 = 0 ;
33766 int val2 ;
33767 int ecode2 = 0 ;
33768 PyObject * obj0 = 0 ;
33769 PyObject * obj1 = 0 ;
33770 char * kwnames[] = {
33771 (char *) "self",(char *) "effect", NULL
33772 };
33773
33774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
33775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33776 if (!SWIG_IsOK(res1)) {
33777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33778 }
33779 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33780 ecode2 = SWIG_AsVal_int(obj1, &val2);
33781 if (!SWIG_IsOK(ecode2)) {
33782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
33783 }
33784 arg2 = static_cast< wxDragResult >(val2);
33785 {
33786 PyThreadState* __tstate = wxPyBeginAllowThreads();
33787 result = (bool)(arg1)->GiveFeedback(arg2);
33788 wxPyEndAllowThreads(__tstate);
33789 if (PyErr_Occurred()) SWIG_fail;
33790 }
33791 {
33792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33793 }
33794 return resultobj;
33795 fail:
33796 return NULL;
33797 }
33798
33799
33800 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33801 PyObject *obj;
33802 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33803 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
33804 return SWIG_Py_Void();
33805 }
33806
33807 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33808 return SWIG_Python_InitShadowInstance(args);
33809 }
33810
33811 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33812 PyObject *resultobj = 0;
33813 wxDataObject *arg1 = (wxDataObject *) NULL ;
33814 wxPyDropTarget *result = 0 ;
33815 int res1 = 0 ;
33816 PyObject * obj0 = 0 ;
33817 char * kwnames[] = {
33818 (char *) "dataObject", NULL
33819 };
33820
33821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
33822 if (obj0) {
33823 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
33824 if (!SWIG_IsOK(res1)) {
33825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
33826 }
33827 }
33828 {
33829 PyThreadState* __tstate = wxPyBeginAllowThreads();
33830 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
33831 wxPyEndAllowThreads(__tstate);
33832 if (PyErr_Occurred()) SWIG_fail;
33833 }
33834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
33835 return resultobj;
33836 fail:
33837 return NULL;
33838 }
33839
33840
33841 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33842 PyObject *resultobj = 0;
33843 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33844 PyObject *arg2 = (PyObject *) 0 ;
33845 PyObject *arg3 = (PyObject *) 0 ;
33846 void *argp1 = 0 ;
33847 int res1 = 0 ;
33848 PyObject * obj0 = 0 ;
33849 PyObject * obj1 = 0 ;
33850 PyObject * obj2 = 0 ;
33851 char * kwnames[] = {
33852 (char *) "self",(char *) "self",(char *) "_class", NULL
33853 };
33854
33855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33857 if (!SWIG_IsOK(res1)) {
33858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33859 }
33860 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33861 arg2 = obj1;
33862 arg3 = obj2;
33863 {
33864 PyThreadState* __tstate = wxPyBeginAllowThreads();
33865 (arg1)->_setCallbackInfo(arg2,arg3);
33866 wxPyEndAllowThreads(__tstate);
33867 if (PyErr_Occurred()) SWIG_fail;
33868 }
33869 resultobj = SWIG_Py_Void();
33870 return resultobj;
33871 fail:
33872 return NULL;
33873 }
33874
33875
33876 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33877 PyObject *resultobj = 0;
33878 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33879 void *argp1 = 0 ;
33880 int res1 = 0 ;
33881 PyObject *swig_obj[1] ;
33882
33883 if (!args) SWIG_fail;
33884 swig_obj[0] = args;
33885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
33886 if (!SWIG_IsOK(res1)) {
33887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33888 }
33889 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33890 {
33891 PyThreadState* __tstate = wxPyBeginAllowThreads();
33892 delete arg1;
33893
33894 wxPyEndAllowThreads(__tstate);
33895 if (PyErr_Occurred()) SWIG_fail;
33896 }
33897 resultobj = SWIG_Py_Void();
33898 return resultobj;
33899 fail:
33900 return NULL;
33901 }
33902
33903
33904 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33905 PyObject *resultobj = 0;
33906 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33907 wxDataObject *result = 0 ;
33908 void *argp1 = 0 ;
33909 int res1 = 0 ;
33910 PyObject *swig_obj[1] ;
33911
33912 if (!args) SWIG_fail;
33913 swig_obj[0] = args;
33914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33915 if (!SWIG_IsOK(res1)) {
33916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33917 }
33918 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33919 {
33920 PyThreadState* __tstate = wxPyBeginAllowThreads();
33921 result = (wxDataObject *)(arg1)->GetDataObject();
33922 wxPyEndAllowThreads(__tstate);
33923 if (PyErr_Occurred()) SWIG_fail;
33924 }
33925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33926 return resultobj;
33927 fail:
33928 return NULL;
33929 }
33930
33931
33932 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33933 PyObject *resultobj = 0;
33934 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33935 wxDataObject *arg2 = (wxDataObject *) 0 ;
33936 void *argp1 = 0 ;
33937 int res1 = 0 ;
33938 int res2 = 0 ;
33939 PyObject * obj0 = 0 ;
33940 PyObject * obj1 = 0 ;
33941 char * kwnames[] = {
33942 (char *) "self",(char *) "dataObject", NULL
33943 };
33944
33945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
33946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33947 if (!SWIG_IsOK(res1)) {
33948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33949 }
33950 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33951 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
33952 if (!SWIG_IsOK(res2)) {
33953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
33954 }
33955 {
33956 PyThreadState* __tstate = wxPyBeginAllowThreads();
33957 (arg1)->SetDataObject(arg2);
33958 wxPyEndAllowThreads(__tstate);
33959 if (PyErr_Occurred()) SWIG_fail;
33960 }
33961 resultobj = SWIG_Py_Void();
33962 return resultobj;
33963 fail:
33964 return NULL;
33965 }
33966
33967
33968 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33969 PyObject *resultobj = 0;
33970 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33971 int arg2 ;
33972 int arg3 ;
33973 wxDragResult arg4 ;
33974 wxDragResult result;
33975 void *argp1 = 0 ;
33976 int res1 = 0 ;
33977 int val2 ;
33978 int ecode2 = 0 ;
33979 int val3 ;
33980 int ecode3 = 0 ;
33981 int val4 ;
33982 int ecode4 = 0 ;
33983 PyObject * obj0 = 0 ;
33984 PyObject * obj1 = 0 ;
33985 PyObject * obj2 = 0 ;
33986 PyObject * obj3 = 0 ;
33987 char * kwnames[] = {
33988 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33989 };
33990
33991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33993 if (!SWIG_IsOK(res1)) {
33994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33995 }
33996 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33997 ecode2 = SWIG_AsVal_int(obj1, &val2);
33998 if (!SWIG_IsOK(ecode2)) {
33999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34000 }
34001 arg2 = static_cast< int >(val2);
34002 ecode3 = SWIG_AsVal_int(obj2, &val3);
34003 if (!SWIG_IsOK(ecode3)) {
34004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34005 }
34006 arg3 = static_cast< int >(val3);
34007 ecode4 = SWIG_AsVal_int(obj3, &val4);
34008 if (!SWIG_IsOK(ecode4)) {
34009 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34010 }
34011 arg4 = static_cast< wxDragResult >(val4);
34012 {
34013 PyThreadState* __tstate = wxPyBeginAllowThreads();
34014 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34015 wxPyEndAllowThreads(__tstate);
34016 if (PyErr_Occurred()) SWIG_fail;
34017 }
34018 resultobj = SWIG_From_int(static_cast< int >(result));
34019 return resultobj;
34020 fail:
34021 return NULL;
34022 }
34023
34024
34025 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34026 PyObject *resultobj = 0;
34027 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34028 int arg2 ;
34029 int arg3 ;
34030 wxDragResult arg4 ;
34031 wxDragResult result;
34032 void *argp1 = 0 ;
34033 int res1 = 0 ;
34034 int val2 ;
34035 int ecode2 = 0 ;
34036 int val3 ;
34037 int ecode3 = 0 ;
34038 int val4 ;
34039 int ecode4 = 0 ;
34040 PyObject * obj0 = 0 ;
34041 PyObject * obj1 = 0 ;
34042 PyObject * obj2 = 0 ;
34043 PyObject * obj3 = 0 ;
34044 char * kwnames[] = {
34045 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34046 };
34047
34048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34050 if (!SWIG_IsOK(res1)) {
34051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34052 }
34053 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34054 ecode2 = SWIG_AsVal_int(obj1, &val2);
34055 if (!SWIG_IsOK(ecode2)) {
34056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34057 }
34058 arg2 = static_cast< int >(val2);
34059 ecode3 = SWIG_AsVal_int(obj2, &val3);
34060 if (!SWIG_IsOK(ecode3)) {
34061 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34062 }
34063 arg3 = static_cast< int >(val3);
34064 ecode4 = SWIG_AsVal_int(obj3, &val4);
34065 if (!SWIG_IsOK(ecode4)) {
34066 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34067 }
34068 arg4 = static_cast< wxDragResult >(val4);
34069 {
34070 PyThreadState* __tstate = wxPyBeginAllowThreads();
34071 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
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_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34083 PyObject *resultobj = 0;
34084 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34085 void *argp1 = 0 ;
34086 int res1 = 0 ;
34087 PyObject *swig_obj[1] ;
34088
34089 if (!args) SWIG_fail;
34090 swig_obj[0] = args;
34091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34092 if (!SWIG_IsOK(res1)) {
34093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34094 }
34095 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34096 {
34097 PyThreadState* __tstate = wxPyBeginAllowThreads();
34098 (arg1)->OnLeave();
34099 wxPyEndAllowThreads(__tstate);
34100 if (PyErr_Occurred()) SWIG_fail;
34101 }
34102 resultobj = SWIG_Py_Void();
34103 return resultobj;
34104 fail:
34105 return NULL;
34106 }
34107
34108
34109 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34110 PyObject *resultobj = 0;
34111 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34112 int arg2 ;
34113 int arg3 ;
34114 bool result;
34115 void *argp1 = 0 ;
34116 int res1 = 0 ;
34117 int val2 ;
34118 int ecode2 = 0 ;
34119 int val3 ;
34120 int ecode3 = 0 ;
34121 PyObject * obj0 = 0 ;
34122 PyObject * obj1 = 0 ;
34123 PyObject * obj2 = 0 ;
34124 char * kwnames[] = {
34125 (char *) "self",(char *) "x",(char *) "y", NULL
34126 };
34127
34128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34130 if (!SWIG_IsOK(res1)) {
34131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34132 }
34133 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34134 ecode2 = SWIG_AsVal_int(obj1, &val2);
34135 if (!SWIG_IsOK(ecode2)) {
34136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34137 }
34138 arg2 = static_cast< int >(val2);
34139 ecode3 = SWIG_AsVal_int(obj2, &val3);
34140 if (!SWIG_IsOK(ecode3)) {
34141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34142 }
34143 arg3 = static_cast< int >(val3);
34144 {
34145 PyThreadState* __tstate = wxPyBeginAllowThreads();
34146 result = (bool)(arg1)->OnDrop(arg2,arg3);
34147 wxPyEndAllowThreads(__tstate);
34148 if (PyErr_Occurred()) SWIG_fail;
34149 }
34150 {
34151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34152 }
34153 return resultobj;
34154 fail:
34155 return NULL;
34156 }
34157
34158
34159 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34160 PyObject *resultobj = 0;
34161 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34162 bool result;
34163 void *argp1 = 0 ;
34164 int res1 = 0 ;
34165 PyObject *swig_obj[1] ;
34166
34167 if (!args) SWIG_fail;
34168 swig_obj[0] = args;
34169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34170 if (!SWIG_IsOK(res1)) {
34171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34172 }
34173 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34174 {
34175 PyThreadState* __tstate = wxPyBeginAllowThreads();
34176 result = (bool)(arg1)->GetData();
34177 wxPyEndAllowThreads(__tstate);
34178 if (PyErr_Occurred()) SWIG_fail;
34179 }
34180 {
34181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34182 }
34183 return resultobj;
34184 fail:
34185 return NULL;
34186 }
34187
34188
34189 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34190 PyObject *resultobj = 0;
34191 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34192 wxDragResult arg2 ;
34193 void *argp1 = 0 ;
34194 int res1 = 0 ;
34195 int val2 ;
34196 int ecode2 = 0 ;
34197 PyObject * obj0 = 0 ;
34198 PyObject * obj1 = 0 ;
34199 char * kwnames[] = {
34200 (char *) "self",(char *) "action", NULL
34201 };
34202
34203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34205 if (!SWIG_IsOK(res1)) {
34206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34207 }
34208 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34209 ecode2 = SWIG_AsVal_int(obj1, &val2);
34210 if (!SWIG_IsOK(ecode2)) {
34211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34212 }
34213 arg2 = static_cast< wxDragResult >(val2);
34214 {
34215 PyThreadState* __tstate = wxPyBeginAllowThreads();
34216 (arg1)->SetDefaultAction(arg2);
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_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34228 PyObject *resultobj = 0;
34229 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34230 wxDragResult result;
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_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34240 }
34241 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34242 {
34243 PyThreadState* __tstate = wxPyBeginAllowThreads();
34244 result = (wxDragResult)(arg1)->GetDefaultAction();
34245 wxPyEndAllowThreads(__tstate);
34246 if (PyErr_Occurred()) SWIG_fail;
34247 }
34248 resultobj = SWIG_From_int(static_cast< int >(result));
34249 return resultobj;
34250 fail:
34251 return NULL;
34252 }
34253
34254
34255 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34256 PyObject *obj;
34257 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34258 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34259 return SWIG_Py_Void();
34260 }
34261
34262 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34263 return SWIG_Python_InitShadowInstance(args);
34264 }
34265
34266 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34267 PyObject *resultobj = 0;
34268 wxPyTextDropTarget *result = 0 ;
34269
34270 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34271 {
34272 PyThreadState* __tstate = wxPyBeginAllowThreads();
34273 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34274 wxPyEndAllowThreads(__tstate);
34275 if (PyErr_Occurred()) SWIG_fail;
34276 }
34277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34278 return resultobj;
34279 fail:
34280 return NULL;
34281 }
34282
34283
34284 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34285 PyObject *resultobj = 0;
34286 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34287 PyObject *arg2 = (PyObject *) 0 ;
34288 PyObject *arg3 = (PyObject *) 0 ;
34289 void *argp1 = 0 ;
34290 int res1 = 0 ;
34291 PyObject * obj0 = 0 ;
34292 PyObject * obj1 = 0 ;
34293 PyObject * obj2 = 0 ;
34294 char * kwnames[] = {
34295 (char *) "self",(char *) "self",(char *) "_class", NULL
34296 };
34297
34298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34300 if (!SWIG_IsOK(res1)) {
34301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34302 }
34303 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34304 arg2 = obj1;
34305 arg3 = obj2;
34306 {
34307 PyThreadState* __tstate = wxPyBeginAllowThreads();
34308 (arg1)->_setCallbackInfo(arg2,arg3);
34309 wxPyEndAllowThreads(__tstate);
34310 if (PyErr_Occurred()) SWIG_fail;
34311 }
34312 resultobj = SWIG_Py_Void();
34313 return resultobj;
34314 fail:
34315 return NULL;
34316 }
34317
34318
34319 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34320 PyObject *resultobj = 0;
34321 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34322 int arg2 ;
34323 int arg3 ;
34324 wxString *arg4 = 0 ;
34325 bool result;
34326 void *argp1 = 0 ;
34327 int res1 = 0 ;
34328 int val2 ;
34329 int ecode2 = 0 ;
34330 int val3 ;
34331 int ecode3 = 0 ;
34332 bool temp4 = false ;
34333 PyObject * obj0 = 0 ;
34334 PyObject * obj1 = 0 ;
34335 PyObject * obj2 = 0 ;
34336 PyObject * obj3 = 0 ;
34337 char * kwnames[] = {
34338 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34339 };
34340
34341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34343 if (!SWIG_IsOK(res1)) {
34344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34345 }
34346 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34347 ecode2 = SWIG_AsVal_int(obj1, &val2);
34348 if (!SWIG_IsOK(ecode2)) {
34349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34350 }
34351 arg2 = static_cast< int >(val2);
34352 ecode3 = SWIG_AsVal_int(obj2, &val3);
34353 if (!SWIG_IsOK(ecode3)) {
34354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34355 }
34356 arg3 = static_cast< int >(val3);
34357 {
34358 arg4 = wxString_in_helper(obj3);
34359 if (arg4 == NULL) SWIG_fail;
34360 temp4 = true;
34361 }
34362 {
34363 PyThreadState* __tstate = wxPyBeginAllowThreads();
34364 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34365 wxPyEndAllowThreads(__tstate);
34366 if (PyErr_Occurred()) SWIG_fail;
34367 }
34368 {
34369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34370 }
34371 {
34372 if (temp4)
34373 delete arg4;
34374 }
34375 return resultobj;
34376 fail:
34377 {
34378 if (temp4)
34379 delete arg4;
34380 }
34381 return NULL;
34382 }
34383
34384
34385 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34386 PyObject *resultobj = 0;
34387 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34388 int arg2 ;
34389 int arg3 ;
34390 wxDragResult arg4 ;
34391 wxDragResult result;
34392 void *argp1 = 0 ;
34393 int res1 = 0 ;
34394 int val2 ;
34395 int ecode2 = 0 ;
34396 int val3 ;
34397 int ecode3 = 0 ;
34398 int val4 ;
34399 int ecode4 = 0 ;
34400 PyObject * obj0 = 0 ;
34401 PyObject * obj1 = 0 ;
34402 PyObject * obj2 = 0 ;
34403 PyObject * obj3 = 0 ;
34404 char * kwnames[] = {
34405 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34406 };
34407
34408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34410 if (!SWIG_IsOK(res1)) {
34411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34412 }
34413 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34414 ecode2 = SWIG_AsVal_int(obj1, &val2);
34415 if (!SWIG_IsOK(ecode2)) {
34416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34417 }
34418 arg2 = static_cast< int >(val2);
34419 ecode3 = SWIG_AsVal_int(obj2, &val3);
34420 if (!SWIG_IsOK(ecode3)) {
34421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34422 }
34423 arg3 = static_cast< int >(val3);
34424 ecode4 = SWIG_AsVal_int(obj3, &val4);
34425 if (!SWIG_IsOK(ecode4)) {
34426 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34427 }
34428 arg4 = static_cast< wxDragResult >(val4);
34429 {
34430 PyThreadState* __tstate = wxPyBeginAllowThreads();
34431 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34432 wxPyEndAllowThreads(__tstate);
34433 if (PyErr_Occurred()) SWIG_fail;
34434 }
34435 resultobj = SWIG_From_int(static_cast< int >(result));
34436 return resultobj;
34437 fail:
34438 return NULL;
34439 }
34440
34441
34442 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34443 PyObject *resultobj = 0;
34444 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34445 int arg2 ;
34446 int arg3 ;
34447 wxDragResult arg4 ;
34448 wxDragResult result;
34449 void *argp1 = 0 ;
34450 int res1 = 0 ;
34451 int val2 ;
34452 int ecode2 = 0 ;
34453 int val3 ;
34454 int ecode3 = 0 ;
34455 int val4 ;
34456 int ecode4 = 0 ;
34457 PyObject * obj0 = 0 ;
34458 PyObject * obj1 = 0 ;
34459 PyObject * obj2 = 0 ;
34460 PyObject * obj3 = 0 ;
34461 char * kwnames[] = {
34462 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34463 };
34464
34465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34467 if (!SWIG_IsOK(res1)) {
34468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34469 }
34470 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34471 ecode2 = SWIG_AsVal_int(obj1, &val2);
34472 if (!SWIG_IsOK(ecode2)) {
34473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34474 }
34475 arg2 = static_cast< int >(val2);
34476 ecode3 = SWIG_AsVal_int(obj2, &val3);
34477 if (!SWIG_IsOK(ecode3)) {
34478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34479 }
34480 arg3 = static_cast< int >(val3);
34481 ecode4 = SWIG_AsVal_int(obj3, &val4);
34482 if (!SWIG_IsOK(ecode4)) {
34483 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34484 }
34485 arg4 = static_cast< wxDragResult >(val4);
34486 {
34487 PyThreadState* __tstate = wxPyBeginAllowThreads();
34488 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34489 wxPyEndAllowThreads(__tstate);
34490 if (PyErr_Occurred()) SWIG_fail;
34491 }
34492 resultobj = SWIG_From_int(static_cast< int >(result));
34493 return resultobj;
34494 fail:
34495 return NULL;
34496 }
34497
34498
34499 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34500 PyObject *resultobj = 0;
34501 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34502 void *argp1 = 0 ;
34503 int res1 = 0 ;
34504 PyObject *swig_obj[1] ;
34505
34506 if (!args) SWIG_fail;
34507 swig_obj[0] = args;
34508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34509 if (!SWIG_IsOK(res1)) {
34510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34511 }
34512 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34513 {
34514 PyThreadState* __tstate = wxPyBeginAllowThreads();
34515 (arg1)->OnLeave();
34516 wxPyEndAllowThreads(__tstate);
34517 if (PyErr_Occurred()) SWIG_fail;
34518 }
34519 resultobj = SWIG_Py_Void();
34520 return resultobj;
34521 fail:
34522 return NULL;
34523 }
34524
34525
34526 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34527 PyObject *resultobj = 0;
34528 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34529 int arg2 ;
34530 int arg3 ;
34531 bool result;
34532 void *argp1 = 0 ;
34533 int res1 = 0 ;
34534 int val2 ;
34535 int ecode2 = 0 ;
34536 int val3 ;
34537 int ecode3 = 0 ;
34538 PyObject * obj0 = 0 ;
34539 PyObject * obj1 = 0 ;
34540 PyObject * obj2 = 0 ;
34541 char * kwnames[] = {
34542 (char *) "self",(char *) "x",(char *) "y", NULL
34543 };
34544
34545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34547 if (!SWIG_IsOK(res1)) {
34548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34549 }
34550 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34551 ecode2 = SWIG_AsVal_int(obj1, &val2);
34552 if (!SWIG_IsOK(ecode2)) {
34553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34554 }
34555 arg2 = static_cast< int >(val2);
34556 ecode3 = SWIG_AsVal_int(obj2, &val3);
34557 if (!SWIG_IsOK(ecode3)) {
34558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34559 }
34560 arg3 = static_cast< int >(val3);
34561 {
34562 PyThreadState* __tstate = wxPyBeginAllowThreads();
34563 result = (bool)(arg1)->OnDrop(arg2,arg3);
34564 wxPyEndAllowThreads(__tstate);
34565 if (PyErr_Occurred()) SWIG_fail;
34566 }
34567 {
34568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34569 }
34570 return resultobj;
34571 fail:
34572 return NULL;
34573 }
34574
34575
34576 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34577 PyObject *resultobj = 0;
34578 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34579 int arg2 ;
34580 int arg3 ;
34581 wxDragResult arg4 ;
34582 wxDragResult result;
34583 void *argp1 = 0 ;
34584 int res1 = 0 ;
34585 int val2 ;
34586 int ecode2 = 0 ;
34587 int val3 ;
34588 int ecode3 = 0 ;
34589 int val4 ;
34590 int ecode4 = 0 ;
34591 PyObject * obj0 = 0 ;
34592 PyObject * obj1 = 0 ;
34593 PyObject * obj2 = 0 ;
34594 PyObject * obj3 = 0 ;
34595 char * kwnames[] = {
34596 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34597 };
34598
34599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34601 if (!SWIG_IsOK(res1)) {
34602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34603 }
34604 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34605 ecode2 = SWIG_AsVal_int(obj1, &val2);
34606 if (!SWIG_IsOK(ecode2)) {
34607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34608 }
34609 arg2 = static_cast< int >(val2);
34610 ecode3 = SWIG_AsVal_int(obj2, &val3);
34611 if (!SWIG_IsOK(ecode3)) {
34612 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34613 }
34614 arg3 = static_cast< int >(val3);
34615 ecode4 = SWIG_AsVal_int(obj3, &val4);
34616 if (!SWIG_IsOK(ecode4)) {
34617 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34618 }
34619 arg4 = static_cast< wxDragResult >(val4);
34620 {
34621 PyThreadState* __tstate = wxPyBeginAllowThreads();
34622 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34623 wxPyEndAllowThreads(__tstate);
34624 if (PyErr_Occurred()) SWIG_fail;
34625 }
34626 resultobj = SWIG_From_int(static_cast< int >(result));
34627 return resultobj;
34628 fail:
34629 return NULL;
34630 }
34631
34632
34633 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34634 PyObject *obj;
34635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34636 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34637 return SWIG_Py_Void();
34638 }
34639
34640 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34641 return SWIG_Python_InitShadowInstance(args);
34642 }
34643
34644 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34645 PyObject *resultobj = 0;
34646 wxPyFileDropTarget *result = 0 ;
34647
34648 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34649 {
34650 PyThreadState* __tstate = wxPyBeginAllowThreads();
34651 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34652 wxPyEndAllowThreads(__tstate);
34653 if (PyErr_Occurred()) SWIG_fail;
34654 }
34655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34656 return resultobj;
34657 fail:
34658 return NULL;
34659 }
34660
34661
34662 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34663 PyObject *resultobj = 0;
34664 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34665 PyObject *arg2 = (PyObject *) 0 ;
34666 PyObject *arg3 = (PyObject *) 0 ;
34667 void *argp1 = 0 ;
34668 int res1 = 0 ;
34669 PyObject * obj0 = 0 ;
34670 PyObject * obj1 = 0 ;
34671 PyObject * obj2 = 0 ;
34672 char * kwnames[] = {
34673 (char *) "self",(char *) "self",(char *) "_class", NULL
34674 };
34675
34676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34678 if (!SWIG_IsOK(res1)) {
34679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34680 }
34681 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34682 arg2 = obj1;
34683 arg3 = obj2;
34684 {
34685 PyThreadState* __tstate = wxPyBeginAllowThreads();
34686 (arg1)->_setCallbackInfo(arg2,arg3);
34687 wxPyEndAllowThreads(__tstate);
34688 if (PyErr_Occurred()) SWIG_fail;
34689 }
34690 resultobj = SWIG_Py_Void();
34691 return resultobj;
34692 fail:
34693 return NULL;
34694 }
34695
34696
34697 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34698 PyObject *resultobj = 0;
34699 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34700 int arg2 ;
34701 int arg3 ;
34702 wxArrayString *arg4 = 0 ;
34703 bool result;
34704 void *argp1 = 0 ;
34705 int res1 = 0 ;
34706 int val2 ;
34707 int ecode2 = 0 ;
34708 int val3 ;
34709 int ecode3 = 0 ;
34710 bool temp4 = false ;
34711 PyObject * obj0 = 0 ;
34712 PyObject * obj1 = 0 ;
34713 PyObject * obj2 = 0 ;
34714 PyObject * obj3 = 0 ;
34715 char * kwnames[] = {
34716 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
34717 };
34718
34719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34721 if (!SWIG_IsOK(res1)) {
34722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34723 }
34724 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34725 ecode2 = SWIG_AsVal_int(obj1, &val2);
34726 if (!SWIG_IsOK(ecode2)) {
34727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
34728 }
34729 arg2 = static_cast< int >(val2);
34730 ecode3 = SWIG_AsVal_int(obj2, &val3);
34731 if (!SWIG_IsOK(ecode3)) {
34732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
34733 }
34734 arg3 = static_cast< int >(val3);
34735 {
34736 if (! PySequence_Check(obj3)) {
34737 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
34738 SWIG_fail;
34739 }
34740 arg4 = new wxArrayString;
34741 temp4 = true;
34742 int i, len=PySequence_Length(obj3);
34743 for (i=0; i<len; i++) {
34744 PyObject* item = PySequence_GetItem(obj3, i);
34745 wxString* s = wxString_in_helper(item);
34746 if (PyErr_Occurred()) SWIG_fail;
34747 arg4->Add(*s);
34748 delete s;
34749 Py_DECREF(item);
34750 }
34751 }
34752 {
34753 PyThreadState* __tstate = wxPyBeginAllowThreads();
34754 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
34755 wxPyEndAllowThreads(__tstate);
34756 if (PyErr_Occurred()) SWIG_fail;
34757 }
34758 {
34759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34760 }
34761 {
34762 if (temp4) delete arg4;
34763 }
34764 return resultobj;
34765 fail:
34766 {
34767 if (temp4) delete arg4;
34768 }
34769 return NULL;
34770 }
34771
34772
34773 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34774 PyObject *resultobj = 0;
34775 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34776 int arg2 ;
34777 int arg3 ;
34778 wxDragResult arg4 ;
34779 wxDragResult result;
34780 void *argp1 = 0 ;
34781 int res1 = 0 ;
34782 int val2 ;
34783 int ecode2 = 0 ;
34784 int val3 ;
34785 int ecode3 = 0 ;
34786 int val4 ;
34787 int ecode4 = 0 ;
34788 PyObject * obj0 = 0 ;
34789 PyObject * obj1 = 0 ;
34790 PyObject * obj2 = 0 ;
34791 PyObject * obj3 = 0 ;
34792 char * kwnames[] = {
34793 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34794 };
34795
34796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34798 if (!SWIG_IsOK(res1)) {
34799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34800 }
34801 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34802 ecode2 = SWIG_AsVal_int(obj1, &val2);
34803 if (!SWIG_IsOK(ecode2)) {
34804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34805 }
34806 arg2 = static_cast< int >(val2);
34807 ecode3 = SWIG_AsVal_int(obj2, &val3);
34808 if (!SWIG_IsOK(ecode3)) {
34809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34810 }
34811 arg3 = static_cast< int >(val3);
34812 ecode4 = SWIG_AsVal_int(obj3, &val4);
34813 if (!SWIG_IsOK(ecode4)) {
34814 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34815 }
34816 arg4 = static_cast< wxDragResult >(val4);
34817 {
34818 PyThreadState* __tstate = wxPyBeginAllowThreads();
34819 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34820 wxPyEndAllowThreads(__tstate);
34821 if (PyErr_Occurred()) SWIG_fail;
34822 }
34823 resultobj = SWIG_From_int(static_cast< int >(result));
34824 return resultobj;
34825 fail:
34826 return NULL;
34827 }
34828
34829
34830 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34831 PyObject *resultobj = 0;
34832 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34833 int arg2 ;
34834 int arg3 ;
34835 wxDragResult arg4 ;
34836 wxDragResult result;
34837 void *argp1 = 0 ;
34838 int res1 = 0 ;
34839 int val2 ;
34840 int ecode2 = 0 ;
34841 int val3 ;
34842 int ecode3 = 0 ;
34843 int val4 ;
34844 int ecode4 = 0 ;
34845 PyObject * obj0 = 0 ;
34846 PyObject * obj1 = 0 ;
34847 PyObject * obj2 = 0 ;
34848 PyObject * obj3 = 0 ;
34849 char * kwnames[] = {
34850 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34851 };
34852
34853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34855 if (!SWIG_IsOK(res1)) {
34856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34857 }
34858 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34859 ecode2 = SWIG_AsVal_int(obj1, &val2);
34860 if (!SWIG_IsOK(ecode2)) {
34861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34862 }
34863 arg2 = static_cast< int >(val2);
34864 ecode3 = SWIG_AsVal_int(obj2, &val3);
34865 if (!SWIG_IsOK(ecode3)) {
34866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34867 }
34868 arg3 = static_cast< int >(val3);
34869 ecode4 = SWIG_AsVal_int(obj3, &val4);
34870 if (!SWIG_IsOK(ecode4)) {
34871 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34872 }
34873 arg4 = static_cast< wxDragResult >(val4);
34874 {
34875 PyThreadState* __tstate = wxPyBeginAllowThreads();
34876 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34877 wxPyEndAllowThreads(__tstate);
34878 if (PyErr_Occurred()) SWIG_fail;
34879 }
34880 resultobj = SWIG_From_int(static_cast< int >(result));
34881 return resultobj;
34882 fail:
34883 return NULL;
34884 }
34885
34886
34887 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34888 PyObject *resultobj = 0;
34889 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34890 void *argp1 = 0 ;
34891 int res1 = 0 ;
34892 PyObject *swig_obj[1] ;
34893
34894 if (!args) SWIG_fail;
34895 swig_obj[0] = args;
34896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34897 if (!SWIG_IsOK(res1)) {
34898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34899 }
34900 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34901 {
34902 PyThreadState* __tstate = wxPyBeginAllowThreads();
34903 (arg1)->OnLeave();
34904 wxPyEndAllowThreads(__tstate);
34905 if (PyErr_Occurred()) SWIG_fail;
34906 }
34907 resultobj = SWIG_Py_Void();
34908 return resultobj;
34909 fail:
34910 return NULL;
34911 }
34912
34913
34914 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34915 PyObject *resultobj = 0;
34916 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34917 int arg2 ;
34918 int arg3 ;
34919 bool result;
34920 void *argp1 = 0 ;
34921 int res1 = 0 ;
34922 int val2 ;
34923 int ecode2 = 0 ;
34924 int val3 ;
34925 int ecode3 = 0 ;
34926 PyObject * obj0 = 0 ;
34927 PyObject * obj1 = 0 ;
34928 PyObject * obj2 = 0 ;
34929 char * kwnames[] = {
34930 (char *) "self",(char *) "x",(char *) "y", NULL
34931 };
34932
34933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34935 if (!SWIG_IsOK(res1)) {
34936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34937 }
34938 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34939 ecode2 = SWIG_AsVal_int(obj1, &val2);
34940 if (!SWIG_IsOK(ecode2)) {
34941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34942 }
34943 arg2 = static_cast< int >(val2);
34944 ecode3 = SWIG_AsVal_int(obj2, &val3);
34945 if (!SWIG_IsOK(ecode3)) {
34946 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34947 }
34948 arg3 = static_cast< int >(val3);
34949 {
34950 PyThreadState* __tstate = wxPyBeginAllowThreads();
34951 result = (bool)(arg1)->OnDrop(arg2,arg3);
34952 wxPyEndAllowThreads(__tstate);
34953 if (PyErr_Occurred()) SWIG_fail;
34954 }
34955 {
34956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34957 }
34958 return resultobj;
34959 fail:
34960 return NULL;
34961 }
34962
34963
34964 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34965 PyObject *resultobj = 0;
34966 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34967 int arg2 ;
34968 int arg3 ;
34969 wxDragResult arg4 ;
34970 wxDragResult result;
34971 void *argp1 = 0 ;
34972 int res1 = 0 ;
34973 int val2 ;
34974 int ecode2 = 0 ;
34975 int val3 ;
34976 int ecode3 = 0 ;
34977 int val4 ;
34978 int ecode4 = 0 ;
34979 PyObject * obj0 = 0 ;
34980 PyObject * obj1 = 0 ;
34981 PyObject * obj2 = 0 ;
34982 PyObject * obj3 = 0 ;
34983 char * kwnames[] = {
34984 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34985 };
34986
34987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34989 if (!SWIG_IsOK(res1)) {
34990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34991 }
34992 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34993 ecode2 = SWIG_AsVal_int(obj1, &val2);
34994 if (!SWIG_IsOK(ecode2)) {
34995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34996 }
34997 arg2 = static_cast< int >(val2);
34998 ecode3 = SWIG_AsVal_int(obj2, &val3);
34999 if (!SWIG_IsOK(ecode3)) {
35000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35001 }
35002 arg3 = static_cast< int >(val3);
35003 ecode4 = SWIG_AsVal_int(obj3, &val4);
35004 if (!SWIG_IsOK(ecode4)) {
35005 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35006 }
35007 arg4 = static_cast< wxDragResult >(val4);
35008 {
35009 PyThreadState* __tstate = wxPyBeginAllowThreads();
35010 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35011 wxPyEndAllowThreads(__tstate);
35012 if (PyErr_Occurred()) SWIG_fail;
35013 }
35014 resultobj = SWIG_From_int(static_cast< int >(result));
35015 return resultobj;
35016 fail:
35017 return NULL;
35018 }
35019
35020
35021 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35022 PyObject *obj;
35023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35024 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35025 return SWIG_Py_Void();
35026 }
35027
35028 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35029 return SWIG_Python_InitShadowInstance(args);
35030 }
35031
35032 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35033 PyObject *resultobj = 0;
35034 wxClipboard *result = 0 ;
35035
35036 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35037 {
35038 PyThreadState* __tstate = wxPyBeginAllowThreads();
35039 result = (wxClipboard *)new wxClipboard();
35040 wxPyEndAllowThreads(__tstate);
35041 if (PyErr_Occurred()) SWIG_fail;
35042 }
35043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35044 return resultobj;
35045 fail:
35046 return NULL;
35047 }
35048
35049
35050 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35051 PyObject *resultobj = 0;
35052 wxClipboard *arg1 = (wxClipboard *) 0 ;
35053 void *argp1 = 0 ;
35054 int res1 = 0 ;
35055 PyObject *swig_obj[1] ;
35056
35057 if (!args) SWIG_fail;
35058 swig_obj[0] = args;
35059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35060 if (!SWIG_IsOK(res1)) {
35061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35062 }
35063 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35064 {
35065 PyThreadState* __tstate = wxPyBeginAllowThreads();
35066 delete arg1;
35067
35068 wxPyEndAllowThreads(__tstate);
35069 if (PyErr_Occurred()) SWIG_fail;
35070 }
35071 resultobj = SWIG_Py_Void();
35072 return resultobj;
35073 fail:
35074 return NULL;
35075 }
35076
35077
35078 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35079 PyObject *resultobj = 0;
35080 wxClipboard *arg1 = (wxClipboard *) 0 ;
35081 bool result;
35082 void *argp1 = 0 ;
35083 int res1 = 0 ;
35084 PyObject *swig_obj[1] ;
35085
35086 if (!args) SWIG_fail;
35087 swig_obj[0] = args;
35088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35089 if (!SWIG_IsOK(res1)) {
35090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35091 }
35092 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35093 {
35094 PyThreadState* __tstate = wxPyBeginAllowThreads();
35095 result = (bool)(arg1)->Open();
35096 wxPyEndAllowThreads(__tstate);
35097 if (PyErr_Occurred()) SWIG_fail;
35098 }
35099 {
35100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35101 }
35102 return resultobj;
35103 fail:
35104 return NULL;
35105 }
35106
35107
35108 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35109 PyObject *resultobj = 0;
35110 wxClipboard *arg1 = (wxClipboard *) 0 ;
35111 void *argp1 = 0 ;
35112 int res1 = 0 ;
35113 PyObject *swig_obj[1] ;
35114
35115 if (!args) SWIG_fail;
35116 swig_obj[0] = args;
35117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35118 if (!SWIG_IsOK(res1)) {
35119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35120 }
35121 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35122 {
35123 PyThreadState* __tstate = wxPyBeginAllowThreads();
35124 (arg1)->Close();
35125 wxPyEndAllowThreads(__tstate);
35126 if (PyErr_Occurred()) SWIG_fail;
35127 }
35128 resultobj = SWIG_Py_Void();
35129 return resultobj;
35130 fail:
35131 return NULL;
35132 }
35133
35134
35135 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35136 PyObject *resultobj = 0;
35137 wxClipboard *arg1 = (wxClipboard *) 0 ;
35138 bool result;
35139 void *argp1 = 0 ;
35140 int res1 = 0 ;
35141 PyObject *swig_obj[1] ;
35142
35143 if (!args) SWIG_fail;
35144 swig_obj[0] = args;
35145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35146 if (!SWIG_IsOK(res1)) {
35147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35148 }
35149 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35150 {
35151 PyThreadState* __tstate = wxPyBeginAllowThreads();
35152 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35153 wxPyEndAllowThreads(__tstate);
35154 if (PyErr_Occurred()) SWIG_fail;
35155 }
35156 {
35157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35158 }
35159 return resultobj;
35160 fail:
35161 return NULL;
35162 }
35163
35164
35165 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35166 PyObject *resultobj = 0;
35167 wxClipboard *arg1 = (wxClipboard *) 0 ;
35168 wxDataObject *arg2 = (wxDataObject *) 0 ;
35169 bool result;
35170 void *argp1 = 0 ;
35171 int res1 = 0 ;
35172 int res2 = 0 ;
35173 PyObject * obj0 = 0 ;
35174 PyObject * obj1 = 0 ;
35175 char * kwnames[] = {
35176 (char *) "self",(char *) "data", NULL
35177 };
35178
35179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35181 if (!SWIG_IsOK(res1)) {
35182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35183 }
35184 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35185 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35186 if (!SWIG_IsOK(res2)) {
35187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35188 }
35189 {
35190 PyThreadState* __tstate = wxPyBeginAllowThreads();
35191 result = (bool)(arg1)->AddData(arg2);
35192 wxPyEndAllowThreads(__tstate);
35193 if (PyErr_Occurred()) SWIG_fail;
35194 }
35195 {
35196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35197 }
35198 return resultobj;
35199 fail:
35200 return NULL;
35201 }
35202
35203
35204 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35205 PyObject *resultobj = 0;
35206 wxClipboard *arg1 = (wxClipboard *) 0 ;
35207 wxDataObject *arg2 = (wxDataObject *) 0 ;
35208 bool result;
35209 void *argp1 = 0 ;
35210 int res1 = 0 ;
35211 int res2 = 0 ;
35212 PyObject * obj0 = 0 ;
35213 PyObject * obj1 = 0 ;
35214 char * kwnames[] = {
35215 (char *) "self",(char *) "data", NULL
35216 };
35217
35218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35220 if (!SWIG_IsOK(res1)) {
35221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35222 }
35223 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35224 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35225 if (!SWIG_IsOK(res2)) {
35226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35227 }
35228 {
35229 PyThreadState* __tstate = wxPyBeginAllowThreads();
35230 result = (bool)(arg1)->SetData(arg2);
35231 wxPyEndAllowThreads(__tstate);
35232 if (PyErr_Occurred()) SWIG_fail;
35233 }
35234 {
35235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35236 }
35237 return resultobj;
35238 fail:
35239 return NULL;
35240 }
35241
35242
35243 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35244 PyObject *resultobj = 0;
35245 wxClipboard *arg1 = (wxClipboard *) 0 ;
35246 wxDataFormat *arg2 = 0 ;
35247 bool result;
35248 void *argp1 = 0 ;
35249 int res1 = 0 ;
35250 void *argp2 = 0 ;
35251 int res2 = 0 ;
35252 PyObject * obj0 = 0 ;
35253 PyObject * obj1 = 0 ;
35254 char * kwnames[] = {
35255 (char *) "self",(char *) "format", NULL
35256 };
35257
35258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35260 if (!SWIG_IsOK(res1)) {
35261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35262 }
35263 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35264 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35265 if (!SWIG_IsOK(res2)) {
35266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35267 }
35268 if (!argp2) {
35269 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35270 }
35271 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35272 {
35273 PyThreadState* __tstate = wxPyBeginAllowThreads();
35274 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
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_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35288 PyObject *resultobj = 0;
35289 wxClipboard *arg1 = (wxClipboard *) 0 ;
35290 wxDataObject *arg2 = 0 ;
35291 bool result;
35292 void *argp1 = 0 ;
35293 int res1 = 0 ;
35294 void *argp2 = 0 ;
35295 int res2 = 0 ;
35296 PyObject * obj0 = 0 ;
35297 PyObject * obj1 = 0 ;
35298 char * kwnames[] = {
35299 (char *) "self",(char *) "data", NULL
35300 };
35301
35302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35304 if (!SWIG_IsOK(res1)) {
35305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35306 }
35307 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35308 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35309 if (!SWIG_IsOK(res2)) {
35310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35311 }
35312 if (!argp2) {
35313 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35314 }
35315 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35316 {
35317 PyThreadState* __tstate = wxPyBeginAllowThreads();
35318 result = (bool)(arg1)->GetData(*arg2);
35319 wxPyEndAllowThreads(__tstate);
35320 if (PyErr_Occurred()) SWIG_fail;
35321 }
35322 {
35323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35324 }
35325 return resultobj;
35326 fail:
35327 return NULL;
35328 }
35329
35330
35331 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35332 PyObject *resultobj = 0;
35333 wxClipboard *arg1 = (wxClipboard *) 0 ;
35334 void *argp1 = 0 ;
35335 int res1 = 0 ;
35336 PyObject *swig_obj[1] ;
35337
35338 if (!args) SWIG_fail;
35339 swig_obj[0] = args;
35340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35341 if (!SWIG_IsOK(res1)) {
35342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35343 }
35344 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35345 {
35346 PyThreadState* __tstate = wxPyBeginAllowThreads();
35347 (arg1)->Clear();
35348 wxPyEndAllowThreads(__tstate);
35349 if (PyErr_Occurred()) SWIG_fail;
35350 }
35351 resultobj = SWIG_Py_Void();
35352 return resultobj;
35353 fail:
35354 return NULL;
35355 }
35356
35357
35358 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35359 PyObject *resultobj = 0;
35360 wxClipboard *arg1 = (wxClipboard *) 0 ;
35361 bool result;
35362 void *argp1 = 0 ;
35363 int res1 = 0 ;
35364 PyObject *swig_obj[1] ;
35365
35366 if (!args) SWIG_fail;
35367 swig_obj[0] = args;
35368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35369 if (!SWIG_IsOK(res1)) {
35370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35371 }
35372 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35373 {
35374 PyThreadState* __tstate = wxPyBeginAllowThreads();
35375 result = (bool)(arg1)->Flush();
35376 wxPyEndAllowThreads(__tstate);
35377 if (PyErr_Occurred()) SWIG_fail;
35378 }
35379 {
35380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35381 }
35382 return resultobj;
35383 fail:
35384 return NULL;
35385 }
35386
35387
35388 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35389 PyObject *resultobj = 0;
35390 wxClipboard *arg1 = (wxClipboard *) 0 ;
35391 bool arg2 = (bool) true ;
35392 void *argp1 = 0 ;
35393 int res1 = 0 ;
35394 bool val2 ;
35395 int ecode2 = 0 ;
35396 PyObject * obj0 = 0 ;
35397 PyObject * obj1 = 0 ;
35398 char * kwnames[] = {
35399 (char *) "self",(char *) "primary", NULL
35400 };
35401
35402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35404 if (!SWIG_IsOK(res1)) {
35405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35406 }
35407 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35408 if (obj1) {
35409 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35410 if (!SWIG_IsOK(ecode2)) {
35411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35412 }
35413 arg2 = static_cast< bool >(val2);
35414 }
35415 {
35416 PyThreadState* __tstate = wxPyBeginAllowThreads();
35417 (arg1)->UsePrimarySelection(arg2);
35418 wxPyEndAllowThreads(__tstate);
35419 if (PyErr_Occurred()) SWIG_fail;
35420 }
35421 resultobj = SWIG_Py_Void();
35422 return resultobj;
35423 fail:
35424 return NULL;
35425 }
35426
35427
35428 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35429 PyObject *resultobj = 0;
35430 wxClipboard *result = 0 ;
35431
35432 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35433 {
35434 PyThreadState* __tstate = wxPyBeginAllowThreads();
35435 result = (wxClipboard *)wxClipboard::Get();
35436 wxPyEndAllowThreads(__tstate);
35437 if (PyErr_Occurred()) SWIG_fail;
35438 }
35439 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35440 return resultobj;
35441 fail:
35442 return NULL;
35443 }
35444
35445
35446 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35447 PyObject *obj;
35448 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35449 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35450 return SWIG_Py_Void();
35451 }
35452
35453 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35454 return SWIG_Python_InitShadowInstance(args);
35455 }
35456
35457 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35458 PyObject *resultobj = 0;
35459 wxClipboard *arg1 = (wxClipboard *) NULL ;
35460 wxClipboardLocker *result = 0 ;
35461 void *argp1 = 0 ;
35462 int res1 = 0 ;
35463 PyObject * obj0 = 0 ;
35464 char * kwnames[] = {
35465 (char *) "clipboard", NULL
35466 };
35467
35468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35469 if (obj0) {
35470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35471 if (!SWIG_IsOK(res1)) {
35472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35473 }
35474 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35475 }
35476 {
35477 PyThreadState* __tstate = wxPyBeginAllowThreads();
35478 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35479 wxPyEndAllowThreads(__tstate);
35480 if (PyErr_Occurred()) SWIG_fail;
35481 }
35482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35483 return resultobj;
35484 fail:
35485 return NULL;
35486 }
35487
35488
35489 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35490 PyObject *resultobj = 0;
35491 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35492 void *argp1 = 0 ;
35493 int res1 = 0 ;
35494 PyObject *swig_obj[1] ;
35495
35496 if (!args) SWIG_fail;
35497 swig_obj[0] = args;
35498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35499 if (!SWIG_IsOK(res1)) {
35500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35501 }
35502 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35503 {
35504 PyThreadState* __tstate = wxPyBeginAllowThreads();
35505 delete arg1;
35506
35507 wxPyEndAllowThreads(__tstate);
35508 if (PyErr_Occurred()) SWIG_fail;
35509 }
35510 resultobj = SWIG_Py_Void();
35511 return resultobj;
35512 fail:
35513 return NULL;
35514 }
35515
35516
35517 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35518 PyObject *resultobj = 0;
35519 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35520 bool result;
35521 void *argp1 = 0 ;
35522 int res1 = 0 ;
35523 PyObject *swig_obj[1] ;
35524
35525 if (!args) SWIG_fail;
35526 swig_obj[0] = args;
35527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35528 if (!SWIG_IsOK(res1)) {
35529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35530 }
35531 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35532 {
35533 PyThreadState* __tstate = wxPyBeginAllowThreads();
35534 result = (bool)wxClipboardLocker___nonzero__(arg1);
35535 wxPyEndAllowThreads(__tstate);
35536 if (PyErr_Occurred()) SWIG_fail;
35537 }
35538 {
35539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35540 }
35541 return resultobj;
35542 fail:
35543 return NULL;
35544 }
35545
35546
35547 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35548 PyObject *obj;
35549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35550 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35551 return SWIG_Py_Void();
35552 }
35553
35554 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35555 return SWIG_Python_InitShadowInstance(args);
35556 }
35557
35558 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35559 PyObject *resultobj = 0;
35560 int arg1 = (int) 0 ;
35561 int arg2 = (int) 0 ;
35562 int arg3 = (int) 0 ;
35563 int arg4 = (int) 0 ;
35564 wxVideoMode *result = 0 ;
35565 int val1 ;
35566 int ecode1 = 0 ;
35567 int val2 ;
35568 int ecode2 = 0 ;
35569 int val3 ;
35570 int ecode3 = 0 ;
35571 int val4 ;
35572 int ecode4 = 0 ;
35573 PyObject * obj0 = 0 ;
35574 PyObject * obj1 = 0 ;
35575 PyObject * obj2 = 0 ;
35576 PyObject * obj3 = 0 ;
35577 char * kwnames[] = {
35578 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35579 };
35580
35581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35582 if (obj0) {
35583 ecode1 = SWIG_AsVal_int(obj0, &val1);
35584 if (!SWIG_IsOK(ecode1)) {
35585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35586 }
35587 arg1 = static_cast< int >(val1);
35588 }
35589 if (obj1) {
35590 ecode2 = SWIG_AsVal_int(obj1, &val2);
35591 if (!SWIG_IsOK(ecode2)) {
35592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35593 }
35594 arg2 = static_cast< int >(val2);
35595 }
35596 if (obj2) {
35597 ecode3 = SWIG_AsVal_int(obj2, &val3);
35598 if (!SWIG_IsOK(ecode3)) {
35599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35600 }
35601 arg3 = static_cast< int >(val3);
35602 }
35603 if (obj3) {
35604 ecode4 = SWIG_AsVal_int(obj3, &val4);
35605 if (!SWIG_IsOK(ecode4)) {
35606 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35607 }
35608 arg4 = static_cast< int >(val4);
35609 }
35610 {
35611 PyThreadState* __tstate = wxPyBeginAllowThreads();
35612 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35613 wxPyEndAllowThreads(__tstate);
35614 if (PyErr_Occurred()) SWIG_fail;
35615 }
35616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35617 return resultobj;
35618 fail:
35619 return NULL;
35620 }
35621
35622
35623 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35624 PyObject *resultobj = 0;
35625 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35626 void *argp1 = 0 ;
35627 int res1 = 0 ;
35628 PyObject *swig_obj[1] ;
35629
35630 if (!args) SWIG_fail;
35631 swig_obj[0] = args;
35632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35633 if (!SWIG_IsOK(res1)) {
35634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35635 }
35636 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35637 {
35638 PyThreadState* __tstate = wxPyBeginAllowThreads();
35639 delete arg1;
35640
35641 wxPyEndAllowThreads(__tstate);
35642 if (PyErr_Occurred()) SWIG_fail;
35643 }
35644 resultobj = SWIG_Py_Void();
35645 return resultobj;
35646 fail:
35647 return NULL;
35648 }
35649
35650
35651 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35652 PyObject *resultobj = 0;
35653 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35654 wxVideoMode *arg2 = 0 ;
35655 bool result;
35656 void *argp1 = 0 ;
35657 int res1 = 0 ;
35658 void *argp2 = 0 ;
35659 int res2 = 0 ;
35660 PyObject * obj0 = 0 ;
35661 PyObject * obj1 = 0 ;
35662 char * kwnames[] = {
35663 (char *) "self",(char *) "other", NULL
35664 };
35665
35666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35668 if (!SWIG_IsOK(res1)) {
35669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35670 }
35671 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35672 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35673 if (!SWIG_IsOK(res2)) {
35674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35675 }
35676 if (!argp2) {
35677 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35678 }
35679 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35680 {
35681 PyThreadState* __tstate = wxPyBeginAllowThreads();
35682 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35683 wxPyEndAllowThreads(__tstate);
35684 if (PyErr_Occurred()) SWIG_fail;
35685 }
35686 {
35687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35688 }
35689 return resultobj;
35690 fail:
35691 return NULL;
35692 }
35693
35694
35695 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35696 PyObject *resultobj = 0;
35697 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35698 int result;
35699 void *argp1 = 0 ;
35700 int res1 = 0 ;
35701 PyObject *swig_obj[1] ;
35702
35703 if (!args) SWIG_fail;
35704 swig_obj[0] = args;
35705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35706 if (!SWIG_IsOK(res1)) {
35707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35708 }
35709 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35710 {
35711 PyThreadState* __tstate = wxPyBeginAllowThreads();
35712 result = (int)((wxVideoMode const *)arg1)->GetWidth();
35713 wxPyEndAllowThreads(__tstate);
35714 if (PyErr_Occurred()) SWIG_fail;
35715 }
35716 resultobj = SWIG_From_int(static_cast< int >(result));
35717 return resultobj;
35718 fail:
35719 return NULL;
35720 }
35721
35722
35723 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35724 PyObject *resultobj = 0;
35725 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35726 int result;
35727 void *argp1 = 0 ;
35728 int res1 = 0 ;
35729 PyObject *swig_obj[1] ;
35730
35731 if (!args) SWIG_fail;
35732 swig_obj[0] = args;
35733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35734 if (!SWIG_IsOK(res1)) {
35735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35736 }
35737 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35738 {
35739 PyThreadState* __tstate = wxPyBeginAllowThreads();
35740 result = (int)((wxVideoMode const *)arg1)->GetHeight();
35741 wxPyEndAllowThreads(__tstate);
35742 if (PyErr_Occurred()) SWIG_fail;
35743 }
35744 resultobj = SWIG_From_int(static_cast< int >(result));
35745 return resultobj;
35746 fail:
35747 return NULL;
35748 }
35749
35750
35751 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35752 PyObject *resultobj = 0;
35753 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35754 int result;
35755 void *argp1 = 0 ;
35756 int res1 = 0 ;
35757 PyObject *swig_obj[1] ;
35758
35759 if (!args) SWIG_fail;
35760 swig_obj[0] = args;
35761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35762 if (!SWIG_IsOK(res1)) {
35763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35764 }
35765 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35766 {
35767 PyThreadState* __tstate = wxPyBeginAllowThreads();
35768 result = (int)((wxVideoMode const *)arg1)->GetDepth();
35769 wxPyEndAllowThreads(__tstate);
35770 if (PyErr_Occurred()) SWIG_fail;
35771 }
35772 resultobj = SWIG_From_int(static_cast< int >(result));
35773 return resultobj;
35774 fail:
35775 return NULL;
35776 }
35777
35778
35779 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35780 PyObject *resultobj = 0;
35781 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35782 bool result;
35783 void *argp1 = 0 ;
35784 int res1 = 0 ;
35785 PyObject *swig_obj[1] ;
35786
35787 if (!args) SWIG_fail;
35788 swig_obj[0] = args;
35789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35790 if (!SWIG_IsOK(res1)) {
35791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35792 }
35793 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35794 {
35795 PyThreadState* __tstate = wxPyBeginAllowThreads();
35796 result = (bool)((wxVideoMode const *)arg1)->IsOk();
35797 wxPyEndAllowThreads(__tstate);
35798 if (PyErr_Occurred()) SWIG_fail;
35799 }
35800 {
35801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35802 }
35803 return resultobj;
35804 fail:
35805 return NULL;
35806 }
35807
35808
35809 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35810 PyObject *resultobj = 0;
35811 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35812 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
35813 bool result;
35814 void *argp1 = 0 ;
35815 int res1 = 0 ;
35816 void *argp2 = 0 ;
35817 int res2 = 0 ;
35818 PyObject * obj0 = 0 ;
35819 PyObject * obj1 = 0 ;
35820 char * kwnames[] = {
35821 (char *) "self",(char *) "other", NULL
35822 };
35823
35824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
35825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35826 if (!SWIG_IsOK(res1)) {
35827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35828 }
35829 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35830 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35831 if (!SWIG_IsOK(res2)) {
35832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
35833 }
35834 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35835 {
35836 PyThreadState* __tstate = wxPyBeginAllowThreads();
35837 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
35838 wxPyEndAllowThreads(__tstate);
35839 if (PyErr_Occurred()) SWIG_fail;
35840 }
35841 {
35842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35843 }
35844 return resultobj;
35845 fail:
35846 return NULL;
35847 }
35848
35849
35850 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35851 PyObject *resultobj = 0;
35852 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35853 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
35854 bool result;
35855 void *argp1 = 0 ;
35856 int res1 = 0 ;
35857 void *argp2 = 0 ;
35858 int res2 = 0 ;
35859 PyObject * obj0 = 0 ;
35860 PyObject * obj1 = 0 ;
35861 char * kwnames[] = {
35862 (char *) "self",(char *) "other", NULL
35863 };
35864
35865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
35866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35867 if (!SWIG_IsOK(res1)) {
35868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35869 }
35870 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35871 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35872 if (!SWIG_IsOK(res2)) {
35873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
35874 }
35875 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35876 {
35877 PyThreadState* __tstate = wxPyBeginAllowThreads();
35878 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
35879 wxPyEndAllowThreads(__tstate);
35880 if (PyErr_Occurred()) SWIG_fail;
35881 }
35882 {
35883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35884 }
35885 return resultobj;
35886 fail:
35887 return NULL;
35888 }
35889
35890
35891 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35892 PyObject *resultobj = 0;
35893 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35894 int arg2 ;
35895 void *argp1 = 0 ;
35896 int res1 = 0 ;
35897 int val2 ;
35898 int ecode2 = 0 ;
35899 PyObject *swig_obj[2] ;
35900
35901 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
35902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35903 if (!SWIG_IsOK(res1)) {
35904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35905 }
35906 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35907 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35908 if (!SWIG_IsOK(ecode2)) {
35909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
35910 }
35911 arg2 = static_cast< int >(val2);
35912 if (arg1) (arg1)->w = arg2;
35913
35914 resultobj = SWIG_Py_Void();
35915 return resultobj;
35916 fail:
35917 return NULL;
35918 }
35919
35920
35921 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35922 PyObject *resultobj = 0;
35923 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35924 int result;
35925 void *argp1 = 0 ;
35926 int res1 = 0 ;
35927 PyObject *swig_obj[1] ;
35928
35929 if (!args) SWIG_fail;
35930 swig_obj[0] = args;
35931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35932 if (!SWIG_IsOK(res1)) {
35933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35934 }
35935 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35936 result = (int) ((arg1)->w);
35937 resultobj = SWIG_From_int(static_cast< int >(result));
35938 return resultobj;
35939 fail:
35940 return NULL;
35941 }
35942
35943
35944 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35945 PyObject *resultobj = 0;
35946 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35947 int arg2 ;
35948 void *argp1 = 0 ;
35949 int res1 = 0 ;
35950 int val2 ;
35951 int ecode2 = 0 ;
35952 PyObject *swig_obj[2] ;
35953
35954 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
35955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35956 if (!SWIG_IsOK(res1)) {
35957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35958 }
35959 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35960 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35961 if (!SWIG_IsOK(ecode2)) {
35962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
35963 }
35964 arg2 = static_cast< int >(val2);
35965 if (arg1) (arg1)->h = arg2;
35966
35967 resultobj = SWIG_Py_Void();
35968 return resultobj;
35969 fail:
35970 return NULL;
35971 }
35972
35973
35974 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35975 PyObject *resultobj = 0;
35976 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35977 int result;
35978 void *argp1 = 0 ;
35979 int res1 = 0 ;
35980 PyObject *swig_obj[1] ;
35981
35982 if (!args) SWIG_fail;
35983 swig_obj[0] = args;
35984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35985 if (!SWIG_IsOK(res1)) {
35986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35987 }
35988 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35989 result = (int) ((arg1)->h);
35990 resultobj = SWIG_From_int(static_cast< int >(result));
35991 return resultobj;
35992 fail:
35993 return NULL;
35994 }
35995
35996
35997 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35998 PyObject *resultobj = 0;
35999 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36000 int arg2 ;
36001 void *argp1 = 0 ;
36002 int res1 = 0 ;
36003 int val2 ;
36004 int ecode2 = 0 ;
36005 PyObject *swig_obj[2] ;
36006
36007 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36009 if (!SWIG_IsOK(res1)) {
36010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36011 }
36012 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36013 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36014 if (!SWIG_IsOK(ecode2)) {
36015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36016 }
36017 arg2 = static_cast< int >(val2);
36018 if (arg1) (arg1)->bpp = arg2;
36019
36020 resultobj = SWIG_Py_Void();
36021 return resultobj;
36022 fail:
36023 return NULL;
36024 }
36025
36026
36027 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36028 PyObject *resultobj = 0;
36029 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36030 int result;
36031 void *argp1 = 0 ;
36032 int res1 = 0 ;
36033 PyObject *swig_obj[1] ;
36034
36035 if (!args) SWIG_fail;
36036 swig_obj[0] = args;
36037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36038 if (!SWIG_IsOK(res1)) {
36039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36040 }
36041 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36042 result = (int) ((arg1)->bpp);
36043 resultobj = SWIG_From_int(static_cast< int >(result));
36044 return resultobj;
36045 fail:
36046 return NULL;
36047 }
36048
36049
36050 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36051 PyObject *resultobj = 0;
36052 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36053 int arg2 ;
36054 void *argp1 = 0 ;
36055 int res1 = 0 ;
36056 int val2 ;
36057 int ecode2 = 0 ;
36058 PyObject *swig_obj[2] ;
36059
36060 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36062 if (!SWIG_IsOK(res1)) {
36063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36064 }
36065 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36066 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36067 if (!SWIG_IsOK(ecode2)) {
36068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36069 }
36070 arg2 = static_cast< int >(val2);
36071 if (arg1) (arg1)->refresh = arg2;
36072
36073 resultobj = SWIG_Py_Void();
36074 return resultobj;
36075 fail:
36076 return NULL;
36077 }
36078
36079
36080 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36081 PyObject *resultobj = 0;
36082 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36083 int result;
36084 void *argp1 = 0 ;
36085 int res1 = 0 ;
36086 PyObject *swig_obj[1] ;
36087
36088 if (!args) SWIG_fail;
36089 swig_obj[0] = args;
36090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36091 if (!SWIG_IsOK(res1)) {
36092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36093 }
36094 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36095 result = (int) ((arg1)->refresh);
36096 resultobj = SWIG_From_int(static_cast< int >(result));
36097 return resultobj;
36098 fail:
36099 return NULL;
36100 }
36101
36102
36103 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36104 PyObject *obj;
36105 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36106 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36107 return SWIG_Py_Void();
36108 }
36109
36110 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36111 return SWIG_Python_InitShadowInstance(args);
36112 }
36113
36114 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36115 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36116 return 1;
36117 }
36118
36119
36120 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36121 PyObject *pyobj = 0;
36122
36123 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36124 return pyobj;
36125 }
36126
36127
36128 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36129 PyObject *resultobj = 0;
36130 size_t arg1 = (size_t) 0 ;
36131 wxDisplay *result = 0 ;
36132 size_t val1 ;
36133 int ecode1 = 0 ;
36134 PyObject * obj0 = 0 ;
36135 char * kwnames[] = {
36136 (char *) "index", NULL
36137 };
36138
36139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36140 if (obj0) {
36141 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
36142 if (!SWIG_IsOK(ecode1)) {
36143 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
36144 }
36145 arg1 = static_cast< size_t >(val1);
36146 }
36147 {
36148 PyThreadState* __tstate = wxPyBeginAllowThreads();
36149 result = (wxDisplay *)new wxDisplay(arg1);
36150 wxPyEndAllowThreads(__tstate);
36151 if (PyErr_Occurred()) SWIG_fail;
36152 }
36153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36154 return resultobj;
36155 fail:
36156 return NULL;
36157 }
36158
36159
36160 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36161 PyObject *resultobj = 0;
36162 wxDisplay *arg1 = (wxDisplay *) 0 ;
36163 void *argp1 = 0 ;
36164 int res1 = 0 ;
36165 PyObject *swig_obj[1] ;
36166
36167 if (!args) SWIG_fail;
36168 swig_obj[0] = args;
36169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36170 if (!SWIG_IsOK(res1)) {
36171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36172 }
36173 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36174 {
36175 PyThreadState* __tstate = wxPyBeginAllowThreads();
36176 delete arg1;
36177
36178 wxPyEndAllowThreads(__tstate);
36179 if (PyErr_Occurred()) SWIG_fail;
36180 }
36181 resultobj = SWIG_Py_Void();
36182 return resultobj;
36183 fail:
36184 return NULL;
36185 }
36186
36187
36188 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36189 PyObject *resultobj = 0;
36190 size_t result;
36191
36192 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36193 {
36194 PyThreadState* __tstate = wxPyBeginAllowThreads();
36195 result = (size_t)wxDisplay::GetCount();
36196 wxPyEndAllowThreads(__tstate);
36197 if (PyErr_Occurred()) SWIG_fail;
36198 }
36199 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
36200 return resultobj;
36201 fail:
36202 return NULL;
36203 }
36204
36205
36206 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36207 PyObject *resultobj = 0;
36208 wxPoint *arg1 = 0 ;
36209 int result;
36210 wxPoint temp1 ;
36211 PyObject * obj0 = 0 ;
36212 char * kwnames[] = {
36213 (char *) "pt", NULL
36214 };
36215
36216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36217 {
36218 arg1 = &temp1;
36219 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36220 }
36221 {
36222 PyThreadState* __tstate = wxPyBeginAllowThreads();
36223 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36224 wxPyEndAllowThreads(__tstate);
36225 if (PyErr_Occurred()) SWIG_fail;
36226 }
36227 resultobj = SWIG_From_int(static_cast< int >(result));
36228 return resultobj;
36229 fail:
36230 return NULL;
36231 }
36232
36233
36234 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36235 PyObject *resultobj = 0;
36236 wxWindow *arg1 = (wxWindow *) 0 ;
36237 int result;
36238 void *argp1 = 0 ;
36239 int res1 = 0 ;
36240 PyObject * obj0 = 0 ;
36241 char * kwnames[] = {
36242 (char *) "window", NULL
36243 };
36244
36245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36247 if (!SWIG_IsOK(res1)) {
36248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36249 }
36250 arg1 = reinterpret_cast< wxWindow * >(argp1);
36251 {
36252 PyThreadState* __tstate = wxPyBeginAllowThreads();
36253 result = (int)wxDisplay::GetFromWindow(arg1);
36254 wxPyEndAllowThreads(__tstate);
36255 if (PyErr_Occurred()) SWIG_fail;
36256 }
36257 resultobj = SWIG_From_int(static_cast< int >(result));
36258 return resultobj;
36259 fail:
36260 return NULL;
36261 }
36262
36263
36264 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36265 PyObject *resultobj = 0;
36266 wxDisplay *arg1 = (wxDisplay *) 0 ;
36267 bool result;
36268 void *argp1 = 0 ;
36269 int res1 = 0 ;
36270 PyObject *swig_obj[1] ;
36271
36272 if (!args) SWIG_fail;
36273 swig_obj[0] = args;
36274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36275 if (!SWIG_IsOK(res1)) {
36276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36277 }
36278 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36279 {
36280 PyThreadState* __tstate = wxPyBeginAllowThreads();
36281 result = (bool)((wxDisplay const *)arg1)->IsOk();
36282 wxPyEndAllowThreads(__tstate);
36283 if (PyErr_Occurred()) SWIG_fail;
36284 }
36285 {
36286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36287 }
36288 return resultobj;
36289 fail:
36290 return NULL;
36291 }
36292
36293
36294 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36295 PyObject *resultobj = 0;
36296 wxDisplay *arg1 = (wxDisplay *) 0 ;
36297 wxRect result;
36298 void *argp1 = 0 ;
36299 int res1 = 0 ;
36300 PyObject *swig_obj[1] ;
36301
36302 if (!args) SWIG_fail;
36303 swig_obj[0] = args;
36304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36305 if (!SWIG_IsOK(res1)) {
36306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36307 }
36308 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36309 {
36310 PyThreadState* __tstate = wxPyBeginAllowThreads();
36311 result = ((wxDisplay const *)arg1)->GetGeometry();
36312 wxPyEndAllowThreads(__tstate);
36313 if (PyErr_Occurred()) SWIG_fail;
36314 }
36315 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36316 return resultobj;
36317 fail:
36318 return NULL;
36319 }
36320
36321
36322 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36323 PyObject *resultobj = 0;
36324 wxDisplay *arg1 = (wxDisplay *) 0 ;
36325 wxRect result;
36326 void *argp1 = 0 ;
36327 int res1 = 0 ;
36328 PyObject *swig_obj[1] ;
36329
36330 if (!args) SWIG_fail;
36331 swig_obj[0] = args;
36332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36333 if (!SWIG_IsOK(res1)) {
36334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36335 }
36336 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36337 {
36338 PyThreadState* __tstate = wxPyBeginAllowThreads();
36339 result = ((wxDisplay const *)arg1)->GetClientArea();
36340 wxPyEndAllowThreads(__tstate);
36341 if (PyErr_Occurred()) SWIG_fail;
36342 }
36343 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36344 return resultobj;
36345 fail:
36346 return NULL;
36347 }
36348
36349
36350 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36351 PyObject *resultobj = 0;
36352 wxDisplay *arg1 = (wxDisplay *) 0 ;
36353 wxString 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_wxDisplay, 0 | 0 );
36361 if (!SWIG_IsOK(res1)) {
36362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36363 }
36364 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36365 {
36366 PyThreadState* __tstate = wxPyBeginAllowThreads();
36367 result = ((wxDisplay const *)arg1)->GetName();
36368 wxPyEndAllowThreads(__tstate);
36369 if (PyErr_Occurred()) SWIG_fail;
36370 }
36371 {
36372 #if wxUSE_UNICODE
36373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36374 #else
36375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36376 #endif
36377 }
36378 return resultobj;
36379 fail:
36380 return NULL;
36381 }
36382
36383
36384 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36385 PyObject *resultobj = 0;
36386 wxDisplay *arg1 = (wxDisplay *) 0 ;
36387 bool result;
36388 void *argp1 = 0 ;
36389 int res1 = 0 ;
36390 PyObject *swig_obj[1] ;
36391
36392 if (!args) SWIG_fail;
36393 swig_obj[0] = args;
36394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36395 if (!SWIG_IsOK(res1)) {
36396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36397 }
36398 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36399 {
36400 PyThreadState* __tstate = wxPyBeginAllowThreads();
36401 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36402 wxPyEndAllowThreads(__tstate);
36403 if (PyErr_Occurred()) SWIG_fail;
36404 }
36405 {
36406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36407 }
36408 return resultobj;
36409 fail:
36410 return NULL;
36411 }
36412
36413
36414 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36415 PyObject *resultobj = 0;
36416 wxDisplay *arg1 = (wxDisplay *) 0 ;
36417 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36418 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36419 PyObject *result = 0 ;
36420 void *argp1 = 0 ;
36421 int res1 = 0 ;
36422 void *argp2 = 0 ;
36423 int res2 = 0 ;
36424 PyObject * obj0 = 0 ;
36425 PyObject * obj1 = 0 ;
36426 char * kwnames[] = {
36427 (char *) "self",(char *) "mode", NULL
36428 };
36429
36430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36432 if (!SWIG_IsOK(res1)) {
36433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36434 }
36435 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36436 if (obj1) {
36437 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36438 if (!SWIG_IsOK(res2)) {
36439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36440 }
36441 if (!argp2) {
36442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36443 }
36444 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36445 }
36446 {
36447 PyThreadState* __tstate = wxPyBeginAllowThreads();
36448 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36449 wxPyEndAllowThreads(__tstate);
36450 if (PyErr_Occurred()) SWIG_fail;
36451 }
36452 resultobj = result;
36453 return resultobj;
36454 fail:
36455 return NULL;
36456 }
36457
36458
36459 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36460 PyObject *resultobj = 0;
36461 wxDisplay *arg1 = (wxDisplay *) 0 ;
36462 wxVideoMode result;
36463 void *argp1 = 0 ;
36464 int res1 = 0 ;
36465 PyObject *swig_obj[1] ;
36466
36467 if (!args) SWIG_fail;
36468 swig_obj[0] = args;
36469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36470 if (!SWIG_IsOK(res1)) {
36471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36472 }
36473 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36474 {
36475 PyThreadState* __tstate = wxPyBeginAllowThreads();
36476 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36477 wxPyEndAllowThreads(__tstate);
36478 if (PyErr_Occurred()) SWIG_fail;
36479 }
36480 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36481 return resultobj;
36482 fail:
36483 return NULL;
36484 }
36485
36486
36487 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36488 PyObject *resultobj = 0;
36489 wxDisplay *arg1 = (wxDisplay *) 0 ;
36490 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36491 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36492 bool result;
36493 void *argp1 = 0 ;
36494 int res1 = 0 ;
36495 void *argp2 = 0 ;
36496 int res2 = 0 ;
36497 PyObject * obj0 = 0 ;
36498 PyObject * obj1 = 0 ;
36499 char * kwnames[] = {
36500 (char *) "self",(char *) "mode", NULL
36501 };
36502
36503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36505 if (!SWIG_IsOK(res1)) {
36506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36507 }
36508 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36509 if (obj1) {
36510 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36511 if (!SWIG_IsOK(res2)) {
36512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36513 }
36514 if (!argp2) {
36515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36516 }
36517 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36518 }
36519 {
36520 PyThreadState* __tstate = wxPyBeginAllowThreads();
36521 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36522 wxPyEndAllowThreads(__tstate);
36523 if (PyErr_Occurred()) SWIG_fail;
36524 }
36525 {
36526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36527 }
36528 return resultobj;
36529 fail:
36530 return NULL;
36531 }
36532
36533
36534 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36535 PyObject *resultobj = 0;
36536 wxDisplay *arg1 = (wxDisplay *) 0 ;
36537 void *argp1 = 0 ;
36538 int res1 = 0 ;
36539 PyObject *swig_obj[1] ;
36540
36541 if (!args) SWIG_fail;
36542 swig_obj[0] = args;
36543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36544 if (!SWIG_IsOK(res1)) {
36545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36546 }
36547 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36548 {
36549 PyThreadState* __tstate = wxPyBeginAllowThreads();
36550 wxDisplay_ResetMode(arg1);
36551 wxPyEndAllowThreads(__tstate);
36552 if (PyErr_Occurred()) SWIG_fail;
36553 }
36554 resultobj = SWIG_Py_Void();
36555 return resultobj;
36556 fail:
36557 return NULL;
36558 }
36559
36560
36561 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36562 PyObject *obj;
36563 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36564 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36565 return SWIG_Py_Void();
36566 }
36567
36568 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36569 return SWIG_Python_InitShadowInstance(args);
36570 }
36571
36572 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36573 PyObject *resultobj = 0;
36574 wxStandardPaths *result = 0 ;
36575
36576 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36577 {
36578 PyThreadState* __tstate = wxPyBeginAllowThreads();
36579 result = (wxStandardPaths *)wxStandardPaths_Get();
36580 wxPyEndAllowThreads(__tstate);
36581 if (PyErr_Occurred()) SWIG_fail;
36582 }
36583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36584 return resultobj;
36585 fail:
36586 return NULL;
36587 }
36588
36589
36590 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36591 PyObject *resultobj = 0;
36592 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36593 wxString result;
36594 void *argp1 = 0 ;
36595 int res1 = 0 ;
36596 PyObject *swig_obj[1] ;
36597
36598 if (!args) SWIG_fail;
36599 swig_obj[0] = args;
36600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36601 if (!SWIG_IsOK(res1)) {
36602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36603 }
36604 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36605 {
36606 PyThreadState* __tstate = wxPyBeginAllowThreads();
36607 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36608 wxPyEndAllowThreads(__tstate);
36609 if (PyErr_Occurred()) SWIG_fail;
36610 }
36611 {
36612 #if wxUSE_UNICODE
36613 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36614 #else
36615 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36616 #endif
36617 }
36618 return resultobj;
36619 fail:
36620 return NULL;
36621 }
36622
36623
36624 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36625 PyObject *resultobj = 0;
36626 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36627 wxString result;
36628 void *argp1 = 0 ;
36629 int res1 = 0 ;
36630 PyObject *swig_obj[1] ;
36631
36632 if (!args) SWIG_fail;
36633 swig_obj[0] = args;
36634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36635 if (!SWIG_IsOK(res1)) {
36636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36637 }
36638 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36639 {
36640 PyThreadState* __tstate = wxPyBeginAllowThreads();
36641 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36642 wxPyEndAllowThreads(__tstate);
36643 if (PyErr_Occurred()) SWIG_fail;
36644 }
36645 {
36646 #if wxUSE_UNICODE
36647 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36648 #else
36649 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36650 #endif
36651 }
36652 return resultobj;
36653 fail:
36654 return NULL;
36655 }
36656
36657
36658 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36659 PyObject *resultobj = 0;
36660 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36661 wxString result;
36662 void *argp1 = 0 ;
36663 int res1 = 0 ;
36664 PyObject *swig_obj[1] ;
36665
36666 if (!args) SWIG_fail;
36667 swig_obj[0] = args;
36668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36669 if (!SWIG_IsOK(res1)) {
36670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36671 }
36672 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36673 {
36674 PyThreadState* __tstate = wxPyBeginAllowThreads();
36675 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36676 wxPyEndAllowThreads(__tstate);
36677 if (PyErr_Occurred()) SWIG_fail;
36678 }
36679 {
36680 #if wxUSE_UNICODE
36681 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36682 #else
36683 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36684 #endif
36685 }
36686 return resultobj;
36687 fail:
36688 return NULL;
36689 }
36690
36691
36692 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36693 PyObject *resultobj = 0;
36694 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36695 wxString result;
36696 void *argp1 = 0 ;
36697 int res1 = 0 ;
36698 PyObject *swig_obj[1] ;
36699
36700 if (!args) SWIG_fail;
36701 swig_obj[0] = args;
36702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36703 if (!SWIG_IsOK(res1)) {
36704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36705 }
36706 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36707 {
36708 PyThreadState* __tstate = wxPyBeginAllowThreads();
36709 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
36710 wxPyEndAllowThreads(__tstate);
36711 if (PyErr_Occurred()) SWIG_fail;
36712 }
36713 {
36714 #if wxUSE_UNICODE
36715 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36716 #else
36717 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36718 #endif
36719 }
36720 return resultobj;
36721 fail:
36722 return NULL;
36723 }
36724
36725
36726 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36727 PyObject *resultobj = 0;
36728 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36729 wxString result;
36730 void *argp1 = 0 ;
36731 int res1 = 0 ;
36732 PyObject *swig_obj[1] ;
36733
36734 if (!args) SWIG_fail;
36735 swig_obj[0] = args;
36736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36737 if (!SWIG_IsOK(res1)) {
36738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36739 }
36740 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36741 {
36742 PyThreadState* __tstate = wxPyBeginAllowThreads();
36743 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
36744 wxPyEndAllowThreads(__tstate);
36745 if (PyErr_Occurred()) SWIG_fail;
36746 }
36747 {
36748 #if wxUSE_UNICODE
36749 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36750 #else
36751 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36752 #endif
36753 }
36754 return resultobj;
36755 fail:
36756 return NULL;
36757 }
36758
36759
36760 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36761 PyObject *resultobj = 0;
36762 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36763 wxString result;
36764 void *argp1 = 0 ;
36765 int res1 = 0 ;
36766 PyObject *swig_obj[1] ;
36767
36768 if (!args) SWIG_fail;
36769 swig_obj[0] = args;
36770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36771 if (!SWIG_IsOK(res1)) {
36772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36773 }
36774 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36775 {
36776 PyThreadState* __tstate = wxPyBeginAllowThreads();
36777 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
36778 wxPyEndAllowThreads(__tstate);
36779 if (PyErr_Occurred()) SWIG_fail;
36780 }
36781 {
36782 #if wxUSE_UNICODE
36783 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36784 #else
36785 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36786 #endif
36787 }
36788 return resultobj;
36789 fail:
36790 return NULL;
36791 }
36792
36793
36794 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36795 PyObject *resultobj = 0;
36796 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36797 wxString result;
36798 void *argp1 = 0 ;
36799 int res1 = 0 ;
36800 PyObject *swig_obj[1] ;
36801
36802 if (!args) SWIG_fail;
36803 swig_obj[0] = args;
36804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36805 if (!SWIG_IsOK(res1)) {
36806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36807 }
36808 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36809 {
36810 PyThreadState* __tstate = wxPyBeginAllowThreads();
36811 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
36812 wxPyEndAllowThreads(__tstate);
36813 if (PyErr_Occurred()) SWIG_fail;
36814 }
36815 {
36816 #if wxUSE_UNICODE
36817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36818 #else
36819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36820 #endif
36821 }
36822 return resultobj;
36823 fail:
36824 return NULL;
36825 }
36826
36827
36828 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36829 PyObject *resultobj = 0;
36830 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36831 wxString result;
36832 void *argp1 = 0 ;
36833 int res1 = 0 ;
36834 PyObject *swig_obj[1] ;
36835
36836 if (!args) SWIG_fail;
36837 swig_obj[0] = args;
36838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36839 if (!SWIG_IsOK(res1)) {
36840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36841 }
36842 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36843 {
36844 PyThreadState* __tstate = wxPyBeginAllowThreads();
36845 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
36846 wxPyEndAllowThreads(__tstate);
36847 if (PyErr_Occurred()) SWIG_fail;
36848 }
36849 {
36850 #if wxUSE_UNICODE
36851 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36852 #else
36853 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36854 #endif
36855 }
36856 return resultobj;
36857 fail:
36858 return NULL;
36859 }
36860
36861
36862 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36863 PyObject *resultobj = 0;
36864 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36865 wxString *arg2 = 0 ;
36866 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
36867 wxString result;
36868 void *argp1 = 0 ;
36869 int res1 = 0 ;
36870 bool temp2 = false ;
36871 int val3 ;
36872 int ecode3 = 0 ;
36873 PyObject * obj0 = 0 ;
36874 PyObject * obj1 = 0 ;
36875 PyObject * obj2 = 0 ;
36876 char * kwnames[] = {
36877 (char *) "self",(char *) "lang",(char *) "category", NULL
36878 };
36879
36880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36882 if (!SWIG_IsOK(res1)) {
36883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36884 }
36885 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36886 {
36887 arg2 = wxString_in_helper(obj1);
36888 if (arg2 == NULL) SWIG_fail;
36889 temp2 = true;
36890 }
36891 if (obj2) {
36892 ecode3 = SWIG_AsVal_int(obj2, &val3);
36893 if (!SWIG_IsOK(ecode3)) {
36894 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
36895 }
36896 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
36897 }
36898 {
36899 PyThreadState* __tstate = wxPyBeginAllowThreads();
36900 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
36901 wxPyEndAllowThreads(__tstate);
36902 if (PyErr_Occurred()) SWIG_fail;
36903 }
36904 {
36905 #if wxUSE_UNICODE
36906 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36907 #else
36908 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36909 #endif
36910 }
36911 {
36912 if (temp2)
36913 delete arg2;
36914 }
36915 return resultobj;
36916 fail:
36917 {
36918 if (temp2)
36919 delete arg2;
36920 }
36921 return NULL;
36922 }
36923
36924
36925 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36926 PyObject *resultobj = 0;
36927 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36928 wxString result;
36929 void *argp1 = 0 ;
36930 int res1 = 0 ;
36931 PyObject *swig_obj[1] ;
36932
36933 if (!args) SWIG_fail;
36934 swig_obj[0] = args;
36935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36936 if (!SWIG_IsOK(res1)) {
36937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36938 }
36939 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36940 {
36941 PyThreadState* __tstate = wxPyBeginAllowThreads();
36942 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
36943 wxPyEndAllowThreads(__tstate);
36944 if (PyErr_Occurred()) SWIG_fail;
36945 }
36946 {
36947 #if wxUSE_UNICODE
36948 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36949 #else
36950 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36951 #endif
36952 }
36953 return resultobj;
36954 fail:
36955 return NULL;
36956 }
36957
36958
36959 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36960 PyObject *resultobj = 0;
36961 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36962 wxString *arg2 = 0 ;
36963 void *argp1 = 0 ;
36964 int res1 = 0 ;
36965 bool temp2 = false ;
36966 PyObject * obj0 = 0 ;
36967 PyObject * obj1 = 0 ;
36968 char * kwnames[] = {
36969 (char *) "self",(char *) "prefix", NULL
36970 };
36971
36972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
36973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36974 if (!SWIG_IsOK(res1)) {
36975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
36976 }
36977 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36978 {
36979 arg2 = wxString_in_helper(obj1);
36980 if (arg2 == NULL) SWIG_fail;
36981 temp2 = true;
36982 }
36983 {
36984 PyThreadState* __tstate = wxPyBeginAllowThreads();
36985 (arg1)->SetInstallPrefix((wxString const &)*arg2);
36986 wxPyEndAllowThreads(__tstate);
36987 if (PyErr_Occurred()) SWIG_fail;
36988 }
36989 resultobj = SWIG_Py_Void();
36990 {
36991 if (temp2)
36992 delete arg2;
36993 }
36994 return resultobj;
36995 fail:
36996 {
36997 if (temp2)
36998 delete arg2;
36999 }
37000 return NULL;
37001 }
37002
37003
37004 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37005 PyObject *resultobj = 0;
37006 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37007 wxString result;
37008 void *argp1 = 0 ;
37009 int res1 = 0 ;
37010 PyObject *swig_obj[1] ;
37011
37012 if (!args) SWIG_fail;
37013 swig_obj[0] = args;
37014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37015 if (!SWIG_IsOK(res1)) {
37016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37017 }
37018 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37019 {
37020 PyThreadState* __tstate = wxPyBeginAllowThreads();
37021 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
37022 wxPyEndAllowThreads(__tstate);
37023 if (PyErr_Occurred()) SWIG_fail;
37024 }
37025 {
37026 #if wxUSE_UNICODE
37027 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37028 #else
37029 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37030 #endif
37031 }
37032 return resultobj;
37033 fail:
37034 return NULL;
37035 }
37036
37037
37038 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37039 PyObject *obj;
37040 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37041 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37042 return SWIG_Py_Void();
37043 }
37044
37045 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37046 PyObject *resultobj = 0;
37047 wxEventType arg1 ;
37048 wxPowerEvent *result = 0 ;
37049 int val1 ;
37050 int ecode1 = 0 ;
37051 PyObject * obj0 = 0 ;
37052 char * kwnames[] = {
37053 (char *) "evtType", NULL
37054 };
37055
37056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37057 ecode1 = SWIG_AsVal_int(obj0, &val1);
37058 if (!SWIG_IsOK(ecode1)) {
37059 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37060 }
37061 arg1 = static_cast< wxEventType >(val1);
37062 {
37063 PyThreadState* __tstate = wxPyBeginAllowThreads();
37064 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37065 wxPyEndAllowThreads(__tstate);
37066 if (PyErr_Occurred()) SWIG_fail;
37067 }
37068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37069 return resultobj;
37070 fail:
37071 return NULL;
37072 }
37073
37074
37075 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37076 PyObject *resultobj = 0;
37077 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37078 void *argp1 = 0 ;
37079 int res1 = 0 ;
37080 PyObject *swig_obj[1] ;
37081
37082 if (!args) SWIG_fail;
37083 swig_obj[0] = args;
37084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37085 if (!SWIG_IsOK(res1)) {
37086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37087 }
37088 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37089 {
37090 PyThreadState* __tstate = wxPyBeginAllowThreads();
37091 (arg1)->Veto();
37092 wxPyEndAllowThreads(__tstate);
37093 if (PyErr_Occurred()) SWIG_fail;
37094 }
37095 resultobj = SWIG_Py_Void();
37096 return resultobj;
37097 fail:
37098 return NULL;
37099 }
37100
37101
37102 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37103 PyObject *resultobj = 0;
37104 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37105 bool result;
37106 void *argp1 = 0 ;
37107 int res1 = 0 ;
37108 PyObject *swig_obj[1] ;
37109
37110 if (!args) SWIG_fail;
37111 swig_obj[0] = args;
37112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37113 if (!SWIG_IsOK(res1)) {
37114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37115 }
37116 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37117 {
37118 PyThreadState* __tstate = wxPyBeginAllowThreads();
37119 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37120 wxPyEndAllowThreads(__tstate);
37121 if (PyErr_Occurred()) SWIG_fail;
37122 }
37123 {
37124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37125 }
37126 return resultobj;
37127 fail:
37128 return NULL;
37129 }
37130
37131
37132 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37133 PyObject *obj;
37134 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37135 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37136 return SWIG_Py_Void();
37137 }
37138
37139 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37140 return SWIG_Python_InitShadowInstance(args);
37141 }
37142
37143 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37144 PyObject *resultobj = 0;
37145 wxPowerType result;
37146
37147 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37148 {
37149 PyThreadState* __tstate = wxPyBeginAllowThreads();
37150 result = (wxPowerType)wxGetPowerType();
37151 wxPyEndAllowThreads(__tstate);
37152 if (PyErr_Occurred()) SWIG_fail;
37153 }
37154 resultobj = SWIG_From_int(static_cast< int >(result));
37155 return resultobj;
37156 fail:
37157 return NULL;
37158 }
37159
37160
37161 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37162 PyObject *resultobj = 0;
37163 wxBatteryState result;
37164
37165 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37166 {
37167 PyThreadState* __tstate = wxPyBeginAllowThreads();
37168 result = (wxBatteryState)wxGetBatteryState();
37169 wxPyEndAllowThreads(__tstate);
37170 if (PyErr_Occurred()) SWIG_fail;
37171 }
37172 resultobj = SWIG_From_int(static_cast< int >(result));
37173 return resultobj;
37174 fail:
37175 return NULL;
37176 }
37177
37178
37179 static PyMethodDef SwigMethods[] = {
37180 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
37181 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
37182 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
37183 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
37184 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
37185 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
37186 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
37187 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
37188 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
37189 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
37190 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
37191 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
37192 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
37193 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
37194 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
37195 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
37196 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
37197 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
37198 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
37199 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
37200 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
37201 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
37202 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
37203 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
37204 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
37205 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
37206 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
37207 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
37208 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
37209 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
37210 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
37211 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
37212 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
37213 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
37214 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
37215 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
37216 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
37217 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
37218 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
37219 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
37220 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
37221 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
37222 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
37223 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
37224 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
37225 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
37226 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
37227 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
37228 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
37229 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37230 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37231 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37232 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37233 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37234 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37235 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
37236 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
37237 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
37238 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37239 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
37240 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
37241 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
37242 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
37243 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
37244 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
37245 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
37246 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
37247 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
37248 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37249 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
37250 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37251 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
37252 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
37253 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
37254 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37255 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37256 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
37257 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
37258 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
37259 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
37260 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
37261 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
37262 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
37263 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
37264 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
37265 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
37266 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
37267 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
37268 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
37269 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
37270 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
37271 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
37272 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
37273 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
37274 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
37275 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
37276 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
37277 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
37278 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
37279 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
37280 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
37281 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
37282 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
37283 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
37284 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
37285 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
37286 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
37287 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
37288 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
37289 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
37290 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
37291 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
37292 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
37293 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
37294 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
37295 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
37296 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
37297 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
37298 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
37299 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
37300 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
37301 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
37302 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
37303 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
37304 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
37305 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
37306 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
37307 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
37308 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
37309 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
37310 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
37311 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
37312 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
37313 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
37314 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
37315 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
37316 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
37317 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
37318 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
37319 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
37320 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37321 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
37322 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
37323 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
37324 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
37325 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
37326 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
37327 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
37328 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37329 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
37330 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
37331 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
37332 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
37333 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37334 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
37335 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
37336 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
37337 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
37338 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
37339 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37340 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
37341 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37342 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37343 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
37344 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37345 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37346 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
37347 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
37348 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
37349 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37350 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
37351 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
37352 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
37353 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
37354 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
37355 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
37356 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
37357 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
37358 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
37359 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
37360 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
37361 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
37362 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37363 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37364 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
37365 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
37366 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
37367 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
37368 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
37369 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
37370 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
37371 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
37372 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
37373 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
37374 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
37375 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
37376 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
37377 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
37378 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
37379 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37380 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37381 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
37382 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
37383 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
37384 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
37385 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
37386 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
37387 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
37388 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
37389 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
37390 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
37391 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
37392 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
37393 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
37394 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37395 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37396 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
37397 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
37398 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
37399 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37400 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
37401 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
37402 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37403 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
37404 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
37405 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37406 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
37407 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
37408 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
37409 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
37410 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
37411 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
37412 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
37413 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
37414 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37415 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
37416 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
37417 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
37418 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
37419 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
37420 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37421 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
37422 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
37423 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
37424 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
37425 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
37426 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
37427 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
37428 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
37429 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
37430 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
37431 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
37432 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
37433 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
37434 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
37435 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
37436 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
37437 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
37438 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
37439 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37440 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37441 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37442 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
37443 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
37444 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
37445 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
37446 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
37447 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37448 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
37449 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
37450 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
37451 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
37452 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
37453 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
37454 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
37455 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
37456 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
37457 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
37458 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
37459 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
37460 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
37461 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
37462 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
37463 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37464 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
37465 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
37466 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
37467 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
37468 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
37469 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
37470 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
37471 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
37472 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
37473 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
37474 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
37475 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
37476 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
37477 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
37478 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
37479 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
37480 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
37481 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
37482 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
37483 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
37484 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
37485 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
37486 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
37487 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
37488 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37489 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
37490 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
37491 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
37492 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
37493 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
37494 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
37495 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
37496 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
37497 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
37498 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
37499 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
37500 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
37501 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
37502 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37503 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
37504 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
37505 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
37506 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
37507 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
37508 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
37509 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37510 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
37511 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
37512 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
37513 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
37514 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
37515 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
37516 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
37517 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
37518 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
37519 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
37520 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
37521 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
37522 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
37523 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37524 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
37525 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
37526 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
37527 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
37528 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
37529 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
37530 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
37531 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
37532 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
37533 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
37534 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
37535 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
37536 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
37537 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
37538 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
37539 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
37540 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
37541 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
37542 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
37543 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
37544 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
37545 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
37546 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
37547 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
37548 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
37549 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
37550 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
37551 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
37552 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
37553 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
37554 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
37555 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
37556 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
37557 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
37558 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
37559 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
37560 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
37561 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
37562 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
37563 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
37564 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
37565 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
37566 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
37567 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
37568 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
37569 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
37570 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
37571 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
37572 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
37573 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
37574 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
37575 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
37576 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
37577 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
37578 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
37579 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
37580 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37581 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
37582 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
37583 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
37584 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
37585 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
37586 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
37587 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
37588 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
37589 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
37590 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
37591 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
37592 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
37593 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
37594 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
37595 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
37596 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
37597 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
37598 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
37599 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
37600 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
37601 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
37602 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
37603 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
37604 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
37605 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
37606 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
37607 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
37608 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
37609 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
37610 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37611 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
37612 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
37613 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
37614 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37615 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
37616 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
37617 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
37618 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
37619 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
37620 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
37621 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
37622 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
37623 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
37624 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
37625 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
37626 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
37627 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
37628 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
37629 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
37630 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
37631 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
37632 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
37633 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
37634 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
37635 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37636 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37637 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
37638 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37639 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37640 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
37641 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37642 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
37643 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
37644 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
37645 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
37646 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
37647 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
37648 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
37649 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
37650 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
37651 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
37652 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
37653 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
37654 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
37655 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
37656 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
37657 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
37658 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
37659 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
37660 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
37661 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37662 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37663 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
37664 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37665 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
37666 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37667 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
37668 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
37669 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
37670 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
37671 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
37672 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
37673 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
37674 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
37675 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
37676 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
37677 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
37678 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
37679 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37680 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
37681 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37682 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
37683 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
37684 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37685 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37686 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
37687 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
37688 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
37689 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
37690 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
37691 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
37692 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
37693 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
37694 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
37695 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
37696 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
37697 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37698 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37699 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37700 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37701 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
37702 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37703 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
37704 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
37705 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
37706 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37707 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
37708 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
37709 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
37710 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
37711 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
37712 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
37713 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
37714 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
37715 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
37716 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
37717 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
37718 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
37719 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
37720 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
37721 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
37722 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
37723 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
37724 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
37725 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
37726 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
37727 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37728 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
37729 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
37730 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
37731 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
37732 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
37733 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37734 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
37735 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
37736 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
37737 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37738 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
37739 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
37740 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
37741 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
37742 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
37743 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
37744 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
37745 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
37746 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
37747 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
37748 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
37749 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
37750 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
37751 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
37752 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
37753 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
37754 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
37755 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
37756 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
37757 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
37758 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
37759 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
37760 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
37761 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37762 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
37763 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
37764 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
37765 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
37766 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
37767 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37768 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37769 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37770 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37771 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37772 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37773 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37774 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37775 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37776 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37777 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37778 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37779 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
37780 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
37781 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
37782 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
37783 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
37784 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
37785 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
37786 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
37787 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
37788 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37789 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37790 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37791 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37792 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37793 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37794 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
37795 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
37796 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37797 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37798 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
37799 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
37800 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
37801 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
37802 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37803 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
37804 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37805 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
37806 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
37807 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
37808 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
37809 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37810 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37811 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37812 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
37813 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
37814 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
37815 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
37816 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
37817 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
37818 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
37819 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
37820 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
37821 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
37822 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
37823 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
37824 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
37825 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37826 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
37827 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
37828 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
37829 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
37830 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
37831 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
37832 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
37833 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
37834 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37835 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37836 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
37837 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37838 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
37839 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
37840 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
37841 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
37842 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
37843 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
37844 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
37845 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
37846 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
37847 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
37848 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
37849 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
37850 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
37851 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
37852 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
37853 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
37854 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
37855 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
37856 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
37857 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
37858 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
37859 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
37860 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
37861 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
37862 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37863 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37864 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
37865 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
37866 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
37867 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
37868 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
37869 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
37870 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
37871 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
37872 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
37873 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
37874 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
37875 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
37876 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
37877 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
37878 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
37879 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37880 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37881 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
37882 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
37883 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
37884 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
37885 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
37886 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
37887 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
37888 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
37889 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
37890 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
37891 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
37892 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
37893 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
37894 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
37895 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
37896 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
37897 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
37898 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
37899 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
37900 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
37901 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
37902 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
37903 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
37904 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
37905 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
37906 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
37907 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
37908 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
37909 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
37910 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
37911 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
37912 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
37913 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
37914 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
37915 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37916 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37917 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
37918 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
37919 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
37920 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
37921 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
37922 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
37923 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
37924 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
37925 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
37926 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
37927 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37928 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37929 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
37930 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
37931 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
37932 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
37933 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
37934 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
37935 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37936 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37937 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
37938 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
37939 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
37940 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
37941 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
37942 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
37943 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
37944 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
37945 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
37946 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
37947 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37948 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
37949 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
37950 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
37951 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
37952 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
37953 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37954 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
37955 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
37956 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
37957 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37958 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
37959 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
37960 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37961 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
37962 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
37963 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
37964 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37965 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
37966 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
37967 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
37968 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37969 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
37970 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
37971 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
37972 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37973 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
37974 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
37975 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
37976 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
37977 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
37978 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37979 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37980 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
37981 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
37982 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37983 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
37984 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
37985 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
37986 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
37987 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37988 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37989 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
37990 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
37991 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
37992 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
37993 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
37994 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
37995 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
37996 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
37997 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37998 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
37999 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
38000 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
38001 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
38002 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38003 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
38004 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
38005 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
38006 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
38007 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
38008 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
38009 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
38010 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
38011 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
38012 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38013 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
38014 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38015 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
38016 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
38017 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38018 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
38019 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
38020 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
38021 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
38022 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38023 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
38024 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
38025 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38026 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38027 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38028 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
38029 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38030 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
38031 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
38032 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
38033 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
38034 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
38035 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
38036 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38037 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
38038 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38039 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38040 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
38041 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38042 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
38043 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
38044 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
38045 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
38046 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38047 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
38048 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38049 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38050 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
38051 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38052 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
38053 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
38054 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
38055 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
38056 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
38057 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
38058 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
38059 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
38060 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
38061 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38062 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
38063 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
38064 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
38065 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
38066 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
38067 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
38068 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
38069 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
38070 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
38071 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
38072 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
38073 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
38074 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
38075 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
38076 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
38077 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
38078 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
38079 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
38080 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
38081 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
38082 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
38083 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
38084 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
38085 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
38086 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
38087 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
38088 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
38089 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
38090 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
38091 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
38092 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
38093 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
38094 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
38095 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
38096 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
38097 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
38098 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
38099 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
38100 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
38101 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
38102 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
38103 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
38104 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
38105 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
38106 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
38107 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
38108 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
38109 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
38110 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
38111 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
38112 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
38113 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
38114 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
38115 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
38116 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
38117 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
38118 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
38119 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
38120 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
38121 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
38122 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
38123 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
38124 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
38125 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
38126 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
38127 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
38128 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
38129 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
38130 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
38131 { NULL, NULL, 0, NULL }
38132 };
38133
38134
38135 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
38136
38137 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
38138 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
38139 }
38140 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
38141 return (void *)((wxEvent *) ((wxMenuEvent *) x));
38142 }
38143 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
38144 return (void *)((wxEvent *) ((wxCloseEvent *) x));
38145 }
38146 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
38147 return (void *)((wxEvent *) ((wxMouseEvent *) x));
38148 }
38149 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
38150 return (void *)((wxEvent *) ((wxEraseEvent *) x));
38151 }
38152 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
38153 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
38154 }
38155 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
38156 return (void *)((wxEvent *) ((wxTimerEvent *) x));
38157 }
38158 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
38159 return (void *)((wxEvent *) ((wxPowerEvent *) x));
38160 }
38161 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
38162 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
38163 }
38164 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
38165 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
38166 }
38167 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
38168 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
38169 }
38170 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
38171 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
38172 }
38173 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
38174 return (void *)((wxEvent *) ((wxPyEvent *) x));
38175 }
38176 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
38177 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
38178 }
38179 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
38180 return (void *)((wxEvent *) ((wxIdleEvent *) x));
38181 }
38182 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
38183 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
38184 }
38185 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
38186 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
38187 }
38188 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
38189 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
38190 }
38191 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
38192 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
38193 }
38194 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
38195 return (void *)((wxEvent *) ((wxActivateEvent *) x));
38196 }
38197 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
38198 return (void *)((wxEvent *) ((wxSizeEvent *) x));
38199 }
38200 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
38201 return (void *)((wxEvent *) ((wxMoveEvent *) x));
38202 }
38203 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
38204 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
38205 }
38206 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
38207 return (void *)((wxEvent *) ((wxPaintEvent *) x));
38208 }
38209 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
38210 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
38211 }
38212 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
38213 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
38214 }
38215 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
38216 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
38217 }
38218 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
38219 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
38220 }
38221 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
38222 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
38223 }
38224 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
38225 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
38226 }
38227 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
38228 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
38229 }
38230 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
38231 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
38232 }
38233 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
38234 return (void *)((wxEvent *) ((wxFocusEvent *) x));
38235 }
38236 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
38237 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
38238 }
38239 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
38240 return (void *)((wxEvent *) ((wxProcessEvent *) x));
38241 }
38242 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
38243 return (void *)((wxEvent *) ((wxShowEvent *) x));
38244 }
38245 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
38246 return (void *)((wxEvent *) ((wxCommandEvent *) x));
38247 }
38248 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
38249 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
38250 }
38251 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
38252 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
38253 }
38254 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
38255 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
38256 }
38257 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
38258 return (void *)((wxEvent *) ((wxKeyEvent *) x));
38259 }
38260 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
38261 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
38262 }
38263 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
38264 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
38265 }
38266 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
38267 return (void *)((wxConfigBase *) ((wxConfig *) x));
38268 }
38269 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
38270 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38271 }
38272 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
38273 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
38274 }
38275 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
38276 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
38277 }
38278 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
38279 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
38280 }
38281 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
38282 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
38283 }
38284 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
38285 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
38286 }
38287 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
38288 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
38289 }
38290 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
38291 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
38292 }
38293 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
38294 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38295 }
38296 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
38297 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
38298 }
38299 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
38300 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
38301 }
38302 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
38303 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
38304 }
38305 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
38306 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
38307 }
38308 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
38309 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
38310 }
38311 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
38312 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
38313 }
38314 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
38315 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
38316 }
38317 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
38318 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
38319 }
38320 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
38321 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38322 }
38323 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
38324 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
38325 }
38326 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
38327 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
38328 }
38329 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
38330 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
38331 }
38332 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
38333 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
38334 }
38335 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
38336 return (void *)((wxEvtHandler *) ((wxWindow *) x));
38337 }
38338 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
38339 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
38340 }
38341 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
38342 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
38343 }
38344 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
38345 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
38346 }
38347 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
38348 return (void *)((wxEvtHandler *) ((wxValidator *) x));
38349 }
38350 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
38351 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
38352 }
38353 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
38354 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
38355 }
38356 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
38357 return (void *)((wxEvtHandler *) ((wxMenu *) x));
38358 }
38359 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
38360 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
38361 }
38362 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
38363 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
38364 }
38365 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
38366 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
38367 }
38368 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
38369 return (void *)((wxObject *) ((wxSizerItem *) x));
38370 }
38371 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
38372 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
38373 }
38374 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
38375 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
38376 }
38377 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
38378 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
38379 }
38380 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
38381 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
38382 }
38383 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
38384 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
38385 }
38386 static void *_p_wxSizerTo_p_wxObject(void *x) {
38387 return (void *)((wxObject *) ((wxSizer *) x));
38388 }
38389 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
38390 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
38391 }
38392 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
38393 return (void *)((wxObject *) ((wxFileHistory *) x));
38394 }
38395 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
38396 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
38397 }
38398 static void *_p_wxEventTo_p_wxObject(void *x) {
38399 return (void *)((wxObject *) ((wxEvent *) x));
38400 }
38401 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
38402 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
38403 }
38404 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
38405 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
38406 }
38407 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
38408 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
38409 }
38410 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
38411 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
38412 }
38413 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
38414 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
38415 }
38416 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
38417 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
38418 }
38419 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
38420 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
38421 }
38422 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
38423 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
38424 }
38425 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
38426 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
38427 }
38428 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
38429 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
38430 }
38431 static void *_p_wxControlTo_p_wxObject(void *x) {
38432 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
38433 }
38434 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
38435 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
38436 }
38437 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
38438 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
38439 }
38440 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
38441 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
38442 }
38443 static void *_p_wxFSFileTo_p_wxObject(void *x) {
38444 return (void *)((wxObject *) ((wxFSFile *) x));
38445 }
38446 static void *_p_wxClipboardTo_p_wxObject(void *x) {
38447 return (void *)((wxObject *) ((wxClipboard *) x));
38448 }
38449 static void *_p_wxPySizerTo_p_wxObject(void *x) {
38450 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
38451 }
38452 static void *_p_wxPyEventTo_p_wxObject(void *x) {
38453 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
38454 }
38455 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
38456 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
38457 }
38458 static void *_p_wxShowEventTo_p_wxObject(void *x) {
38459 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
38460 }
38461 static void *_p_wxToolTipTo_p_wxObject(void *x) {
38462 return (void *)((wxObject *) ((wxToolTip *) x));
38463 }
38464 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
38465 return (void *)((wxObject *) ((wxMenuItem *) x));
38466 }
38467 static void *_p_wxDateEventTo_p_wxObject(void *x) {
38468 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
38469 }
38470 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
38471 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
38472 }
38473 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
38474 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
38475 }
38476 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
38477 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
38478 }
38479 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
38480 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
38481 }
38482 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
38483 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
38484 }
38485 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
38486 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
38487 }
38488 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
38489 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
38490 }
38491 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
38492 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
38493 }
38494 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
38495 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
38496 }
38497 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
38498 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
38499 }
38500 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
38501 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
38502 }
38503 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
38504 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
38505 }
38506 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
38507 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
38508 }
38509 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
38510 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
38511 }
38512 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
38513 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
38514 }
38515 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
38516 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
38517 }
38518 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
38519 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
38520 }
38521 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
38522 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
38523 }
38524 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
38525 return (void *)((wxObject *) ((wxImageHandler *) x));
38526 }
38527 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
38528 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
38529 }
38530 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
38531 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
38532 }
38533 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
38534 return (void *)((wxObject *) ((wxEvtHandler *) x));
38535 }
38536 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
38537 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
38538 }
38539 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
38540 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
38541 }
38542 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
38543 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
38544 }
38545 static void *_p_wxImageTo_p_wxObject(void *x) {
38546 return (void *)((wxObject *) ((wxImage *) x));
38547 }
38548 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
38549 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
38550 }
38551 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
38552 return (void *)((wxObject *) ((wxSystemOptions *) x));
38553 }
38554 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
38555 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
38556 }
38557 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
38558 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
38559 }
38560 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
38561 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
38562 }
38563 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
38564 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
38565 }
38566 static void *_p_wxWindowTo_p_wxObject(void *x) {
38567 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
38568 }
38569 static void *_p_wxMenuTo_p_wxObject(void *x) {
38570 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
38571 }
38572 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
38573 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
38574 }
38575 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
38576 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
38577 }
38578 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
38579 return (void *)((wxObject *) ((wxFileSystem *) x));
38580 }
38581 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
38582 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
38583 }
38584 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
38585 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
38586 }
38587 static void *_p_wxPyAppTo_p_wxObject(void *x) {
38588 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
38589 }
38590 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
38591 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
38592 }
38593 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
38594 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
38595 }
38596 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
38597 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
38598 }
38599 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
38600 return (void *)((wxObject *) ((wxBusyInfo *) x));
38601 }
38602 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
38603 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
38604 }
38605 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
38606 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
38607 }
38608 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
38609 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
38610 }
38611 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
38612 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
38613 }
38614 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
38615 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
38616 }
38617 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
38618 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
38619 }
38620 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
38621 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
38622 }
38623 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
38624 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
38625 }
38626 static void *_p_wxValidatorTo_p_wxObject(void *x) {
38627 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
38628 }
38629 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
38630 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
38631 }
38632 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
38633 return (void *)((wxLog *) ((wxLogBuffer *) x));
38634 }
38635 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
38636 return (void *)((wxLog *) ((wxLogStderr *) x));
38637 }
38638 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
38639 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
38640 }
38641 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
38642 return (void *)((wxLog *) ((wxLogWindow *) x));
38643 }
38644 static void *_p_wxLogChainTo_p_wxLog(void *x) {
38645 return (void *)((wxLog *) ((wxLogChain *) x));
38646 }
38647 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
38648 return (void *)((wxLog *) ((wxLogGui *) x));
38649 }
38650 static void *_p_wxPyLogTo_p_wxLog(void *x) {
38651 return (void *)((wxLog *) ((wxPyLog *) x));
38652 }
38653 static void *_p_wxControlTo_p_wxWindow(void *x) {
38654 return (void *)((wxWindow *) ((wxControl *) x));
38655 }
38656 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
38657 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
38658 }
38659 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
38660 return (void *)((wxWindow *) ((wxMenuBar *) x));
38661 }
38662 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
38663 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
38664 }
38665 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
38666 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
38667 }
38668 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
38669 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};
38670 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
38671 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
38672 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
38673 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
38674 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
38675 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
38676 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
38677 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
38678 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
38679 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
38680 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
38681 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
38682 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
38683 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
38684 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
38685 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
38686 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
38687 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
38688 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
38689 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
38690 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
38691 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
38692 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
38693 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
38694 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
38695 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
38696 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
38697 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
38698 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
38699 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
38700 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
38701 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
38702 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
38703 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
38704 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
38705 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
38706 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
38707 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
38708 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
38709 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
38710 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
38711 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
38712 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
38713 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
38714 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
38715 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
38716 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
38717 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
38718 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
38719 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
38720 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
38721 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
38722 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
38723 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
38724 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
38725 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
38726 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
38727 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
38728 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
38729 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
38730 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
38731 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
38732 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
38733 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
38734 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
38735 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
38736 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
38737 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
38738 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
38739 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
38740 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
38741 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
38742 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
38743 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
38744 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
38745 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
38746 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
38747 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
38748 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
38749 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
38750 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
38751 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
38752 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
38753 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
38754 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
38755 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
38756 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
38757 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
38758 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
38759 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
38760 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
38761 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
38762 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
38763 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
38764 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
38765 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
38766 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
38767 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
38768 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
38769 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
38770 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
38771 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
38772 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
38773 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
38774 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
38775 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
38776 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
38777 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
38778 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
38779 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
38780 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
38781 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
38782 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
38783 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
38784 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
38785 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
38786 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
38787 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
38788 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
38789 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
38790 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
38791 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
38792 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
38793 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
38794 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
38795 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
38796 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
38797 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
38798 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
38799 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
38800 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
38801 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
38802 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
38803 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
38804 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
38805 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
38806 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
38807 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
38808 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
38809 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
38810 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
38811 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
38812 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
38813 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
38814 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
38815 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
38816 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
38817 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
38818 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
38819 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
38820 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
38821 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
38822 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
38823 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
38824 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
38825 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
38826 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
38827 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
38828 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
38829 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
38830 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
38831 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
38832 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
38833 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
38834 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
38835 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
38836 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
38837 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
38838 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
38839 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
38840
38841 static swig_type_info *swig_type_initial[] = {
38842 &_swigt__p_char,
38843 &_swigt__p_form_ops_t,
38844 &_swigt__p_int,
38845 &_swigt__p_unsigned_char,
38846 &_swigt__p_unsigned_int,
38847 &_swigt__p_unsigned_long,
38848 &_swigt__p_void,
38849 &_swigt__p_wxANIHandler,
38850 &_swigt__p_wxAcceleratorTable,
38851 &_swigt__p_wxActivateEvent,
38852 &_swigt__p_wxArrayString,
38853 &_swigt__p_wxBMPHandler,
38854 &_swigt__p_wxBitmap,
38855 &_swigt__p_wxBitmapDataObject,
38856 &_swigt__p_wxBoxSizer,
38857 &_swigt__p_wxBusyCursor,
38858 &_swigt__p_wxBusyInfo,
38859 &_swigt__p_wxCURHandler,
38860 &_swigt__p_wxCaret,
38861 &_swigt__p_wxChar,
38862 &_swigt__p_wxChildFocusEvent,
38863 &_swigt__p_wxClipboard,
38864 &_swigt__p_wxClipboardLocker,
38865 &_swigt__p_wxClipboardTextEvent,
38866 &_swigt__p_wxCloseEvent,
38867 &_swigt__p_wxColour,
38868 &_swigt__p_wxCommandEvent,
38869 &_swigt__p_wxConfig,
38870 &_swigt__p_wxConfigBase,
38871 &_swigt__p_wxConfigPathChanger,
38872 &_swigt__p_wxContextMenuEvent,
38873 &_swigt__p_wxControl,
38874 &_swigt__p_wxControlWithItems,
38875 &_swigt__p_wxCursor,
38876 &_swigt__p_wxCustomDataObject,
38877 &_swigt__p_wxDC,
38878 &_swigt__p_wxDataFormat,
38879 &_swigt__p_wxDataObject,
38880 &_swigt__p_wxDataObjectComposite,
38881 &_swigt__p_wxDataObjectSimple,
38882 &_swigt__p_wxDateEvent,
38883 &_swigt__p_wxDateSpan,
38884 &_swigt__p_wxDateTime,
38885 &_swigt__p_wxDateTime__TimeZone,
38886 &_swigt__p_wxDisplay,
38887 &_swigt__p_wxDisplayChangedEvent,
38888 &_swigt__p_wxDropFilesEvent,
38889 &_swigt__p_wxDuplexMode,
38890 &_swigt__p_wxEraseEvent,
38891 &_swigt__p_wxEvent,
38892 &_swigt__p_wxEvtHandler,
38893 &_swigt__p_wxFSFile,
38894 &_swigt__p_wxFileConfig,
38895 &_swigt__p_wxFileDataObject,
38896 &_swigt__p_wxFileHistory,
38897 &_swigt__p_wxFileSystem,
38898 &_swigt__p_wxFileType,
38899 &_swigt__p_wxFileTypeInfo,
38900 &_swigt__p_wxFlexGridSizer,
38901 &_swigt__p_wxFocusEvent,
38902 &_swigt__p_wxFont,
38903 &_swigt__p_wxFrame,
38904 &_swigt__p_wxGBSizerItem,
38905 &_swigt__p_wxGIFHandler,
38906 &_swigt__p_wxGridBagSizer,
38907 &_swigt__p_wxGridSizer,
38908 &_swigt__p_wxICOHandler,
38909 &_swigt__p_wxIcon,
38910 &_swigt__p_wxIconizeEvent,
38911 &_swigt__p_wxIdleEvent,
38912 &_swigt__p_wxImage,
38913 &_swigt__p_wxImageHandler,
38914 &_swigt__p_wxIndividualLayoutConstraint,
38915 &_swigt__p_wxInitDialogEvent,
38916 &_swigt__p_wxJPEGHandler,
38917 &_swigt__p_wxJoystick,
38918 &_swigt__p_wxJoystickEvent,
38919 &_swigt__p_wxKeyEvent,
38920 &_swigt__p_wxKillError,
38921 &_swigt__p_wxLayoutConstraints,
38922 &_swigt__p_wxLog,
38923 &_swigt__p_wxLogBuffer,
38924 &_swigt__p_wxLogChain,
38925 &_swigt__p_wxLogGui,
38926 &_swigt__p_wxLogNull,
38927 &_swigt__p_wxLogStderr,
38928 &_swigt__p_wxLogTextCtrl,
38929 &_swigt__p_wxLogWindow,
38930 &_swigt__p_wxMaximizeEvent,
38931 &_swigt__p_wxMenu,
38932 &_swigt__p_wxMenuBar,
38933 &_swigt__p_wxMenuEvent,
38934 &_swigt__p_wxMenuItem,
38935 &_swigt__p_wxMetafileDataObject,
38936 &_swigt__p_wxMimeTypesManager,
38937 &_swigt__p_wxMouseCaptureChangedEvent,
38938 &_swigt__p_wxMouseCaptureLostEvent,
38939 &_swigt__p_wxMouseEvent,
38940 &_swigt__p_wxMouseState,
38941 &_swigt__p_wxMoveEvent,
38942 &_swigt__p_wxMutexGuiLocker,
38943 &_swigt__p_wxNavigationKeyEvent,
38944 &_swigt__p_wxNcPaintEvent,
38945 &_swigt__p_wxNotifyEvent,
38946 &_swigt__p_wxObject,
38947 &_swigt__p_wxOutputStream,
38948 &_swigt__p_wxPCXHandler,
38949 &_swigt__p_wxPNGHandler,
38950 &_swigt__p_wxPNMHandler,
38951 &_swigt__p_wxPaintEvent,
38952 &_swigt__p_wxPaletteChangedEvent,
38953 &_swigt__p_wxPaperSize,
38954 &_swigt__p_wxPlatformInfo,
38955 &_swigt__p_wxPoint,
38956 &_swigt__p_wxPowerEvent,
38957 &_swigt__p_wxProcessEvent,
38958 &_swigt__p_wxPyApp,
38959 &_swigt__p_wxPyArtProvider,
38960 &_swigt__p_wxPyBitmapDataObject,
38961 &_swigt__p_wxPyCommandEvent,
38962 &_swigt__p_wxPyDataObjectSimple,
38963 &_swigt__p_wxPyDropSource,
38964 &_swigt__p_wxPyDropTarget,
38965 &_swigt__p_wxPyEvent,
38966 &_swigt__p_wxPyFileDropTarget,
38967 &_swigt__p_wxPyImageHandler,
38968 &_swigt__p_wxPyLog,
38969 &_swigt__p_wxPyProcess,
38970 &_swigt__p_wxPySizer,
38971 &_swigt__p_wxPyTextDataObject,
38972 &_swigt__p_wxPyTextDropTarget,
38973 &_swigt__p_wxPyTimer,
38974 &_swigt__p_wxPyTipProvider,
38975 &_swigt__p_wxPyValidator,
38976 &_swigt__p_wxQueryNewPaletteEvent,
38977 &_swigt__p_wxRect,
38978 &_swigt__p_wxScrollEvent,
38979 &_swigt__p_wxScrollWinEvent,
38980 &_swigt__p_wxSetCursorEvent,
38981 &_swigt__p_wxShowEvent,
38982 &_swigt__p_wxSingleInstanceChecker,
38983 &_swigt__p_wxSize,
38984 &_swigt__p_wxSizeEvent,
38985 &_swigt__p_wxSizer,
38986 &_swigt__p_wxSizerItem,
38987 &_swigt__p_wxSound,
38988 &_swigt__p_wxStandardPaths,
38989 &_swigt__p_wxStaticBoxSizer,
38990 &_swigt__p_wxStdDialogButtonSizer,
38991 &_swigt__p_wxStopWatch,
38992 &_swigt__p_wxString,
38993 &_swigt__p_wxSysColourChangedEvent,
38994 &_swigt__p_wxSystemOptions,
38995 &_swigt__p_wxSystemSettings,
38996 &_swigt__p_wxTIFFHandler,
38997 &_swigt__p_wxTextCtrl,
38998 &_swigt__p_wxTextDataObject,
38999 &_swigt__p_wxTimeSpan,
39000 &_swigt__p_wxTimer,
39001 &_swigt__p_wxTimerEvent,
39002 &_swigt__p_wxTimerRunner,
39003 &_swigt__p_wxTipProvider,
39004 &_swigt__p_wxToolTip,
39005 &_swigt__p_wxURLDataObject,
39006 &_swigt__p_wxUpdateUIEvent,
39007 &_swigt__p_wxValidator,
39008 &_swigt__p_wxVideoMode,
39009 &_swigt__p_wxWindow,
39010 &_swigt__p_wxWindowCreateEvent,
39011 &_swigt__p_wxWindowDestroyEvent,
39012 &_swigt__p_wxWindowDisabler,
39013 &_swigt__p_wxXPMHandler,
39014 };
39015
39016 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
39017 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
39018 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
39019 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
39020 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
39021 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
39022 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
39023 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
39024 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
39025 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}};
39026 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
39027 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
39028 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
39029 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
39030 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
39031 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
39032 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
39033 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
39034 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}};
39035 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
39036 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
39037 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
39038 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
39039 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
39040 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}};
39041 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
39042 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}};
39043 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
39044 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
39045 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
39046 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
39047 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
39048 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
39049 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
39050 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
39051 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
39052 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
39053 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
39054 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
39055 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
39056 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
39057 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
39058 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
39059 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
39060 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
39061 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
39062 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39063 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39064 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
39065 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39066 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
39067 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
39068 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
39069 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
39070 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
39071 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
39072 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39073 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39074 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39075 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39076 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
39077 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
39078 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
39079 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
39080 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
39081 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
39082 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
39083 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
39084 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
39085 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
39086 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}};
39087 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
39088 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
39089 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
39090 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
39091 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
39092 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
39093 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}};
39094 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
39095 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
39096 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
39097 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
39098 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
39099 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
39100 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
39101 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
39102 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
39103 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
39104 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
39105 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}};
39106 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
39107 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
39108 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
39109 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
39110 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
39111 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
39112 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
39113 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
39114 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
39115 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
39116 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
39117 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
39118 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
39119 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
39120 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
39121 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
39122 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
39123 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
39124 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
39125 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
39126 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
39127 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
39128 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
39129 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
39130 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
39131 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
39132 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
39133 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
39134 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
39135 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
39136 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
39137 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
39138 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
39139 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
39140 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
39141 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
39142 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
39143 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
39144 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
39145 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
39146 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
39147 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
39148 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
39149 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
39150 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
39151 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
39152 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
39153 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
39154 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
39155 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
39156 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
39157 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
39158 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
39159 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}};
39160 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
39161 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
39162 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
39163 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
39164 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
39165 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
39166 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
39167 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
39168 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
39169 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
39170 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
39171 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
39172 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
39173 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
39174 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
39175 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
39176 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
39177 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}};
39178 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
39179 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
39180 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
39181 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
39182 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}};
39183 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
39184 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
39185 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
39186 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}};
39187 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
39188
39189 static swig_cast_info *swig_cast_initial[] = {
39190 _swigc__p_char,
39191 _swigc__p_form_ops_t,
39192 _swigc__p_int,
39193 _swigc__p_unsigned_char,
39194 _swigc__p_unsigned_int,
39195 _swigc__p_unsigned_long,
39196 _swigc__p_void,
39197 _swigc__p_wxANIHandler,
39198 _swigc__p_wxAcceleratorTable,
39199 _swigc__p_wxActivateEvent,
39200 _swigc__p_wxArrayString,
39201 _swigc__p_wxBMPHandler,
39202 _swigc__p_wxBitmap,
39203 _swigc__p_wxBitmapDataObject,
39204 _swigc__p_wxBoxSizer,
39205 _swigc__p_wxBusyCursor,
39206 _swigc__p_wxBusyInfo,
39207 _swigc__p_wxCURHandler,
39208 _swigc__p_wxCaret,
39209 _swigc__p_wxChar,
39210 _swigc__p_wxChildFocusEvent,
39211 _swigc__p_wxClipboard,
39212 _swigc__p_wxClipboardLocker,
39213 _swigc__p_wxClipboardTextEvent,
39214 _swigc__p_wxCloseEvent,
39215 _swigc__p_wxColour,
39216 _swigc__p_wxCommandEvent,
39217 _swigc__p_wxConfig,
39218 _swigc__p_wxConfigBase,
39219 _swigc__p_wxConfigPathChanger,
39220 _swigc__p_wxContextMenuEvent,
39221 _swigc__p_wxControl,
39222 _swigc__p_wxControlWithItems,
39223 _swigc__p_wxCursor,
39224 _swigc__p_wxCustomDataObject,
39225 _swigc__p_wxDC,
39226 _swigc__p_wxDataFormat,
39227 _swigc__p_wxDataObject,
39228 _swigc__p_wxDataObjectComposite,
39229 _swigc__p_wxDataObjectSimple,
39230 _swigc__p_wxDateEvent,
39231 _swigc__p_wxDateSpan,
39232 _swigc__p_wxDateTime,
39233 _swigc__p_wxDateTime__TimeZone,
39234 _swigc__p_wxDisplay,
39235 _swigc__p_wxDisplayChangedEvent,
39236 _swigc__p_wxDropFilesEvent,
39237 _swigc__p_wxDuplexMode,
39238 _swigc__p_wxEraseEvent,
39239 _swigc__p_wxEvent,
39240 _swigc__p_wxEvtHandler,
39241 _swigc__p_wxFSFile,
39242 _swigc__p_wxFileConfig,
39243 _swigc__p_wxFileDataObject,
39244 _swigc__p_wxFileHistory,
39245 _swigc__p_wxFileSystem,
39246 _swigc__p_wxFileType,
39247 _swigc__p_wxFileTypeInfo,
39248 _swigc__p_wxFlexGridSizer,
39249 _swigc__p_wxFocusEvent,
39250 _swigc__p_wxFont,
39251 _swigc__p_wxFrame,
39252 _swigc__p_wxGBSizerItem,
39253 _swigc__p_wxGIFHandler,
39254 _swigc__p_wxGridBagSizer,
39255 _swigc__p_wxGridSizer,
39256 _swigc__p_wxICOHandler,
39257 _swigc__p_wxIcon,
39258 _swigc__p_wxIconizeEvent,
39259 _swigc__p_wxIdleEvent,
39260 _swigc__p_wxImage,
39261 _swigc__p_wxImageHandler,
39262 _swigc__p_wxIndividualLayoutConstraint,
39263 _swigc__p_wxInitDialogEvent,
39264 _swigc__p_wxJPEGHandler,
39265 _swigc__p_wxJoystick,
39266 _swigc__p_wxJoystickEvent,
39267 _swigc__p_wxKeyEvent,
39268 _swigc__p_wxKillError,
39269 _swigc__p_wxLayoutConstraints,
39270 _swigc__p_wxLog,
39271 _swigc__p_wxLogBuffer,
39272 _swigc__p_wxLogChain,
39273 _swigc__p_wxLogGui,
39274 _swigc__p_wxLogNull,
39275 _swigc__p_wxLogStderr,
39276 _swigc__p_wxLogTextCtrl,
39277 _swigc__p_wxLogWindow,
39278 _swigc__p_wxMaximizeEvent,
39279 _swigc__p_wxMenu,
39280 _swigc__p_wxMenuBar,
39281 _swigc__p_wxMenuEvent,
39282 _swigc__p_wxMenuItem,
39283 _swigc__p_wxMetafileDataObject,
39284 _swigc__p_wxMimeTypesManager,
39285 _swigc__p_wxMouseCaptureChangedEvent,
39286 _swigc__p_wxMouseCaptureLostEvent,
39287 _swigc__p_wxMouseEvent,
39288 _swigc__p_wxMouseState,
39289 _swigc__p_wxMoveEvent,
39290 _swigc__p_wxMutexGuiLocker,
39291 _swigc__p_wxNavigationKeyEvent,
39292 _swigc__p_wxNcPaintEvent,
39293 _swigc__p_wxNotifyEvent,
39294 _swigc__p_wxObject,
39295 _swigc__p_wxOutputStream,
39296 _swigc__p_wxPCXHandler,
39297 _swigc__p_wxPNGHandler,
39298 _swigc__p_wxPNMHandler,
39299 _swigc__p_wxPaintEvent,
39300 _swigc__p_wxPaletteChangedEvent,
39301 _swigc__p_wxPaperSize,
39302 _swigc__p_wxPlatformInfo,
39303 _swigc__p_wxPoint,
39304 _swigc__p_wxPowerEvent,
39305 _swigc__p_wxProcessEvent,
39306 _swigc__p_wxPyApp,
39307 _swigc__p_wxPyArtProvider,
39308 _swigc__p_wxPyBitmapDataObject,
39309 _swigc__p_wxPyCommandEvent,
39310 _swigc__p_wxPyDataObjectSimple,
39311 _swigc__p_wxPyDropSource,
39312 _swigc__p_wxPyDropTarget,
39313 _swigc__p_wxPyEvent,
39314 _swigc__p_wxPyFileDropTarget,
39315 _swigc__p_wxPyImageHandler,
39316 _swigc__p_wxPyLog,
39317 _swigc__p_wxPyProcess,
39318 _swigc__p_wxPySizer,
39319 _swigc__p_wxPyTextDataObject,
39320 _swigc__p_wxPyTextDropTarget,
39321 _swigc__p_wxPyTimer,
39322 _swigc__p_wxPyTipProvider,
39323 _swigc__p_wxPyValidator,
39324 _swigc__p_wxQueryNewPaletteEvent,
39325 _swigc__p_wxRect,
39326 _swigc__p_wxScrollEvent,
39327 _swigc__p_wxScrollWinEvent,
39328 _swigc__p_wxSetCursorEvent,
39329 _swigc__p_wxShowEvent,
39330 _swigc__p_wxSingleInstanceChecker,
39331 _swigc__p_wxSize,
39332 _swigc__p_wxSizeEvent,
39333 _swigc__p_wxSizer,
39334 _swigc__p_wxSizerItem,
39335 _swigc__p_wxSound,
39336 _swigc__p_wxStandardPaths,
39337 _swigc__p_wxStaticBoxSizer,
39338 _swigc__p_wxStdDialogButtonSizer,
39339 _swigc__p_wxStopWatch,
39340 _swigc__p_wxString,
39341 _swigc__p_wxSysColourChangedEvent,
39342 _swigc__p_wxSystemOptions,
39343 _swigc__p_wxSystemSettings,
39344 _swigc__p_wxTIFFHandler,
39345 _swigc__p_wxTextCtrl,
39346 _swigc__p_wxTextDataObject,
39347 _swigc__p_wxTimeSpan,
39348 _swigc__p_wxTimer,
39349 _swigc__p_wxTimerEvent,
39350 _swigc__p_wxTimerRunner,
39351 _swigc__p_wxTipProvider,
39352 _swigc__p_wxToolTip,
39353 _swigc__p_wxURLDataObject,
39354 _swigc__p_wxUpdateUIEvent,
39355 _swigc__p_wxValidator,
39356 _swigc__p_wxVideoMode,
39357 _swigc__p_wxWindow,
39358 _swigc__p_wxWindowCreateEvent,
39359 _swigc__p_wxWindowDestroyEvent,
39360 _swigc__p_wxWindowDisabler,
39361 _swigc__p_wxXPMHandler,
39362 };
39363
39364
39365 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
39366
39367 static swig_const_info swig_const_table[] = {
39368 {0, 0, 0, 0.0, 0, 0}};
39369
39370 #ifdef __cplusplus
39371 }
39372 #endif
39373 /* -----------------------------------------------------------------------------
39374 * Type initialization:
39375 * This problem is tough by the requirement that no dynamic
39376 * memory is used. Also, since swig_type_info structures store pointers to
39377 * swig_cast_info structures and swig_cast_info structures store pointers back
39378 * to swig_type_info structures, we need some lookup code at initialization.
39379 * The idea is that swig generates all the structures that are needed.
39380 * The runtime then collects these partially filled structures.
39381 * The SWIG_InitializeModule function takes these initial arrays out of
39382 * swig_module, and does all the lookup, filling in the swig_module.types
39383 * array with the correct data and linking the correct swig_cast_info
39384 * structures together.
39385 *
39386 * The generated swig_type_info structures are assigned staticly to an initial
39387 * array. We just loop though that array, and handle each type individually.
39388 * First we lookup if this type has been already loaded, and if so, use the
39389 * loaded structure instead of the generated one. Then we have to fill in the
39390 * cast linked list. The cast data is initially stored in something like a
39391 * two-dimensional array. Each row corresponds to a type (there are the same
39392 * number of rows as there are in the swig_type_initial array). Each entry in
39393 * a column is one of the swig_cast_info structures for that type.
39394 * The cast_initial array is actually an array of arrays, because each row has
39395 * a variable number of columns. So to actually build the cast linked list,
39396 * we find the array of casts associated with the type, and loop through it
39397 * adding the casts to the list. The one last trick we need to do is making
39398 * sure the type pointer in the swig_cast_info struct is correct.
39399 *
39400 * First off, we lookup the cast->type name to see if it is already loaded.
39401 * There are three cases to handle:
39402 * 1) If the cast->type has already been loaded AND the type we are adding
39403 * casting info to has not been loaded (it is in this module), THEN we
39404 * replace the cast->type pointer with the type pointer that has already
39405 * been loaded.
39406 * 2) If BOTH types (the one we are adding casting info to, and the
39407 * cast->type) are loaded, THEN the cast info has already been loaded by
39408 * the previous module so we just ignore it.
39409 * 3) Finally, if cast->type has not already been loaded, then we add that
39410 * swig_cast_info to the linked list (because the cast->type) pointer will
39411 * be correct.
39412 * ----------------------------------------------------------------------------- */
39413
39414 #ifdef __cplusplus
39415 extern "C" {
39416 #if 0
39417 } /* c-mode */
39418 #endif
39419 #endif
39420
39421 #if 0
39422 #define SWIGRUNTIME_DEBUG
39423 #endif
39424
39425 SWIGRUNTIME void
39426 SWIG_InitializeModule(void *clientdata) {
39427 size_t i;
39428 swig_module_info *module_head;
39429 static int init_run = 0;
39430
39431 clientdata = clientdata;
39432
39433 if (init_run) return;
39434 init_run = 1;
39435
39436 /* Initialize the swig_module */
39437 swig_module.type_initial = swig_type_initial;
39438 swig_module.cast_initial = swig_cast_initial;
39439
39440 /* Try and load any already created modules */
39441 module_head = SWIG_GetModule(clientdata);
39442 if (module_head) {
39443 swig_module.next = module_head->next;
39444 module_head->next = &swig_module;
39445 } else {
39446 /* This is the first module loaded */
39447 swig_module.next = &swig_module;
39448 SWIG_SetModule(clientdata, &swig_module);
39449 }
39450
39451 /* Now work on filling in swig_module.types */
39452 #ifdef SWIGRUNTIME_DEBUG
39453 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
39454 #endif
39455 for (i = 0; i < swig_module.size; ++i) {
39456 swig_type_info *type = 0;
39457 swig_type_info *ret;
39458 swig_cast_info *cast;
39459
39460 #ifdef SWIGRUNTIME_DEBUG
39461 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39462 #endif
39463
39464 /* if there is another module already loaded */
39465 if (swig_module.next != &swig_module) {
39466 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
39467 }
39468 if (type) {
39469 /* Overwrite clientdata field */
39470 #ifdef SWIGRUNTIME_DEBUG
39471 printf("SWIG_InitializeModule: found type %s\n", type->name);
39472 #endif
39473 if (swig_module.type_initial[i]->clientdata) {
39474 type->clientdata = swig_module.type_initial[i]->clientdata;
39475 #ifdef SWIGRUNTIME_DEBUG
39476 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
39477 #endif
39478 }
39479 } else {
39480 type = swig_module.type_initial[i];
39481 }
39482
39483 /* Insert casting types */
39484 cast = swig_module.cast_initial[i];
39485 while (cast->type) {
39486 /* Don't need to add information already in the list */
39487 ret = 0;
39488 #ifdef SWIGRUNTIME_DEBUG
39489 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
39490 #endif
39491 if (swig_module.next != &swig_module) {
39492 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
39493 #ifdef SWIGRUNTIME_DEBUG
39494 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
39495 #endif
39496 }
39497 if (ret) {
39498 if (type == swig_module.type_initial[i]) {
39499 #ifdef SWIGRUNTIME_DEBUG
39500 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
39501 #endif
39502 cast->type = ret;
39503 ret = 0;
39504 } else {
39505 /* Check for casting already in the list */
39506 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
39507 #ifdef SWIGRUNTIME_DEBUG
39508 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
39509 #endif
39510 if (!ocast) ret = 0;
39511 }
39512 }
39513
39514 if (!ret) {
39515 #ifdef SWIGRUNTIME_DEBUG
39516 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
39517 #endif
39518 if (type->cast) {
39519 type->cast->prev = cast;
39520 cast->next = type->cast;
39521 }
39522 type->cast = cast;
39523 }
39524 cast++;
39525 }
39526 /* Set entry in modules->types array equal to the type */
39527 swig_module.types[i] = type;
39528 }
39529 swig_module.types[i] = 0;
39530
39531 #ifdef SWIGRUNTIME_DEBUG
39532 printf("**** SWIG_InitializeModule: Cast List ******\n");
39533 for (i = 0; i < swig_module.size; ++i) {
39534 int j = 0;
39535 swig_cast_info *cast = swig_module.cast_initial[i];
39536 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39537 while (cast->type) {
39538 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
39539 cast++;
39540 ++j;
39541 }
39542 printf("---- Total casts: %d\n",j);
39543 }
39544 printf("**** SWIG_InitializeModule: Cast List ******\n");
39545 #endif
39546 }
39547
39548 /* This function will propagate the clientdata field of type to
39549 * any new swig_type_info structures that have been added into the list
39550 * of equivalent types. It is like calling
39551 * SWIG_TypeClientData(type, clientdata) a second time.
39552 */
39553 SWIGRUNTIME void
39554 SWIG_PropagateClientData(void) {
39555 size_t i;
39556 swig_cast_info *equiv;
39557 static int init_run = 0;
39558
39559 if (init_run) return;
39560 init_run = 1;
39561
39562 for (i = 0; i < swig_module.size; i++) {
39563 if (swig_module.types[i]->clientdata) {
39564 equiv = swig_module.types[i]->cast;
39565 while (equiv) {
39566 if (!equiv->converter) {
39567 if (equiv->type && !equiv->type->clientdata)
39568 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
39569 }
39570 equiv = equiv->next;
39571 }
39572 }
39573 }
39574 }
39575
39576 #ifdef __cplusplus
39577 #if 0
39578 {
39579 /* c-mode */
39580 #endif
39581 }
39582 #endif
39583
39584
39585
39586 #ifdef __cplusplus
39587 extern "C" {
39588 #endif
39589
39590 /* Python-specific SWIG API */
39591 #define SWIG_newvarlink() SWIG_Python_newvarlink()
39592 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
39593 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
39594
39595 /* -----------------------------------------------------------------------------
39596 * global variable support code.
39597 * ----------------------------------------------------------------------------- */
39598
39599 typedef struct swig_globalvar {
39600 char *name; /* Name of global variable */
39601 PyObject *(*get_attr)(void); /* Return the current value */
39602 int (*set_attr)(PyObject *); /* Set the value */
39603 struct swig_globalvar *next;
39604 } swig_globalvar;
39605
39606 typedef struct swig_varlinkobject {
39607 PyObject_HEAD
39608 swig_globalvar *vars;
39609 } swig_varlinkobject;
39610
39611 SWIGINTERN PyObject *
39612 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
39613 return PyString_FromString("<Swig global variables>");
39614 }
39615
39616 SWIGINTERN PyObject *
39617 swig_varlink_str(swig_varlinkobject *v) {
39618 PyObject *str = PyString_FromString("(");
39619 swig_globalvar *var;
39620 for (var = v->vars; var; var=var->next) {
39621 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
39622 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
39623 }
39624 PyString_ConcatAndDel(&str,PyString_FromString(")"));
39625 return str;
39626 }
39627
39628 SWIGINTERN int
39629 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
39630 PyObject *str = swig_varlink_str(v);
39631 fprintf(fp,"Swig global variables ");
39632 fprintf(fp,"%s\n", PyString_AsString(str));
39633 Py_DECREF(str);
39634 return 0;
39635 }
39636
39637 SWIGINTERN void
39638 swig_varlink_dealloc(swig_varlinkobject *v) {
39639 swig_globalvar *var = v->vars;
39640 while (var) {
39641 swig_globalvar *n = var->next;
39642 free(var->name);
39643 free(var);
39644 var = n;
39645 }
39646 }
39647
39648 SWIGINTERN PyObject *
39649 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
39650 PyObject *res = NULL;
39651 swig_globalvar *var = v->vars;
39652 while (var) {
39653 if (strcmp(var->name,n) == 0) {
39654 res = (*var->get_attr)();
39655 break;
39656 }
39657 var = var->next;
39658 }
39659 if (res == NULL && !PyErr_Occurred()) {
39660 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39661 }
39662 return res;
39663 }
39664
39665 SWIGINTERN int
39666 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
39667 int res = 1;
39668 swig_globalvar *var = v->vars;
39669 while (var) {
39670 if (strcmp(var->name,n) == 0) {
39671 res = (*var->set_attr)(p);
39672 break;
39673 }
39674 var = var->next;
39675 }
39676 if (res == 1 && !PyErr_Occurred()) {
39677 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39678 }
39679 return res;
39680 }
39681
39682 SWIGINTERN PyTypeObject*
39683 swig_varlink_type(void) {
39684 static char varlink__doc__[] = "Swig var link object";
39685 static PyTypeObject varlink_type;
39686 static int type_init = 0;
39687 if (!type_init) {
39688 const PyTypeObject tmp
39689 = {
39690 PyObject_HEAD_INIT(NULL)
39691 0, /* Number of items in variable part (ob_size) */
39692 (char *)"swigvarlink", /* Type name (tp_name) */
39693 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
39694 0, /* Itemsize (tp_itemsize) */
39695 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
39696 (printfunc) swig_varlink_print, /* Print (tp_print) */
39697 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
39698 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
39699 0, /* tp_compare */
39700 (reprfunc) swig_varlink_repr, /* tp_repr */
39701 0, /* tp_as_number */
39702 0, /* tp_as_sequence */
39703 0, /* tp_as_mapping */
39704 0, /* tp_hash */
39705 0, /* tp_call */
39706 (reprfunc)swig_varlink_str, /* tp_str */
39707 0, /* tp_getattro */
39708 0, /* tp_setattro */
39709 0, /* tp_as_buffer */
39710 0, /* tp_flags */
39711 varlink__doc__, /* tp_doc */
39712 0, /* tp_traverse */
39713 0, /* tp_clear */
39714 0, /* tp_richcompare */
39715 0, /* tp_weaklistoffset */
39716 #if PY_VERSION_HEX >= 0x02020000
39717 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
39718 #endif
39719 #if PY_VERSION_HEX >= 0x02030000
39720 0, /* tp_del */
39721 #endif
39722 #ifdef COUNT_ALLOCS
39723 0,0,0,0 /* tp_alloc -> tp_next */
39724 #endif
39725 };
39726 varlink_type = tmp;
39727 varlink_type.ob_type = &PyType_Type;
39728 type_init = 1;
39729 }
39730 return &varlink_type;
39731 }
39732
39733 /* Create a variable linking object for use later */
39734 SWIGINTERN PyObject *
39735 SWIG_Python_newvarlink(void) {
39736 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
39737 if (result) {
39738 result->vars = 0;
39739 }
39740 return ((PyObject*) result);
39741 }
39742
39743 SWIGINTERN void
39744 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
39745 swig_varlinkobject *v = (swig_varlinkobject *) p;
39746 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
39747 if (gv) {
39748 size_t size = strlen(name)+1;
39749 gv->name = (char *)malloc(size);
39750 if (gv->name) {
39751 strncpy(gv->name,name,size);
39752 gv->get_attr = get_attr;
39753 gv->set_attr = set_attr;
39754 gv->next = v->vars;
39755 }
39756 }
39757 v->vars = gv;
39758 }
39759
39760 SWIGINTERN PyObject *
39761 SWIG_globals() {
39762 static PyObject *_SWIG_globals = 0;
39763 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
39764 return _SWIG_globals;
39765 }
39766
39767 /* -----------------------------------------------------------------------------
39768 * constants/methods manipulation
39769 * ----------------------------------------------------------------------------- */
39770
39771 /* Install Constants */
39772 SWIGINTERN void
39773 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
39774 PyObject *obj = 0;
39775 size_t i;
39776 for (i = 0; constants[i].type; ++i) {
39777 switch(constants[i].type) {
39778 case SWIG_PY_POINTER:
39779 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
39780 break;
39781 case SWIG_PY_BINARY:
39782 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
39783 break;
39784 default:
39785 obj = 0;
39786 break;
39787 }
39788 if (obj) {
39789 PyDict_SetItemString(d, constants[i].name, obj);
39790 Py_DECREF(obj);
39791 }
39792 }
39793 }
39794
39795 /* -----------------------------------------------------------------------------*/
39796 /* Fix SwigMethods to carry the callback ptrs when needed */
39797 /* -----------------------------------------------------------------------------*/
39798
39799 SWIGINTERN void
39800 SWIG_Python_FixMethods(PyMethodDef *methods,
39801 swig_const_info *const_table,
39802 swig_type_info **types,
39803 swig_type_info **types_initial) {
39804 size_t i;
39805 for (i = 0; methods[i].ml_name; ++i) {
39806 const char *c = methods[i].ml_doc;
39807 if (c && (c = strstr(c, "swig_ptr: "))) {
39808 int j;
39809 swig_const_info *ci = 0;
39810 const char *name = c + 10;
39811 for (j = 0; const_table[j].type; ++j) {
39812 if (strncmp(const_table[j].name, name,
39813 strlen(const_table[j].name)) == 0) {
39814 ci = &(const_table[j]);
39815 break;
39816 }
39817 }
39818 if (ci) {
39819 size_t shift = (ci->ptype) - types;
39820 swig_type_info *ty = types_initial[shift];
39821 size_t ldoc = (c - methods[i].ml_doc);
39822 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
39823 char *ndoc = (char*)malloc(ldoc + lptr + 10);
39824 if (ndoc) {
39825 char *buff = ndoc;
39826 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
39827 if (ptr) {
39828 strncpy(buff, methods[i].ml_doc, ldoc);
39829 buff += ldoc;
39830 strncpy(buff, "swig_ptr: ", 10);
39831 buff += 10;
39832 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
39833 methods[i].ml_doc = ndoc;
39834 }
39835 }
39836 }
39837 }
39838 }
39839 }
39840
39841 #ifdef __cplusplus
39842 }
39843 #endif
39844
39845 /* -----------------------------------------------------------------------------*
39846 * Partial Init method
39847 * -----------------------------------------------------------------------------*/
39848
39849 #ifdef __cplusplus
39850 extern "C"
39851 #endif
39852 SWIGEXPORT void SWIG_init(void) {
39853 PyObject *m, *d;
39854
39855 /* Fix SwigMethods to carry the callback ptrs when needed */
39856 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
39857
39858 m = Py_InitModule((char *) SWIG_name, SwigMethods);
39859 d = PyModule_GetDict(m);
39860
39861 SWIG_InitializeModule(0);
39862 SWIG_InstallConstants(d,swig_const_table);
39863
39864
39865 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
39866 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
39867 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
39868 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
39869 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
39870 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
39871 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
39872 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
39873 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
39874 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
39875 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
39876 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
39877 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
39878 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
39879 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
39880 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
39881 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
39882 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
39883 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
39884 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
39885 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
39886 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
39887 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
39888 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
39889 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
39890 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
39891 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
39892 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
39893 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
39894 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
39895 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
39896 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
39897 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
39898 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
39899 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
39900 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
39901 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
39902 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
39903 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
39904 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
39905 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
39906 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
39907 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
39908 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
39909 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
39910 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
39911 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
39912 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
39913 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
39914 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
39915 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
39916 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
39917 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
39918 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
39919 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
39920 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
39921 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
39922 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
39923 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
39924 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
39925 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
39926 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
39927 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
39928 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
39929 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
39930 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
39931 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
39932 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
39933 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
39934 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
39935 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
39936 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
39937 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
39938 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
39939 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
39940 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
39941 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
39942 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
39943 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
39944 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
39945 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
39946 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
39947 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
39948 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
39949 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
39950 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
39951 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
39952 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
39953 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
39954 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
39955 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
39956 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
39957 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
39958 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
39959 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
39960 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
39961 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
39962 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
39963 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
39964 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
39965 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
39966 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
39967 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
39968 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
39969 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
39970 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
39971 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
39972 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
39973 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
39974 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
39975 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
39976 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
39977 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
39978 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
39979 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
39980 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
39981 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
39982 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
39983 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
39984 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
39985 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
39986 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
39987 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
39988 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
39989 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
39990 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
39991 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
39992 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
39993 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
39994 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
39995 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
39996 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
39997 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
39998 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
39999 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
40000 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
40001 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
40002 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
40003 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
40004 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
40005 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
40006 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
40007 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
40008 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
40009
40010 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
40011
40012 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
40013 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
40014 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
40015 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
40016 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
40017 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
40018 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
40019 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
40020 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
40021 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
40022 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
40023 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
40024 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
40025 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
40026 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
40027 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
40028 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
40029 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
40030 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
40031 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
40032 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
40033 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
40034 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
40035 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
40036 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
40037 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
40038 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
40039 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
40040 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
40041 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
40042 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
40043 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
40044 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
40045 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
40046 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
40047 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
40048 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
40049 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
40050 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
40051 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
40052 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
40053 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
40054 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
40055 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
40056 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
40057 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
40058 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
40059 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
40060 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
40061 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
40062 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
40063 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
40064 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
40065
40066 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
40067
40068 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
40069 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
40070 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
40071 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
40072 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
40073 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
40074 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
40075 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
40076 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
40077 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
40078 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
40079 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
40080 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
40081 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
40082 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
40083 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
40084 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
40085 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
40086 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
40087 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
40088 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
40089 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
40090 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
40091 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
40092 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
40093 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
40094 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
40095 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
40096 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
40097 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
40098 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
40099 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
40100 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
40101 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
40102 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
40103 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
40104 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
40105 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
40106 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
40107 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
40108 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
40109 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
40110 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
40111 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
40112 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
40113 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
40114 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
40115 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
40116 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
40117 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
40118 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
40119 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
40120 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
40121 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
40122 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
40123 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
40124 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
40125 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
40126 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
40127 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
40128 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
40129 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
40130 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
40131 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
40132 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
40133 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
40134 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
40135 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
40136 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
40137 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
40138 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
40139 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
40140 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
40141 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
40142 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
40143 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
40144
40145 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
40146
40147 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
40148 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
40149 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
40150 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
40151 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
40152 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
40153 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
40154 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
40155 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
40156 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
40157 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
40158 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
40159 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
40160 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
40161 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
40162 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
40163 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
40164 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
40165 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
40166 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
40167 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
40168 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
40169 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
40170 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
40171 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
40172 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
40173 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
40174 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
40175 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
40176 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
40177 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
40178 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
40179 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
40180 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
40181 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
40182 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
40183 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
40184 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
40185 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
40186 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
40187 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
40188 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
40189 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
40190 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
40191 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
40192 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
40193 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
40194 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
40195 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
40196 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
40197 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
40198 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
40199 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
40200 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
40201 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
40202 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
40203 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
40204 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
40205 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
40206 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
40207 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
40208 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
40209 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
40210 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
40211 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
40212 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
40213 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
40214 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
40215 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
40216 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
40217 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
40218 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
40219 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
40220 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
40221 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
40222 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
40223 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
40224 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
40225 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
40226 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
40227 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
40228 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
40229 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
40230 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
40231 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
40232 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
40233 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
40234 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
40235 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
40236 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
40237 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
40238 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
40239 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
40240 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
40241 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
40242 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
40243 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
40244 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
40245 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
40246 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
40247 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
40248 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
40249 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
40250 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
40251 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
40252 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
40253 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
40254 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
40255 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
40256 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
40257 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
40258 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
40259 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
40260 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
40261 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
40262 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
40263 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
40264 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
40265 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
40266 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
40267 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
40268 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
40269 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
40270 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
40271 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
40272 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
40273 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
40274 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
40275 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
40276 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
40277 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
40278 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
40279 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
40280 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
40281 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
40282 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
40283 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
40284 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
40285 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
40286 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
40287 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
40288 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
40289 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
40290 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
40291 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
40292 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
40293 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
40294 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
40295 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
40296 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
40297 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
40298 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
40299 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
40300 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
40301 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
40302 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
40303 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
40304 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
40305 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
40306 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
40307 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
40308 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
40309 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
40310 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
40311 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
40312 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
40313 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
40314 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
40315 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
40316 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
40317 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
40318 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
40319 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
40320 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
40321 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
40322 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
40323 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
40324 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
40325 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
40326 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
40327 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
40328 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
40329 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
40330 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
40331 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
40332 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
40333 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
40334 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
40335 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
40336 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
40337 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
40338 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
40339 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
40340 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
40341 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
40342 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
40343 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
40344 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
40345 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
40346 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
40347
40348 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
40349 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
40350 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
40351 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
40352
40353 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
40354 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
40355 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
40356 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
40357 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
40358 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
40359 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
40360 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
40361 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
40362 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
40363 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
40364 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
40365 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
40366 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
40367 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
40368 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
40369 }
40370
wxWidgets (Impactor)