]> 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
reSWIGged
[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_InsertProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20330 PyObject *resultobj = 0;
20331 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20332 int res1 = 0 ;
20333 PyObject * obj0 = 0 ;
20334 char * kwnames[] = {
20335 (char *) "provider", NULL
20336 };
20337
20338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_InsertProvider",kwnames,&obj0)) SWIG_fail;
20339 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20340 if (!SWIG_IsOK(res1)) {
20341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_InsertProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20342 }
20343 {
20344 PyThreadState* __tstate = wxPyBeginAllowThreads();
20345 wxPyArtProvider::InsertProvider(arg1);
20346 wxPyEndAllowThreads(__tstate);
20347 if (PyErr_Occurred()) SWIG_fail;
20348 }
20349 resultobj = SWIG_Py_Void();
20350 return resultobj;
20351 fail:
20352 return NULL;
20353 }
20354
20355
20356 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20357 PyObject *resultobj = 0;
20358 bool result;
20359
20360 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
20361 {
20362 PyThreadState* __tstate = wxPyBeginAllowThreads();
20363 result = (bool)wxPyArtProvider::PopProvider();
20364 wxPyEndAllowThreads(__tstate);
20365 if (PyErr_Occurred()) SWIG_fail;
20366 }
20367 {
20368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20369 }
20370 return resultobj;
20371 fail:
20372 return NULL;
20373 }
20374
20375
20376 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20377 PyObject *resultobj = 0;
20378 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20379 bool result;
20380 void *argp1 = 0 ;
20381 int res1 = 0 ;
20382 PyObject * obj0 = 0 ;
20383 char * kwnames[] = {
20384 (char *) "provider", NULL
20385 };
20386
20387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
20388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20389 if (!SWIG_IsOK(res1)) {
20390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20391 }
20392 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20393 {
20394 PyThreadState* __tstate = wxPyBeginAllowThreads();
20395 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
20396 wxPyEndAllowThreads(__tstate);
20397 if (PyErr_Occurred()) SWIG_fail;
20398 }
20399 {
20400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20401 }
20402 return resultobj;
20403 fail:
20404 return NULL;
20405 }
20406
20407
20408 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20409 PyObject *resultobj = 0;
20410 wxString *arg1 = 0 ;
20411 wxString const &arg2_defvalue = wxPyART_OTHER ;
20412 wxString *arg2 = (wxString *) &arg2_defvalue ;
20413 wxSize const &arg3_defvalue = wxDefaultSize ;
20414 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20415 wxBitmap result;
20416 bool temp1 = false ;
20417 bool temp2 = false ;
20418 wxSize temp3 ;
20419 PyObject * obj0 = 0 ;
20420 PyObject * obj1 = 0 ;
20421 PyObject * obj2 = 0 ;
20422 char * kwnames[] = {
20423 (char *) "id",(char *) "client",(char *) "size", NULL
20424 };
20425
20426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20427 {
20428 arg1 = wxString_in_helper(obj0);
20429 if (arg1 == NULL) SWIG_fail;
20430 temp1 = true;
20431 }
20432 if (obj1) {
20433 {
20434 arg2 = wxString_in_helper(obj1);
20435 if (arg2 == NULL) SWIG_fail;
20436 temp2 = true;
20437 }
20438 }
20439 if (obj2) {
20440 {
20441 arg3 = &temp3;
20442 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20443 }
20444 }
20445 {
20446 if (!wxPyCheckForApp()) SWIG_fail;
20447 PyThreadState* __tstate = wxPyBeginAllowThreads();
20448 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20449 wxPyEndAllowThreads(__tstate);
20450 if (PyErr_Occurred()) SWIG_fail;
20451 }
20452 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20453 {
20454 if (temp1)
20455 delete arg1;
20456 }
20457 {
20458 if (temp2)
20459 delete arg2;
20460 }
20461 return resultobj;
20462 fail:
20463 {
20464 if (temp1)
20465 delete arg1;
20466 }
20467 {
20468 if (temp2)
20469 delete arg2;
20470 }
20471 return NULL;
20472 }
20473
20474
20475 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20476 PyObject *resultobj = 0;
20477 wxString *arg1 = 0 ;
20478 wxString const &arg2_defvalue = wxPyART_OTHER ;
20479 wxString *arg2 = (wxString *) &arg2_defvalue ;
20480 wxSize const &arg3_defvalue = wxDefaultSize ;
20481 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20482 wxIcon result;
20483 bool temp1 = false ;
20484 bool temp2 = false ;
20485 wxSize temp3 ;
20486 PyObject * obj0 = 0 ;
20487 PyObject * obj1 = 0 ;
20488 PyObject * obj2 = 0 ;
20489 char * kwnames[] = {
20490 (char *) "id",(char *) "client",(char *) "size", NULL
20491 };
20492
20493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20494 {
20495 arg1 = wxString_in_helper(obj0);
20496 if (arg1 == NULL) SWIG_fail;
20497 temp1 = true;
20498 }
20499 if (obj1) {
20500 {
20501 arg2 = wxString_in_helper(obj1);
20502 if (arg2 == NULL) SWIG_fail;
20503 temp2 = true;
20504 }
20505 }
20506 if (obj2) {
20507 {
20508 arg3 = &temp3;
20509 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20510 }
20511 }
20512 {
20513 if (!wxPyCheckForApp()) SWIG_fail;
20514 PyThreadState* __tstate = wxPyBeginAllowThreads();
20515 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20516 wxPyEndAllowThreads(__tstate);
20517 if (PyErr_Occurred()) SWIG_fail;
20518 }
20519 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20520 {
20521 if (temp1)
20522 delete arg1;
20523 }
20524 {
20525 if (temp2)
20526 delete arg2;
20527 }
20528 return resultobj;
20529 fail:
20530 {
20531 if (temp1)
20532 delete arg1;
20533 }
20534 {
20535 if (temp2)
20536 delete arg2;
20537 }
20538 return NULL;
20539 }
20540
20541
20542 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20543 PyObject *resultobj = 0;
20544 wxString *arg1 = 0 ;
20545 bool arg2 = (bool) false ;
20546 wxSize result;
20547 bool temp1 = false ;
20548 bool val2 ;
20549 int ecode2 = 0 ;
20550 PyObject * obj0 = 0 ;
20551 PyObject * obj1 = 0 ;
20552 char * kwnames[] = {
20553 (char *) "client",(char *) "platform_dependent", NULL
20554 };
20555
20556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20557 {
20558 arg1 = wxString_in_helper(obj0);
20559 if (arg1 == NULL) SWIG_fail;
20560 temp1 = true;
20561 }
20562 if (obj1) {
20563 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20564 if (!SWIG_IsOK(ecode2)) {
20565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20566 }
20567 arg2 = static_cast< bool >(val2);
20568 }
20569 {
20570 PyThreadState* __tstate = wxPyBeginAllowThreads();
20571 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20572 wxPyEndAllowThreads(__tstate);
20573 if (PyErr_Occurred()) SWIG_fail;
20574 }
20575 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20576 {
20577 if (temp1)
20578 delete arg1;
20579 }
20580 return resultobj;
20581 fail:
20582 {
20583 if (temp1)
20584 delete arg1;
20585 }
20586 return NULL;
20587 }
20588
20589
20590 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20591 PyObject *resultobj = 0;
20592 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20593 void *argp1 = 0 ;
20594 int res1 = 0 ;
20595 PyObject *swig_obj[1] ;
20596
20597 if (!args) SWIG_fail;
20598 swig_obj[0] = args;
20599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20600 if (!SWIG_IsOK(res1)) {
20601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20602 }
20603 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20604 {
20605 PyThreadState* __tstate = wxPyBeginAllowThreads();
20606 wxPyArtProvider_Destroy(arg1);
20607 wxPyEndAllowThreads(__tstate);
20608 if (PyErr_Occurred()) SWIG_fail;
20609 }
20610 resultobj = SWIG_Py_Void();
20611 return resultobj;
20612 fail:
20613 return NULL;
20614 }
20615
20616
20617 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20618 PyObject *obj;
20619 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20620 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20621 return SWIG_Py_Void();
20622 }
20623
20624 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20625 return SWIG_Python_InitShadowInstance(args);
20626 }
20627
20628 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20629 PyObject *resultobj = 0;
20630 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20631 void *argp1 = 0 ;
20632 int res1 = 0 ;
20633 PyObject *swig_obj[1] ;
20634
20635 if (!args) SWIG_fail;
20636 swig_obj[0] = args;
20637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20638 if (!SWIG_IsOK(res1)) {
20639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20640 }
20641 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20642 {
20643 PyThreadState* __tstate = wxPyBeginAllowThreads();
20644 delete arg1;
20645
20646 wxPyEndAllowThreads(__tstate);
20647 if (PyErr_Occurred()) SWIG_fail;
20648 }
20649 resultobj = SWIG_Py_Void();
20650 return resultobj;
20651 fail:
20652 return NULL;
20653 }
20654
20655
20656 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20657 PyObject *resultobj = 0;
20658 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20659 wxConfigBase *result = 0 ;
20660 int res1 = 0 ;
20661 PyObject * obj0 = 0 ;
20662 char * kwnames[] = {
20663 (char *) "config", NULL
20664 };
20665
20666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20667 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20668 if (!SWIG_IsOK(res1)) {
20669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20670 }
20671 {
20672 PyThreadState* __tstate = wxPyBeginAllowThreads();
20673 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20674 wxPyEndAllowThreads(__tstate);
20675 if (PyErr_Occurred()) SWIG_fail;
20676 }
20677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20678 return resultobj;
20679 fail:
20680 return NULL;
20681 }
20682
20683
20684 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20685 PyObject *resultobj = 0;
20686 bool arg1 = (bool) true ;
20687 wxConfigBase *result = 0 ;
20688 bool val1 ;
20689 int ecode1 = 0 ;
20690 PyObject * obj0 = 0 ;
20691 char * kwnames[] = {
20692 (char *) "createOnDemand", NULL
20693 };
20694
20695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20696 if (obj0) {
20697 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20698 if (!SWIG_IsOK(ecode1)) {
20699 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20700 }
20701 arg1 = static_cast< bool >(val1);
20702 }
20703 {
20704 PyThreadState* __tstate = wxPyBeginAllowThreads();
20705 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20706 wxPyEndAllowThreads(__tstate);
20707 if (PyErr_Occurred()) SWIG_fail;
20708 }
20709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20710 return resultobj;
20711 fail:
20712 return NULL;
20713 }
20714
20715
20716 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20717 PyObject *resultobj = 0;
20718 wxConfigBase *result = 0 ;
20719
20720 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20721 {
20722 PyThreadState* __tstate = wxPyBeginAllowThreads();
20723 result = (wxConfigBase *)wxConfigBase::Create();
20724 wxPyEndAllowThreads(__tstate);
20725 if (PyErr_Occurred()) SWIG_fail;
20726 }
20727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20728 return resultobj;
20729 fail:
20730 return NULL;
20731 }
20732
20733
20734 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20735 PyObject *resultobj = 0;
20736
20737 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20738 {
20739 PyThreadState* __tstate = wxPyBeginAllowThreads();
20740 wxConfigBase::DontCreateOnDemand();
20741 wxPyEndAllowThreads(__tstate);
20742 if (PyErr_Occurred()) SWIG_fail;
20743 }
20744 resultobj = SWIG_Py_Void();
20745 return resultobj;
20746 fail:
20747 return NULL;
20748 }
20749
20750
20751 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20752 PyObject *resultobj = 0;
20753 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20754 wxString *arg2 = 0 ;
20755 void *argp1 = 0 ;
20756 int res1 = 0 ;
20757 bool temp2 = false ;
20758 PyObject * obj0 = 0 ;
20759 PyObject * obj1 = 0 ;
20760 char * kwnames[] = {
20761 (char *) "self",(char *) "path", NULL
20762 };
20763
20764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20766 if (!SWIG_IsOK(res1)) {
20767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20768 }
20769 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20770 {
20771 arg2 = wxString_in_helper(obj1);
20772 if (arg2 == NULL) SWIG_fail;
20773 temp2 = true;
20774 }
20775 {
20776 PyThreadState* __tstate = wxPyBeginAllowThreads();
20777 (arg1)->SetPath((wxString const &)*arg2);
20778 wxPyEndAllowThreads(__tstate);
20779 if (PyErr_Occurred()) SWIG_fail;
20780 }
20781 resultobj = SWIG_Py_Void();
20782 {
20783 if (temp2)
20784 delete arg2;
20785 }
20786 return resultobj;
20787 fail:
20788 {
20789 if (temp2)
20790 delete arg2;
20791 }
20792 return NULL;
20793 }
20794
20795
20796 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20797 PyObject *resultobj = 0;
20798 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20799 wxString *result = 0 ;
20800 void *argp1 = 0 ;
20801 int res1 = 0 ;
20802 PyObject *swig_obj[1] ;
20803
20804 if (!args) SWIG_fail;
20805 swig_obj[0] = args;
20806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20807 if (!SWIG_IsOK(res1)) {
20808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20809 }
20810 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20811 {
20812 PyThreadState* __tstate = wxPyBeginAllowThreads();
20813 {
20814 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
20815 result = (wxString *) &_result_ref;
20816 }
20817 wxPyEndAllowThreads(__tstate);
20818 if (PyErr_Occurred()) SWIG_fail;
20819 }
20820 {
20821 #if wxUSE_UNICODE
20822 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
20823 #else
20824 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
20825 #endif
20826 }
20827 return resultobj;
20828 fail:
20829 return NULL;
20830 }
20831
20832
20833 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20834 PyObject *resultobj = 0;
20835 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20836 PyObject *result = 0 ;
20837 void *argp1 = 0 ;
20838 int res1 = 0 ;
20839 PyObject *swig_obj[1] ;
20840
20841 if (!args) SWIG_fail;
20842 swig_obj[0] = args;
20843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20844 if (!SWIG_IsOK(res1)) {
20845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20846 }
20847 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20848 {
20849 PyThreadState* __tstate = wxPyBeginAllowThreads();
20850 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
20851 wxPyEndAllowThreads(__tstate);
20852 if (PyErr_Occurred()) SWIG_fail;
20853 }
20854 resultobj = result;
20855 return resultobj;
20856 fail:
20857 return NULL;
20858 }
20859
20860
20861 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20862 PyObject *resultobj = 0;
20863 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20864 long arg2 ;
20865 PyObject *result = 0 ;
20866 void *argp1 = 0 ;
20867 int res1 = 0 ;
20868 long val2 ;
20869 int ecode2 = 0 ;
20870 PyObject * obj0 = 0 ;
20871 PyObject * obj1 = 0 ;
20872 char * kwnames[] = {
20873 (char *) "self",(char *) "index", NULL
20874 };
20875
20876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20878 if (!SWIG_IsOK(res1)) {
20879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20880 }
20881 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20882 ecode2 = SWIG_AsVal_long(obj1, &val2);
20883 if (!SWIG_IsOK(ecode2)) {
20884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
20885 }
20886 arg2 = static_cast< long >(val2);
20887 {
20888 PyThreadState* __tstate = wxPyBeginAllowThreads();
20889 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
20890 wxPyEndAllowThreads(__tstate);
20891 if (PyErr_Occurred()) SWIG_fail;
20892 }
20893 resultobj = result;
20894 return resultobj;
20895 fail:
20896 return NULL;
20897 }
20898
20899
20900 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20901 PyObject *resultobj = 0;
20902 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20903 PyObject *result = 0 ;
20904 void *argp1 = 0 ;
20905 int res1 = 0 ;
20906 PyObject *swig_obj[1] ;
20907
20908 if (!args) SWIG_fail;
20909 swig_obj[0] = args;
20910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20911 if (!SWIG_IsOK(res1)) {
20912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20913 }
20914 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20915 {
20916 PyThreadState* __tstate = wxPyBeginAllowThreads();
20917 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
20918 wxPyEndAllowThreads(__tstate);
20919 if (PyErr_Occurred()) SWIG_fail;
20920 }
20921 resultobj = result;
20922 return resultobj;
20923 fail:
20924 return NULL;
20925 }
20926
20927
20928 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20929 PyObject *resultobj = 0;
20930 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20931 long arg2 ;
20932 PyObject *result = 0 ;
20933 void *argp1 = 0 ;
20934 int res1 = 0 ;
20935 long val2 ;
20936 int ecode2 = 0 ;
20937 PyObject * obj0 = 0 ;
20938 PyObject * obj1 = 0 ;
20939 char * kwnames[] = {
20940 (char *) "self",(char *) "index", NULL
20941 };
20942
20943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20945 if (!SWIG_IsOK(res1)) {
20946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20947 }
20948 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20949 ecode2 = SWIG_AsVal_long(obj1, &val2);
20950 if (!SWIG_IsOK(ecode2)) {
20951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
20952 }
20953 arg2 = static_cast< long >(val2);
20954 {
20955 PyThreadState* __tstate = wxPyBeginAllowThreads();
20956 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
20957 wxPyEndAllowThreads(__tstate);
20958 if (PyErr_Occurred()) SWIG_fail;
20959 }
20960 resultobj = result;
20961 return resultobj;
20962 fail:
20963 return NULL;
20964 }
20965
20966
20967 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20968 PyObject *resultobj = 0;
20969 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20970 bool arg2 = (bool) false ;
20971 size_t result;
20972 void *argp1 = 0 ;
20973 int res1 = 0 ;
20974 bool val2 ;
20975 int ecode2 = 0 ;
20976 PyObject * obj0 = 0 ;
20977 PyObject * obj1 = 0 ;
20978 char * kwnames[] = {
20979 (char *) "self",(char *) "recursive", NULL
20980 };
20981
20982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
20983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20984 if (!SWIG_IsOK(res1)) {
20985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20986 }
20987 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20988 if (obj1) {
20989 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20990 if (!SWIG_IsOK(ecode2)) {
20991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
20992 }
20993 arg2 = static_cast< bool >(val2);
20994 }
20995 {
20996 PyThreadState* __tstate = wxPyBeginAllowThreads();
20997 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
20998 wxPyEndAllowThreads(__tstate);
20999 if (PyErr_Occurred()) SWIG_fail;
21000 }
21001 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21002 return resultobj;
21003 fail:
21004 return NULL;
21005 }
21006
21007
21008 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21009 PyObject *resultobj = 0;
21010 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21011 bool arg2 = (bool) false ;
21012 size_t result;
21013 void *argp1 = 0 ;
21014 int res1 = 0 ;
21015 bool val2 ;
21016 int ecode2 = 0 ;
21017 PyObject * obj0 = 0 ;
21018 PyObject * obj1 = 0 ;
21019 char * kwnames[] = {
21020 (char *) "self",(char *) "recursive", NULL
21021 };
21022
21023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21025 if (!SWIG_IsOK(res1)) {
21026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21027 }
21028 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21029 if (obj1) {
21030 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21031 if (!SWIG_IsOK(ecode2)) {
21032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21033 }
21034 arg2 = static_cast< bool >(val2);
21035 }
21036 {
21037 PyThreadState* __tstate = wxPyBeginAllowThreads();
21038 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21039 wxPyEndAllowThreads(__tstate);
21040 if (PyErr_Occurred()) SWIG_fail;
21041 }
21042 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21043 return resultobj;
21044 fail:
21045 return NULL;
21046 }
21047
21048
21049 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21050 PyObject *resultobj = 0;
21051 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21052 wxString *arg2 = 0 ;
21053 bool result;
21054 void *argp1 = 0 ;
21055 int res1 = 0 ;
21056 bool temp2 = false ;
21057 PyObject * obj0 = 0 ;
21058 PyObject * obj1 = 0 ;
21059 char * kwnames[] = {
21060 (char *) "self",(char *) "name", NULL
21061 };
21062
21063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21065 if (!SWIG_IsOK(res1)) {
21066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21067 }
21068 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21069 {
21070 arg2 = wxString_in_helper(obj1);
21071 if (arg2 == NULL) SWIG_fail;
21072 temp2 = true;
21073 }
21074 {
21075 PyThreadState* __tstate = wxPyBeginAllowThreads();
21076 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21077 wxPyEndAllowThreads(__tstate);
21078 if (PyErr_Occurred()) SWIG_fail;
21079 }
21080 {
21081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21082 }
21083 {
21084 if (temp2)
21085 delete arg2;
21086 }
21087 return resultobj;
21088 fail:
21089 {
21090 if (temp2)
21091 delete arg2;
21092 }
21093 return NULL;
21094 }
21095
21096
21097 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21098 PyObject *resultobj = 0;
21099 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21100 wxString *arg2 = 0 ;
21101 bool result;
21102 void *argp1 = 0 ;
21103 int res1 = 0 ;
21104 bool temp2 = false ;
21105 PyObject * obj0 = 0 ;
21106 PyObject * obj1 = 0 ;
21107 char * kwnames[] = {
21108 (char *) "self",(char *) "name", NULL
21109 };
21110
21111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21113 if (!SWIG_IsOK(res1)) {
21114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21115 }
21116 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21117 {
21118 arg2 = wxString_in_helper(obj1);
21119 if (arg2 == NULL) SWIG_fail;
21120 temp2 = true;
21121 }
21122 {
21123 PyThreadState* __tstate = wxPyBeginAllowThreads();
21124 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21125 wxPyEndAllowThreads(__tstate);
21126 if (PyErr_Occurred()) SWIG_fail;
21127 }
21128 {
21129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21130 }
21131 {
21132 if (temp2)
21133 delete arg2;
21134 }
21135 return resultobj;
21136 fail:
21137 {
21138 if (temp2)
21139 delete arg2;
21140 }
21141 return NULL;
21142 }
21143
21144
21145 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21146 PyObject *resultobj = 0;
21147 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21148 wxString *arg2 = 0 ;
21149 bool result;
21150 void *argp1 = 0 ;
21151 int res1 = 0 ;
21152 bool temp2 = false ;
21153 PyObject * obj0 = 0 ;
21154 PyObject * obj1 = 0 ;
21155 char * kwnames[] = {
21156 (char *) "self",(char *) "name", NULL
21157 };
21158
21159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21161 if (!SWIG_IsOK(res1)) {
21162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21163 }
21164 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21165 {
21166 arg2 = wxString_in_helper(obj1);
21167 if (arg2 == NULL) SWIG_fail;
21168 temp2 = true;
21169 }
21170 {
21171 PyThreadState* __tstate = wxPyBeginAllowThreads();
21172 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21173 wxPyEndAllowThreads(__tstate);
21174 if (PyErr_Occurred()) SWIG_fail;
21175 }
21176 {
21177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21178 }
21179 {
21180 if (temp2)
21181 delete arg2;
21182 }
21183 return resultobj;
21184 fail:
21185 {
21186 if (temp2)
21187 delete arg2;
21188 }
21189 return NULL;
21190 }
21191
21192
21193 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21194 PyObject *resultobj = 0;
21195 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21196 wxString *arg2 = 0 ;
21197 wxConfigBase::EntryType result;
21198 void *argp1 = 0 ;
21199 int res1 = 0 ;
21200 bool temp2 = false ;
21201 PyObject * obj0 = 0 ;
21202 PyObject * obj1 = 0 ;
21203 char * kwnames[] = {
21204 (char *) "self",(char *) "name", NULL
21205 };
21206
21207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21209 if (!SWIG_IsOK(res1)) {
21210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21211 }
21212 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21213 {
21214 arg2 = wxString_in_helper(obj1);
21215 if (arg2 == NULL) SWIG_fail;
21216 temp2 = true;
21217 }
21218 {
21219 PyThreadState* __tstate = wxPyBeginAllowThreads();
21220 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21221 wxPyEndAllowThreads(__tstate);
21222 if (PyErr_Occurred()) SWIG_fail;
21223 }
21224 resultobj = SWIG_From_int(static_cast< int >(result));
21225 {
21226 if (temp2)
21227 delete arg2;
21228 }
21229 return resultobj;
21230 fail:
21231 {
21232 if (temp2)
21233 delete arg2;
21234 }
21235 return NULL;
21236 }
21237
21238
21239 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21240 PyObject *resultobj = 0;
21241 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21242 wxString *arg2 = 0 ;
21243 wxString const &arg3_defvalue = wxPyEmptyString ;
21244 wxString *arg3 = (wxString *) &arg3_defvalue ;
21245 wxString result;
21246 void *argp1 = 0 ;
21247 int res1 = 0 ;
21248 bool temp2 = false ;
21249 bool temp3 = false ;
21250 PyObject * obj0 = 0 ;
21251 PyObject * obj1 = 0 ;
21252 PyObject * obj2 = 0 ;
21253 char * kwnames[] = {
21254 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21255 };
21256
21257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21259 if (!SWIG_IsOK(res1)) {
21260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21261 }
21262 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21263 {
21264 arg2 = wxString_in_helper(obj1);
21265 if (arg2 == NULL) SWIG_fail;
21266 temp2 = true;
21267 }
21268 if (obj2) {
21269 {
21270 arg3 = wxString_in_helper(obj2);
21271 if (arg3 == NULL) SWIG_fail;
21272 temp3 = true;
21273 }
21274 }
21275 {
21276 PyThreadState* __tstate = wxPyBeginAllowThreads();
21277 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21278 wxPyEndAllowThreads(__tstate);
21279 if (PyErr_Occurred()) SWIG_fail;
21280 }
21281 {
21282 #if wxUSE_UNICODE
21283 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21284 #else
21285 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21286 #endif
21287 }
21288 {
21289 if (temp2)
21290 delete arg2;
21291 }
21292 {
21293 if (temp3)
21294 delete arg3;
21295 }
21296 return resultobj;
21297 fail:
21298 {
21299 if (temp2)
21300 delete arg2;
21301 }
21302 {
21303 if (temp3)
21304 delete arg3;
21305 }
21306 return NULL;
21307 }
21308
21309
21310 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21311 PyObject *resultobj = 0;
21312 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21313 wxString *arg2 = 0 ;
21314 long arg3 = (long) 0 ;
21315 long result;
21316 void *argp1 = 0 ;
21317 int res1 = 0 ;
21318 bool temp2 = false ;
21319 long val3 ;
21320 int ecode3 = 0 ;
21321 PyObject * obj0 = 0 ;
21322 PyObject * obj1 = 0 ;
21323 PyObject * obj2 = 0 ;
21324 char * kwnames[] = {
21325 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21326 };
21327
21328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21330 if (!SWIG_IsOK(res1)) {
21331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21332 }
21333 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21334 {
21335 arg2 = wxString_in_helper(obj1);
21336 if (arg2 == NULL) SWIG_fail;
21337 temp2 = true;
21338 }
21339 if (obj2) {
21340 ecode3 = SWIG_AsVal_long(obj2, &val3);
21341 if (!SWIG_IsOK(ecode3)) {
21342 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21343 }
21344 arg3 = static_cast< long >(val3);
21345 }
21346 {
21347 PyThreadState* __tstate = wxPyBeginAllowThreads();
21348 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21349 wxPyEndAllowThreads(__tstate);
21350 if (PyErr_Occurred()) SWIG_fail;
21351 }
21352 resultobj = SWIG_From_long(static_cast< long >(result));
21353 {
21354 if (temp2)
21355 delete arg2;
21356 }
21357 return resultobj;
21358 fail:
21359 {
21360 if (temp2)
21361 delete arg2;
21362 }
21363 return NULL;
21364 }
21365
21366
21367 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21368 PyObject *resultobj = 0;
21369 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21370 wxString *arg2 = 0 ;
21371 double arg3 = (double) 0.0 ;
21372 double result;
21373 void *argp1 = 0 ;
21374 int res1 = 0 ;
21375 bool temp2 = false ;
21376 double val3 ;
21377 int ecode3 = 0 ;
21378 PyObject * obj0 = 0 ;
21379 PyObject * obj1 = 0 ;
21380 PyObject * obj2 = 0 ;
21381 char * kwnames[] = {
21382 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21383 };
21384
21385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21387 if (!SWIG_IsOK(res1)) {
21388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21389 }
21390 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21391 {
21392 arg2 = wxString_in_helper(obj1);
21393 if (arg2 == NULL) SWIG_fail;
21394 temp2 = true;
21395 }
21396 if (obj2) {
21397 ecode3 = SWIG_AsVal_double(obj2, &val3);
21398 if (!SWIG_IsOK(ecode3)) {
21399 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21400 }
21401 arg3 = static_cast< double >(val3);
21402 }
21403 {
21404 PyThreadState* __tstate = wxPyBeginAllowThreads();
21405 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21406 wxPyEndAllowThreads(__tstate);
21407 if (PyErr_Occurred()) SWIG_fail;
21408 }
21409 resultobj = SWIG_From_double(static_cast< double >(result));
21410 {
21411 if (temp2)
21412 delete arg2;
21413 }
21414 return resultobj;
21415 fail:
21416 {
21417 if (temp2)
21418 delete arg2;
21419 }
21420 return NULL;
21421 }
21422
21423
21424 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21425 PyObject *resultobj = 0;
21426 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21427 wxString *arg2 = 0 ;
21428 bool arg3 = (bool) false ;
21429 bool result;
21430 void *argp1 = 0 ;
21431 int res1 = 0 ;
21432 bool temp2 = false ;
21433 bool val3 ;
21434 int ecode3 = 0 ;
21435 PyObject * obj0 = 0 ;
21436 PyObject * obj1 = 0 ;
21437 PyObject * obj2 = 0 ;
21438 char * kwnames[] = {
21439 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21440 };
21441
21442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21444 if (!SWIG_IsOK(res1)) {
21445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21446 }
21447 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21448 {
21449 arg2 = wxString_in_helper(obj1);
21450 if (arg2 == NULL) SWIG_fail;
21451 temp2 = true;
21452 }
21453 if (obj2) {
21454 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21455 if (!SWIG_IsOK(ecode3)) {
21456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21457 }
21458 arg3 = static_cast< bool >(val3);
21459 }
21460 {
21461 PyThreadState* __tstate = wxPyBeginAllowThreads();
21462 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21463 wxPyEndAllowThreads(__tstate);
21464 if (PyErr_Occurred()) SWIG_fail;
21465 }
21466 {
21467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21468 }
21469 {
21470 if (temp2)
21471 delete arg2;
21472 }
21473 return resultobj;
21474 fail:
21475 {
21476 if (temp2)
21477 delete arg2;
21478 }
21479 return NULL;
21480 }
21481
21482
21483 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21484 PyObject *resultobj = 0;
21485 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21486 wxString *arg2 = 0 ;
21487 wxString *arg3 = 0 ;
21488 bool result;
21489 void *argp1 = 0 ;
21490 int res1 = 0 ;
21491 bool temp2 = false ;
21492 bool temp3 = false ;
21493 PyObject * obj0 = 0 ;
21494 PyObject * obj1 = 0 ;
21495 PyObject * obj2 = 0 ;
21496 char * kwnames[] = {
21497 (char *) "self",(char *) "key",(char *) "value", NULL
21498 };
21499
21500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21502 if (!SWIG_IsOK(res1)) {
21503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21504 }
21505 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21506 {
21507 arg2 = wxString_in_helper(obj1);
21508 if (arg2 == NULL) SWIG_fail;
21509 temp2 = true;
21510 }
21511 {
21512 arg3 = wxString_in_helper(obj2);
21513 if (arg3 == NULL) SWIG_fail;
21514 temp3 = true;
21515 }
21516 {
21517 PyThreadState* __tstate = wxPyBeginAllowThreads();
21518 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21519 wxPyEndAllowThreads(__tstate);
21520 if (PyErr_Occurred()) SWIG_fail;
21521 }
21522 {
21523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21524 }
21525 {
21526 if (temp2)
21527 delete arg2;
21528 }
21529 {
21530 if (temp3)
21531 delete arg3;
21532 }
21533 return resultobj;
21534 fail:
21535 {
21536 if (temp2)
21537 delete arg2;
21538 }
21539 {
21540 if (temp3)
21541 delete arg3;
21542 }
21543 return NULL;
21544 }
21545
21546
21547 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21548 PyObject *resultobj = 0;
21549 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21550 wxString *arg2 = 0 ;
21551 long arg3 ;
21552 bool result;
21553 void *argp1 = 0 ;
21554 int res1 = 0 ;
21555 bool temp2 = false ;
21556 long val3 ;
21557 int ecode3 = 0 ;
21558 PyObject * obj0 = 0 ;
21559 PyObject * obj1 = 0 ;
21560 PyObject * obj2 = 0 ;
21561 char * kwnames[] = {
21562 (char *) "self",(char *) "key",(char *) "value", NULL
21563 };
21564
21565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21567 if (!SWIG_IsOK(res1)) {
21568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21569 }
21570 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21571 {
21572 arg2 = wxString_in_helper(obj1);
21573 if (arg2 == NULL) SWIG_fail;
21574 temp2 = true;
21575 }
21576 ecode3 = SWIG_AsVal_long(obj2, &val3);
21577 if (!SWIG_IsOK(ecode3)) {
21578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21579 }
21580 arg3 = static_cast< long >(val3);
21581 {
21582 PyThreadState* __tstate = wxPyBeginAllowThreads();
21583 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21584 wxPyEndAllowThreads(__tstate);
21585 if (PyErr_Occurred()) SWIG_fail;
21586 }
21587 {
21588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21589 }
21590 {
21591 if (temp2)
21592 delete arg2;
21593 }
21594 return resultobj;
21595 fail:
21596 {
21597 if (temp2)
21598 delete arg2;
21599 }
21600 return NULL;
21601 }
21602
21603
21604 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21605 PyObject *resultobj = 0;
21606 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21607 wxString *arg2 = 0 ;
21608 double arg3 ;
21609 bool result;
21610 void *argp1 = 0 ;
21611 int res1 = 0 ;
21612 bool temp2 = false ;
21613 double val3 ;
21614 int ecode3 = 0 ;
21615 PyObject * obj0 = 0 ;
21616 PyObject * obj1 = 0 ;
21617 PyObject * obj2 = 0 ;
21618 char * kwnames[] = {
21619 (char *) "self",(char *) "key",(char *) "value", NULL
21620 };
21621
21622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21624 if (!SWIG_IsOK(res1)) {
21625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21626 }
21627 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21628 {
21629 arg2 = wxString_in_helper(obj1);
21630 if (arg2 == NULL) SWIG_fail;
21631 temp2 = true;
21632 }
21633 ecode3 = SWIG_AsVal_double(obj2, &val3);
21634 if (!SWIG_IsOK(ecode3)) {
21635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21636 }
21637 arg3 = static_cast< double >(val3);
21638 {
21639 PyThreadState* __tstate = wxPyBeginAllowThreads();
21640 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21641 wxPyEndAllowThreads(__tstate);
21642 if (PyErr_Occurred()) SWIG_fail;
21643 }
21644 {
21645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21646 }
21647 {
21648 if (temp2)
21649 delete arg2;
21650 }
21651 return resultobj;
21652 fail:
21653 {
21654 if (temp2)
21655 delete arg2;
21656 }
21657 return NULL;
21658 }
21659
21660
21661 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21662 PyObject *resultobj = 0;
21663 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21664 wxString *arg2 = 0 ;
21665 bool arg3 ;
21666 bool result;
21667 void *argp1 = 0 ;
21668 int res1 = 0 ;
21669 bool temp2 = false ;
21670 bool val3 ;
21671 int ecode3 = 0 ;
21672 PyObject * obj0 = 0 ;
21673 PyObject * obj1 = 0 ;
21674 PyObject * obj2 = 0 ;
21675 char * kwnames[] = {
21676 (char *) "self",(char *) "key",(char *) "value", NULL
21677 };
21678
21679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21681 if (!SWIG_IsOK(res1)) {
21682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21683 }
21684 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21685 {
21686 arg2 = wxString_in_helper(obj1);
21687 if (arg2 == NULL) SWIG_fail;
21688 temp2 = true;
21689 }
21690 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21691 if (!SWIG_IsOK(ecode3)) {
21692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21693 }
21694 arg3 = static_cast< bool >(val3);
21695 {
21696 PyThreadState* __tstate = wxPyBeginAllowThreads();
21697 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21698 wxPyEndAllowThreads(__tstate);
21699 if (PyErr_Occurred()) SWIG_fail;
21700 }
21701 {
21702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21703 }
21704 {
21705 if (temp2)
21706 delete arg2;
21707 }
21708 return resultobj;
21709 fail:
21710 {
21711 if (temp2)
21712 delete arg2;
21713 }
21714 return NULL;
21715 }
21716
21717
21718 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21719 PyObject *resultobj = 0;
21720 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21721 bool arg2 = (bool) false ;
21722 bool result;
21723 void *argp1 = 0 ;
21724 int res1 = 0 ;
21725 bool val2 ;
21726 int ecode2 = 0 ;
21727 PyObject * obj0 = 0 ;
21728 PyObject * obj1 = 0 ;
21729 char * kwnames[] = {
21730 (char *) "self",(char *) "currentOnly", NULL
21731 };
21732
21733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21735 if (!SWIG_IsOK(res1)) {
21736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21737 }
21738 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21739 if (obj1) {
21740 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21741 if (!SWIG_IsOK(ecode2)) {
21742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21743 }
21744 arg2 = static_cast< bool >(val2);
21745 }
21746 {
21747 PyThreadState* __tstate = wxPyBeginAllowThreads();
21748 result = (bool)(arg1)->Flush(arg2);
21749 wxPyEndAllowThreads(__tstate);
21750 if (PyErr_Occurred()) SWIG_fail;
21751 }
21752 {
21753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21754 }
21755 return resultobj;
21756 fail:
21757 return NULL;
21758 }
21759
21760
21761 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21762 PyObject *resultobj = 0;
21763 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21764 wxString *arg2 = 0 ;
21765 wxString *arg3 = 0 ;
21766 bool result;
21767 void *argp1 = 0 ;
21768 int res1 = 0 ;
21769 bool temp2 = false ;
21770 bool temp3 = false ;
21771 PyObject * obj0 = 0 ;
21772 PyObject * obj1 = 0 ;
21773 PyObject * obj2 = 0 ;
21774 char * kwnames[] = {
21775 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21776 };
21777
21778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21780 if (!SWIG_IsOK(res1)) {
21781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21782 }
21783 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21784 {
21785 arg2 = wxString_in_helper(obj1);
21786 if (arg2 == NULL) SWIG_fail;
21787 temp2 = true;
21788 }
21789 {
21790 arg3 = wxString_in_helper(obj2);
21791 if (arg3 == NULL) SWIG_fail;
21792 temp3 = true;
21793 }
21794 {
21795 PyThreadState* __tstate = wxPyBeginAllowThreads();
21796 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
21797 wxPyEndAllowThreads(__tstate);
21798 if (PyErr_Occurred()) SWIG_fail;
21799 }
21800 {
21801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21802 }
21803 {
21804 if (temp2)
21805 delete arg2;
21806 }
21807 {
21808 if (temp3)
21809 delete arg3;
21810 }
21811 return resultobj;
21812 fail:
21813 {
21814 if (temp2)
21815 delete arg2;
21816 }
21817 {
21818 if (temp3)
21819 delete arg3;
21820 }
21821 return NULL;
21822 }
21823
21824
21825 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21826 PyObject *resultobj = 0;
21827 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21828 wxString *arg2 = 0 ;
21829 wxString *arg3 = 0 ;
21830 bool result;
21831 void *argp1 = 0 ;
21832 int res1 = 0 ;
21833 bool temp2 = false ;
21834 bool temp3 = false ;
21835 PyObject * obj0 = 0 ;
21836 PyObject * obj1 = 0 ;
21837 PyObject * obj2 = 0 ;
21838 char * kwnames[] = {
21839 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21840 };
21841
21842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21844 if (!SWIG_IsOK(res1)) {
21845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21846 }
21847 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21848 {
21849 arg2 = wxString_in_helper(obj1);
21850 if (arg2 == NULL) SWIG_fail;
21851 temp2 = true;
21852 }
21853 {
21854 arg3 = wxString_in_helper(obj2);
21855 if (arg3 == NULL) SWIG_fail;
21856 temp3 = true;
21857 }
21858 {
21859 PyThreadState* __tstate = wxPyBeginAllowThreads();
21860 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
21861 wxPyEndAllowThreads(__tstate);
21862 if (PyErr_Occurred()) SWIG_fail;
21863 }
21864 {
21865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21866 }
21867 {
21868 if (temp2)
21869 delete arg2;
21870 }
21871 {
21872 if (temp3)
21873 delete arg3;
21874 }
21875 return resultobj;
21876 fail:
21877 {
21878 if (temp2)
21879 delete arg2;
21880 }
21881 {
21882 if (temp3)
21883 delete arg3;
21884 }
21885 return NULL;
21886 }
21887
21888
21889 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21890 PyObject *resultobj = 0;
21891 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21892 wxString *arg2 = 0 ;
21893 bool arg3 = (bool) true ;
21894 bool result;
21895 void *argp1 = 0 ;
21896 int res1 = 0 ;
21897 bool temp2 = false ;
21898 bool val3 ;
21899 int ecode3 = 0 ;
21900 PyObject * obj0 = 0 ;
21901 PyObject * obj1 = 0 ;
21902 PyObject * obj2 = 0 ;
21903 char * kwnames[] = {
21904 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
21905 };
21906
21907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21909 if (!SWIG_IsOK(res1)) {
21910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21911 }
21912 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21913 {
21914 arg2 = wxString_in_helper(obj1);
21915 if (arg2 == NULL) SWIG_fail;
21916 temp2 = true;
21917 }
21918 if (obj2) {
21919 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21920 if (!SWIG_IsOK(ecode3)) {
21921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
21922 }
21923 arg3 = static_cast< bool >(val3);
21924 }
21925 {
21926 PyThreadState* __tstate = wxPyBeginAllowThreads();
21927 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
21928 wxPyEndAllowThreads(__tstate);
21929 if (PyErr_Occurred()) SWIG_fail;
21930 }
21931 {
21932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21933 }
21934 {
21935 if (temp2)
21936 delete arg2;
21937 }
21938 return resultobj;
21939 fail:
21940 {
21941 if (temp2)
21942 delete arg2;
21943 }
21944 return NULL;
21945 }
21946
21947
21948 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21949 PyObject *resultobj = 0;
21950 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21951 wxString *arg2 = 0 ;
21952 bool result;
21953 void *argp1 = 0 ;
21954 int res1 = 0 ;
21955 bool temp2 = false ;
21956 PyObject * obj0 = 0 ;
21957 PyObject * obj1 = 0 ;
21958 char * kwnames[] = {
21959 (char *) "self",(char *) "key", NULL
21960 };
21961
21962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21964 if (!SWIG_IsOK(res1)) {
21965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21966 }
21967 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21968 {
21969 arg2 = wxString_in_helper(obj1);
21970 if (arg2 == NULL) SWIG_fail;
21971 temp2 = true;
21972 }
21973 {
21974 PyThreadState* __tstate = wxPyBeginAllowThreads();
21975 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
21976 wxPyEndAllowThreads(__tstate);
21977 if (PyErr_Occurred()) SWIG_fail;
21978 }
21979 {
21980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21981 }
21982 {
21983 if (temp2)
21984 delete arg2;
21985 }
21986 return resultobj;
21987 fail:
21988 {
21989 if (temp2)
21990 delete arg2;
21991 }
21992 return NULL;
21993 }
21994
21995
21996 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21997 PyObject *resultobj = 0;
21998 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21999 bool result;
22000 void *argp1 = 0 ;
22001 int res1 = 0 ;
22002 PyObject *swig_obj[1] ;
22003
22004 if (!args) SWIG_fail;
22005 swig_obj[0] = args;
22006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22007 if (!SWIG_IsOK(res1)) {
22008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22009 }
22010 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22011 {
22012 PyThreadState* __tstate = wxPyBeginAllowThreads();
22013 result = (bool)(arg1)->DeleteAll();
22014 wxPyEndAllowThreads(__tstate);
22015 if (PyErr_Occurred()) SWIG_fail;
22016 }
22017 {
22018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22019 }
22020 return resultobj;
22021 fail:
22022 return NULL;
22023 }
22024
22025
22026 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22027 PyObject *resultobj = 0;
22028 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22029 bool arg2 = (bool) true ;
22030 void *argp1 = 0 ;
22031 int res1 = 0 ;
22032 bool val2 ;
22033 int ecode2 = 0 ;
22034 PyObject * obj0 = 0 ;
22035 PyObject * obj1 = 0 ;
22036 char * kwnames[] = {
22037 (char *) "self",(char *) "doIt", NULL
22038 };
22039
22040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22042 if (!SWIG_IsOK(res1)) {
22043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22044 }
22045 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22046 if (obj1) {
22047 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22048 if (!SWIG_IsOK(ecode2)) {
22049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22050 }
22051 arg2 = static_cast< bool >(val2);
22052 }
22053 {
22054 PyThreadState* __tstate = wxPyBeginAllowThreads();
22055 (arg1)->SetExpandEnvVars(arg2);
22056 wxPyEndAllowThreads(__tstate);
22057 if (PyErr_Occurred()) SWIG_fail;
22058 }
22059 resultobj = SWIG_Py_Void();
22060 return resultobj;
22061 fail:
22062 return NULL;
22063 }
22064
22065
22066 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22067 PyObject *resultobj = 0;
22068 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22069 bool result;
22070 void *argp1 = 0 ;
22071 int res1 = 0 ;
22072 PyObject *swig_obj[1] ;
22073
22074 if (!args) SWIG_fail;
22075 swig_obj[0] = args;
22076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22077 if (!SWIG_IsOK(res1)) {
22078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22079 }
22080 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22081 {
22082 PyThreadState* __tstate = wxPyBeginAllowThreads();
22083 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22084 wxPyEndAllowThreads(__tstate);
22085 if (PyErr_Occurred()) SWIG_fail;
22086 }
22087 {
22088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22089 }
22090 return resultobj;
22091 fail:
22092 return NULL;
22093 }
22094
22095
22096 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22097 PyObject *resultobj = 0;
22098 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22099 bool arg2 = (bool) true ;
22100 void *argp1 = 0 ;
22101 int res1 = 0 ;
22102 bool val2 ;
22103 int ecode2 = 0 ;
22104 PyObject * obj0 = 0 ;
22105 PyObject * obj1 = 0 ;
22106 char * kwnames[] = {
22107 (char *) "self",(char *) "doIt", NULL
22108 };
22109
22110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22112 if (!SWIG_IsOK(res1)) {
22113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22114 }
22115 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22116 if (obj1) {
22117 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22118 if (!SWIG_IsOK(ecode2)) {
22119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22120 }
22121 arg2 = static_cast< bool >(val2);
22122 }
22123 {
22124 PyThreadState* __tstate = wxPyBeginAllowThreads();
22125 (arg1)->SetRecordDefaults(arg2);
22126 wxPyEndAllowThreads(__tstate);
22127 if (PyErr_Occurred()) SWIG_fail;
22128 }
22129 resultobj = SWIG_Py_Void();
22130 return resultobj;
22131 fail:
22132 return NULL;
22133 }
22134
22135
22136 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22137 PyObject *resultobj = 0;
22138 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22139 bool result;
22140 void *argp1 = 0 ;
22141 int res1 = 0 ;
22142 PyObject *swig_obj[1] ;
22143
22144 if (!args) SWIG_fail;
22145 swig_obj[0] = args;
22146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22147 if (!SWIG_IsOK(res1)) {
22148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22149 }
22150 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22151 {
22152 PyThreadState* __tstate = wxPyBeginAllowThreads();
22153 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22154 wxPyEndAllowThreads(__tstate);
22155 if (PyErr_Occurred()) SWIG_fail;
22156 }
22157 {
22158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22159 }
22160 return resultobj;
22161 fail:
22162 return NULL;
22163 }
22164
22165
22166 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22167 PyObject *resultobj = 0;
22168 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22169 wxString *arg2 = 0 ;
22170 wxString result;
22171 void *argp1 = 0 ;
22172 int res1 = 0 ;
22173 bool temp2 = false ;
22174 PyObject * obj0 = 0 ;
22175 PyObject * obj1 = 0 ;
22176 char * kwnames[] = {
22177 (char *) "self",(char *) "str", NULL
22178 };
22179
22180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22182 if (!SWIG_IsOK(res1)) {
22183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22184 }
22185 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22186 {
22187 arg2 = wxString_in_helper(obj1);
22188 if (arg2 == NULL) SWIG_fail;
22189 temp2 = true;
22190 }
22191 {
22192 PyThreadState* __tstate = wxPyBeginAllowThreads();
22193 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22194 wxPyEndAllowThreads(__tstate);
22195 if (PyErr_Occurred()) SWIG_fail;
22196 }
22197 {
22198 #if wxUSE_UNICODE
22199 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22200 #else
22201 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22202 #endif
22203 }
22204 {
22205 if (temp2)
22206 delete arg2;
22207 }
22208 return resultobj;
22209 fail:
22210 {
22211 if (temp2)
22212 delete arg2;
22213 }
22214 return NULL;
22215 }
22216
22217
22218 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22219 PyObject *resultobj = 0;
22220 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22221 wxString result;
22222 void *argp1 = 0 ;
22223 int res1 = 0 ;
22224 PyObject *swig_obj[1] ;
22225
22226 if (!args) SWIG_fail;
22227 swig_obj[0] = args;
22228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22229 if (!SWIG_IsOK(res1)) {
22230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22231 }
22232 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22233 {
22234 PyThreadState* __tstate = wxPyBeginAllowThreads();
22235 result = ((wxConfigBase const *)arg1)->GetAppName();
22236 wxPyEndAllowThreads(__tstate);
22237 if (PyErr_Occurred()) SWIG_fail;
22238 }
22239 {
22240 #if wxUSE_UNICODE
22241 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22242 #else
22243 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22244 #endif
22245 }
22246 return resultobj;
22247 fail:
22248 return NULL;
22249 }
22250
22251
22252 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22253 PyObject *resultobj = 0;
22254 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22255 wxString result;
22256 void *argp1 = 0 ;
22257 int res1 = 0 ;
22258 PyObject *swig_obj[1] ;
22259
22260 if (!args) SWIG_fail;
22261 swig_obj[0] = args;
22262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22263 if (!SWIG_IsOK(res1)) {
22264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22265 }
22266 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22267 {
22268 PyThreadState* __tstate = wxPyBeginAllowThreads();
22269 result = ((wxConfigBase const *)arg1)->GetVendorName();
22270 wxPyEndAllowThreads(__tstate);
22271 if (PyErr_Occurred()) SWIG_fail;
22272 }
22273 {
22274 #if wxUSE_UNICODE
22275 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22276 #else
22277 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22278 #endif
22279 }
22280 return resultobj;
22281 fail:
22282 return NULL;
22283 }
22284
22285
22286 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22287 PyObject *resultobj = 0;
22288 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22289 wxString *arg2 = 0 ;
22290 void *argp1 = 0 ;
22291 int res1 = 0 ;
22292 bool temp2 = false ;
22293 PyObject * obj0 = 0 ;
22294 PyObject * obj1 = 0 ;
22295 char * kwnames[] = {
22296 (char *) "self",(char *) "appName", NULL
22297 };
22298
22299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22301 if (!SWIG_IsOK(res1)) {
22302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22303 }
22304 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22305 {
22306 arg2 = wxString_in_helper(obj1);
22307 if (arg2 == NULL) SWIG_fail;
22308 temp2 = true;
22309 }
22310 {
22311 PyThreadState* __tstate = wxPyBeginAllowThreads();
22312 (arg1)->SetAppName((wxString const &)*arg2);
22313 wxPyEndAllowThreads(__tstate);
22314 if (PyErr_Occurred()) SWIG_fail;
22315 }
22316 resultobj = SWIG_Py_Void();
22317 {
22318 if (temp2)
22319 delete arg2;
22320 }
22321 return resultobj;
22322 fail:
22323 {
22324 if (temp2)
22325 delete arg2;
22326 }
22327 return NULL;
22328 }
22329
22330
22331 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22332 PyObject *resultobj = 0;
22333 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22334 wxString *arg2 = 0 ;
22335 void *argp1 = 0 ;
22336 int res1 = 0 ;
22337 bool temp2 = false ;
22338 PyObject * obj0 = 0 ;
22339 PyObject * obj1 = 0 ;
22340 char * kwnames[] = {
22341 (char *) "self",(char *) "vendorName", NULL
22342 };
22343
22344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22346 if (!SWIG_IsOK(res1)) {
22347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22348 }
22349 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22350 {
22351 arg2 = wxString_in_helper(obj1);
22352 if (arg2 == NULL) SWIG_fail;
22353 temp2 = true;
22354 }
22355 {
22356 PyThreadState* __tstate = wxPyBeginAllowThreads();
22357 (arg1)->SetVendorName((wxString const &)*arg2);
22358 wxPyEndAllowThreads(__tstate);
22359 if (PyErr_Occurred()) SWIG_fail;
22360 }
22361 resultobj = SWIG_Py_Void();
22362 {
22363 if (temp2)
22364 delete arg2;
22365 }
22366 return resultobj;
22367 fail:
22368 {
22369 if (temp2)
22370 delete arg2;
22371 }
22372 return NULL;
22373 }
22374
22375
22376 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22377 PyObject *resultobj = 0;
22378 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22379 long arg2 ;
22380 void *argp1 = 0 ;
22381 int res1 = 0 ;
22382 long val2 ;
22383 int ecode2 = 0 ;
22384 PyObject * obj0 = 0 ;
22385 PyObject * obj1 = 0 ;
22386 char * kwnames[] = {
22387 (char *) "self",(char *) "style", NULL
22388 };
22389
22390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22392 if (!SWIG_IsOK(res1)) {
22393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22394 }
22395 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22396 ecode2 = SWIG_AsVal_long(obj1, &val2);
22397 if (!SWIG_IsOK(ecode2)) {
22398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22399 }
22400 arg2 = static_cast< long >(val2);
22401 {
22402 PyThreadState* __tstate = wxPyBeginAllowThreads();
22403 (arg1)->SetStyle(arg2);
22404 wxPyEndAllowThreads(__tstate);
22405 if (PyErr_Occurred()) SWIG_fail;
22406 }
22407 resultobj = SWIG_Py_Void();
22408 return resultobj;
22409 fail:
22410 return NULL;
22411 }
22412
22413
22414 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22415 PyObject *resultobj = 0;
22416 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22417 long result;
22418 void *argp1 = 0 ;
22419 int res1 = 0 ;
22420 PyObject *swig_obj[1] ;
22421
22422 if (!args) SWIG_fail;
22423 swig_obj[0] = args;
22424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22425 if (!SWIG_IsOK(res1)) {
22426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22427 }
22428 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22429 {
22430 PyThreadState* __tstate = wxPyBeginAllowThreads();
22431 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22432 wxPyEndAllowThreads(__tstate);
22433 if (PyErr_Occurred()) SWIG_fail;
22434 }
22435 resultobj = SWIG_From_long(static_cast< long >(result));
22436 return resultobj;
22437 fail:
22438 return NULL;
22439 }
22440
22441
22442 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22443 PyObject *obj;
22444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22445 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22446 return SWIG_Py_Void();
22447 }
22448
22449 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22450 PyObject *resultobj = 0;
22451 wxString const &arg1_defvalue = wxPyEmptyString ;
22452 wxString *arg1 = (wxString *) &arg1_defvalue ;
22453 wxString const &arg2_defvalue = wxPyEmptyString ;
22454 wxString *arg2 = (wxString *) &arg2_defvalue ;
22455 wxString const &arg3_defvalue = wxPyEmptyString ;
22456 wxString *arg3 = (wxString *) &arg3_defvalue ;
22457 wxString const &arg4_defvalue = wxPyEmptyString ;
22458 wxString *arg4 = (wxString *) &arg4_defvalue ;
22459 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22460 wxConfig *result = 0 ;
22461 bool temp1 = false ;
22462 bool temp2 = false ;
22463 bool temp3 = false ;
22464 bool temp4 = false ;
22465 long val5 ;
22466 int ecode5 = 0 ;
22467 PyObject * obj0 = 0 ;
22468 PyObject * obj1 = 0 ;
22469 PyObject * obj2 = 0 ;
22470 PyObject * obj3 = 0 ;
22471 PyObject * obj4 = 0 ;
22472 char * kwnames[] = {
22473 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22474 };
22475
22476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22477 if (obj0) {
22478 {
22479 arg1 = wxString_in_helper(obj0);
22480 if (arg1 == NULL) SWIG_fail;
22481 temp1 = true;
22482 }
22483 }
22484 if (obj1) {
22485 {
22486 arg2 = wxString_in_helper(obj1);
22487 if (arg2 == NULL) SWIG_fail;
22488 temp2 = true;
22489 }
22490 }
22491 if (obj2) {
22492 {
22493 arg3 = wxString_in_helper(obj2);
22494 if (arg3 == NULL) SWIG_fail;
22495 temp3 = true;
22496 }
22497 }
22498 if (obj3) {
22499 {
22500 arg4 = wxString_in_helper(obj3);
22501 if (arg4 == NULL) SWIG_fail;
22502 temp4 = true;
22503 }
22504 }
22505 if (obj4) {
22506 ecode5 = SWIG_AsVal_long(obj4, &val5);
22507 if (!SWIG_IsOK(ecode5)) {
22508 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22509 }
22510 arg5 = static_cast< long >(val5);
22511 }
22512 {
22513 PyThreadState* __tstate = wxPyBeginAllowThreads();
22514 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22515 wxPyEndAllowThreads(__tstate);
22516 if (PyErr_Occurred()) SWIG_fail;
22517 }
22518 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22519 {
22520 if (temp1)
22521 delete arg1;
22522 }
22523 {
22524 if (temp2)
22525 delete arg2;
22526 }
22527 {
22528 if (temp3)
22529 delete arg3;
22530 }
22531 {
22532 if (temp4)
22533 delete arg4;
22534 }
22535 return resultobj;
22536 fail:
22537 {
22538 if (temp1)
22539 delete arg1;
22540 }
22541 {
22542 if (temp2)
22543 delete arg2;
22544 }
22545 {
22546 if (temp3)
22547 delete arg3;
22548 }
22549 {
22550 if (temp4)
22551 delete arg4;
22552 }
22553 return NULL;
22554 }
22555
22556
22557 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22558 PyObject *resultobj = 0;
22559 wxConfig *arg1 = (wxConfig *) 0 ;
22560 void *argp1 = 0 ;
22561 int res1 = 0 ;
22562 PyObject *swig_obj[1] ;
22563
22564 if (!args) SWIG_fail;
22565 swig_obj[0] = args;
22566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22567 if (!SWIG_IsOK(res1)) {
22568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22569 }
22570 arg1 = reinterpret_cast< wxConfig * >(argp1);
22571 {
22572 PyThreadState* __tstate = wxPyBeginAllowThreads();
22573 delete arg1;
22574
22575 wxPyEndAllowThreads(__tstate);
22576 if (PyErr_Occurred()) SWIG_fail;
22577 }
22578 resultobj = SWIG_Py_Void();
22579 return resultobj;
22580 fail:
22581 return NULL;
22582 }
22583
22584
22585 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22586 PyObject *obj;
22587 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22588 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22589 return SWIG_Py_Void();
22590 }
22591
22592 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22593 return SWIG_Python_InitShadowInstance(args);
22594 }
22595
22596 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22597 PyObject *resultobj = 0;
22598 wxString const &arg1_defvalue = wxPyEmptyString ;
22599 wxString *arg1 = (wxString *) &arg1_defvalue ;
22600 wxString const &arg2_defvalue = wxPyEmptyString ;
22601 wxString *arg2 = (wxString *) &arg2_defvalue ;
22602 wxString const &arg3_defvalue = wxPyEmptyString ;
22603 wxString *arg3 = (wxString *) &arg3_defvalue ;
22604 wxString const &arg4_defvalue = wxPyEmptyString ;
22605 wxString *arg4 = (wxString *) &arg4_defvalue ;
22606 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22607 wxFileConfig *result = 0 ;
22608 bool temp1 = false ;
22609 bool temp2 = false ;
22610 bool temp3 = false ;
22611 bool temp4 = false ;
22612 long val5 ;
22613 int ecode5 = 0 ;
22614 PyObject * obj0 = 0 ;
22615 PyObject * obj1 = 0 ;
22616 PyObject * obj2 = 0 ;
22617 PyObject * obj3 = 0 ;
22618 PyObject * obj4 = 0 ;
22619 char * kwnames[] = {
22620 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22621 };
22622
22623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22624 if (obj0) {
22625 {
22626 arg1 = wxString_in_helper(obj0);
22627 if (arg1 == NULL) SWIG_fail;
22628 temp1 = true;
22629 }
22630 }
22631 if (obj1) {
22632 {
22633 arg2 = wxString_in_helper(obj1);
22634 if (arg2 == NULL) SWIG_fail;
22635 temp2 = true;
22636 }
22637 }
22638 if (obj2) {
22639 {
22640 arg3 = wxString_in_helper(obj2);
22641 if (arg3 == NULL) SWIG_fail;
22642 temp3 = true;
22643 }
22644 }
22645 if (obj3) {
22646 {
22647 arg4 = wxString_in_helper(obj3);
22648 if (arg4 == NULL) SWIG_fail;
22649 temp4 = true;
22650 }
22651 }
22652 if (obj4) {
22653 ecode5 = SWIG_AsVal_long(obj4, &val5);
22654 if (!SWIG_IsOK(ecode5)) {
22655 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22656 }
22657 arg5 = static_cast< long >(val5);
22658 }
22659 {
22660 PyThreadState* __tstate = wxPyBeginAllowThreads();
22661 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22662 wxPyEndAllowThreads(__tstate);
22663 if (PyErr_Occurred()) SWIG_fail;
22664 }
22665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22666 {
22667 if (temp1)
22668 delete arg1;
22669 }
22670 {
22671 if (temp2)
22672 delete arg2;
22673 }
22674 {
22675 if (temp3)
22676 delete arg3;
22677 }
22678 {
22679 if (temp4)
22680 delete arg4;
22681 }
22682 return resultobj;
22683 fail:
22684 {
22685 if (temp1)
22686 delete arg1;
22687 }
22688 {
22689 if (temp2)
22690 delete arg2;
22691 }
22692 {
22693 if (temp3)
22694 delete arg3;
22695 }
22696 {
22697 if (temp4)
22698 delete arg4;
22699 }
22700 return NULL;
22701 }
22702
22703
22704 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22705 PyObject *resultobj = 0;
22706 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22707 void *argp1 = 0 ;
22708 int res1 = 0 ;
22709 PyObject *swig_obj[1] ;
22710
22711 if (!args) SWIG_fail;
22712 swig_obj[0] = args;
22713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22714 if (!SWIG_IsOK(res1)) {
22715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22716 }
22717 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22718 {
22719 PyThreadState* __tstate = wxPyBeginAllowThreads();
22720 delete arg1;
22721
22722 wxPyEndAllowThreads(__tstate);
22723 if (PyErr_Occurred()) SWIG_fail;
22724 }
22725 resultobj = SWIG_Py_Void();
22726 return resultobj;
22727 fail:
22728 return NULL;
22729 }
22730
22731
22732 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22733 PyObject *obj;
22734 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22735 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22736 return SWIG_Py_Void();
22737 }
22738
22739 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22740 return SWIG_Python_InitShadowInstance(args);
22741 }
22742
22743 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22744 PyObject *resultobj = 0;
22745 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22746 wxString *arg2 = 0 ;
22747 wxConfigPathChanger *result = 0 ;
22748 void *argp1 = 0 ;
22749 int res1 = 0 ;
22750 bool temp2 = false ;
22751 PyObject * obj0 = 0 ;
22752 PyObject * obj1 = 0 ;
22753 char * kwnames[] = {
22754 (char *) "config",(char *) "entry", NULL
22755 };
22756
22757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22759 if (!SWIG_IsOK(res1)) {
22760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22761 }
22762 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22763 {
22764 arg2 = wxString_in_helper(obj1);
22765 if (arg2 == NULL) SWIG_fail;
22766 temp2 = true;
22767 }
22768 {
22769 PyThreadState* __tstate = wxPyBeginAllowThreads();
22770 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22771 wxPyEndAllowThreads(__tstate);
22772 if (PyErr_Occurred()) SWIG_fail;
22773 }
22774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
22775 {
22776 if (temp2)
22777 delete arg2;
22778 }
22779 return resultobj;
22780 fail:
22781 {
22782 if (temp2)
22783 delete arg2;
22784 }
22785 return NULL;
22786 }
22787
22788
22789 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22790 PyObject *resultobj = 0;
22791 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22792 void *argp1 = 0 ;
22793 int res1 = 0 ;
22794 PyObject *swig_obj[1] ;
22795
22796 if (!args) SWIG_fail;
22797 swig_obj[0] = args;
22798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
22799 if (!SWIG_IsOK(res1)) {
22800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
22801 }
22802 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22803 {
22804 PyThreadState* __tstate = wxPyBeginAllowThreads();
22805 delete arg1;
22806
22807 wxPyEndAllowThreads(__tstate);
22808 if (PyErr_Occurred()) SWIG_fail;
22809 }
22810 resultobj = SWIG_Py_Void();
22811 return resultobj;
22812 fail:
22813 return NULL;
22814 }
22815
22816
22817 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22818 PyObject *resultobj = 0;
22819 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22820 wxString *result = 0 ;
22821 void *argp1 = 0 ;
22822 int res1 = 0 ;
22823 PyObject *swig_obj[1] ;
22824
22825 if (!args) SWIG_fail;
22826 swig_obj[0] = args;
22827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
22828 if (!SWIG_IsOK(res1)) {
22829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
22830 }
22831 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22832 {
22833 PyThreadState* __tstate = wxPyBeginAllowThreads();
22834 {
22835 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
22836 result = (wxString *) &_result_ref;
22837 }
22838 wxPyEndAllowThreads(__tstate);
22839 if (PyErr_Occurred()) SWIG_fail;
22840 }
22841 {
22842 #if wxUSE_UNICODE
22843 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22844 #else
22845 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22846 #endif
22847 }
22848 return resultobj;
22849 fail:
22850 return NULL;
22851 }
22852
22853
22854 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22855 PyObject *obj;
22856 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22857 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
22858 return SWIG_Py_Void();
22859 }
22860
22861 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22862 return SWIG_Python_InitShadowInstance(args);
22863 }
22864
22865 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22866 PyObject *resultobj = 0;
22867 wxString *arg1 = 0 ;
22868 wxString result;
22869 bool temp1 = false ;
22870 PyObject * obj0 = 0 ;
22871 char * kwnames[] = {
22872 (char *) "sz", NULL
22873 };
22874
22875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
22876 {
22877 arg1 = wxString_in_helper(obj0);
22878 if (arg1 == NULL) SWIG_fail;
22879 temp1 = true;
22880 }
22881 {
22882 PyThreadState* __tstate = wxPyBeginAllowThreads();
22883 result = wxExpandEnvVars((wxString const &)*arg1);
22884 wxPyEndAllowThreads(__tstate);
22885 if (PyErr_Occurred()) SWIG_fail;
22886 }
22887 {
22888 #if wxUSE_UNICODE
22889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22890 #else
22891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22892 #endif
22893 }
22894 {
22895 if (temp1)
22896 delete arg1;
22897 }
22898 return resultobj;
22899 fail:
22900 {
22901 if (temp1)
22902 delete arg1;
22903 }
22904 return NULL;
22905 }
22906
22907
22908 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
22909 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
22910 return 1;
22911 }
22912
22913
22914 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
22915 PyObject *pyobj = 0;
22916
22917 {
22918 #if wxUSE_UNICODE
22919 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
22920 #else
22921 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
22922 #endif
22923 }
22924 return pyobj;
22925 }
22926
22927
22928 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
22929 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
22930 return 1;
22931 }
22932
22933
22934 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
22935 PyObject *pyobj = 0;
22936
22937 {
22938 #if wxUSE_UNICODE
22939 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22940 #else
22941 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22942 #endif
22943 }
22944 return pyobj;
22945 }
22946
22947
22948 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22949 PyObject *resultobj = 0;
22950 wxDateTime::Country arg1 ;
22951 int val1 ;
22952 int ecode1 = 0 ;
22953 PyObject * obj0 = 0 ;
22954 char * kwnames[] = {
22955 (char *) "country", NULL
22956 };
22957
22958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
22959 ecode1 = SWIG_AsVal_int(obj0, &val1);
22960 if (!SWIG_IsOK(ecode1)) {
22961 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22962 }
22963 arg1 = static_cast< wxDateTime::Country >(val1);
22964 {
22965 PyThreadState* __tstate = wxPyBeginAllowThreads();
22966 wxDateTime::SetCountry(arg1);
22967 wxPyEndAllowThreads(__tstate);
22968 if (PyErr_Occurred()) SWIG_fail;
22969 }
22970 resultobj = SWIG_Py_Void();
22971 return resultobj;
22972 fail:
22973 return NULL;
22974 }
22975
22976
22977 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22978 PyObject *resultobj = 0;
22979 wxDateTime::Country result;
22980
22981 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
22982 {
22983 PyThreadState* __tstate = wxPyBeginAllowThreads();
22984 result = (wxDateTime::Country)wxDateTime::GetCountry();
22985 wxPyEndAllowThreads(__tstate);
22986 if (PyErr_Occurred()) SWIG_fail;
22987 }
22988 resultobj = SWIG_From_int(static_cast< int >(result));
22989 return resultobj;
22990 fail:
22991 return NULL;
22992 }
22993
22994
22995 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22996 PyObject *resultobj = 0;
22997 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
22998 bool result;
22999 int val1 ;
23000 int ecode1 = 0 ;
23001 PyObject * obj0 = 0 ;
23002 char * kwnames[] = {
23003 (char *) "country", NULL
23004 };
23005
23006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23007 if (obj0) {
23008 ecode1 = SWIG_AsVal_int(obj0, &val1);
23009 if (!SWIG_IsOK(ecode1)) {
23010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23011 }
23012 arg1 = static_cast< wxDateTime::Country >(val1);
23013 }
23014 {
23015 PyThreadState* __tstate = wxPyBeginAllowThreads();
23016 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23017 wxPyEndAllowThreads(__tstate);
23018 if (PyErr_Occurred()) SWIG_fail;
23019 }
23020 {
23021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23022 }
23023 return resultobj;
23024 fail:
23025 return NULL;
23026 }
23027
23028
23029 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23030 PyObject *resultobj = 0;
23031 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23032 int result;
23033 int val1 ;
23034 int ecode1 = 0 ;
23035 PyObject * obj0 = 0 ;
23036 char * kwnames[] = {
23037 (char *) "cal", NULL
23038 };
23039
23040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23041 if (obj0) {
23042 ecode1 = SWIG_AsVal_int(obj0, &val1);
23043 if (!SWIG_IsOK(ecode1)) {
23044 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23045 }
23046 arg1 = static_cast< wxDateTime::Calendar >(val1);
23047 }
23048 {
23049 PyThreadState* __tstate = wxPyBeginAllowThreads();
23050 result = (int)wxDateTime::GetCurrentYear(arg1);
23051 wxPyEndAllowThreads(__tstate);
23052 if (PyErr_Occurred()) SWIG_fail;
23053 }
23054 resultobj = SWIG_From_int(static_cast< int >(result));
23055 return resultobj;
23056 fail:
23057 return NULL;
23058 }
23059
23060
23061 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23062 PyObject *resultobj = 0;
23063 int arg1 ;
23064 int result;
23065 int val1 ;
23066 int ecode1 = 0 ;
23067 PyObject * obj0 = 0 ;
23068 char * kwnames[] = {
23069 (char *) "year", NULL
23070 };
23071
23072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23073 ecode1 = SWIG_AsVal_int(obj0, &val1);
23074 if (!SWIG_IsOK(ecode1)) {
23075 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23076 }
23077 arg1 = static_cast< int >(val1);
23078 {
23079 PyThreadState* __tstate = wxPyBeginAllowThreads();
23080 result = (int)wxDateTime::ConvertYearToBC(arg1);
23081 wxPyEndAllowThreads(__tstate);
23082 if (PyErr_Occurred()) SWIG_fail;
23083 }
23084 resultobj = SWIG_From_int(static_cast< int >(result));
23085 return resultobj;
23086 fail:
23087 return NULL;
23088 }
23089
23090
23091 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23092 PyObject *resultobj = 0;
23093 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23094 wxDateTime::Month result;
23095 int val1 ;
23096 int ecode1 = 0 ;
23097 PyObject * obj0 = 0 ;
23098 char * kwnames[] = {
23099 (char *) "cal", NULL
23100 };
23101
23102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23103 if (obj0) {
23104 ecode1 = SWIG_AsVal_int(obj0, &val1);
23105 if (!SWIG_IsOK(ecode1)) {
23106 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23107 }
23108 arg1 = static_cast< wxDateTime::Calendar >(val1);
23109 }
23110 {
23111 PyThreadState* __tstate = wxPyBeginAllowThreads();
23112 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23113 wxPyEndAllowThreads(__tstate);
23114 if (PyErr_Occurred()) SWIG_fail;
23115 }
23116 resultobj = SWIG_From_int(static_cast< int >(result));
23117 return resultobj;
23118 fail:
23119 return NULL;
23120 }
23121
23122
23123 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23124 PyObject *resultobj = 0;
23125 int arg1 = (int) wxDateTime::Inv_Year ;
23126 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23127 bool result;
23128 int val1 ;
23129 int ecode1 = 0 ;
23130 int val2 ;
23131 int ecode2 = 0 ;
23132 PyObject * obj0 = 0 ;
23133 PyObject * obj1 = 0 ;
23134 char * kwnames[] = {
23135 (char *) "year",(char *) "cal", NULL
23136 };
23137
23138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23139 if (obj0) {
23140 ecode1 = SWIG_AsVal_int(obj0, &val1);
23141 if (!SWIG_IsOK(ecode1)) {
23142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23143 }
23144 arg1 = static_cast< int >(val1);
23145 }
23146 if (obj1) {
23147 ecode2 = SWIG_AsVal_int(obj1, &val2);
23148 if (!SWIG_IsOK(ecode2)) {
23149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23150 }
23151 arg2 = static_cast< wxDateTime::Calendar >(val2);
23152 }
23153 {
23154 PyThreadState* __tstate = wxPyBeginAllowThreads();
23155 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23156 wxPyEndAllowThreads(__tstate);
23157 if (PyErr_Occurred()) SWIG_fail;
23158 }
23159 {
23160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23161 }
23162 return resultobj;
23163 fail:
23164 return NULL;
23165 }
23166
23167
23168 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23169 PyObject *resultobj = 0;
23170 int arg1 = (int) wxDateTime::Inv_Year ;
23171 int result;
23172 int val1 ;
23173 int ecode1 = 0 ;
23174 PyObject * obj0 = 0 ;
23175 char * kwnames[] = {
23176 (char *) "year", NULL
23177 };
23178
23179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23180 if (obj0) {
23181 ecode1 = SWIG_AsVal_int(obj0, &val1);
23182 if (!SWIG_IsOK(ecode1)) {
23183 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23184 }
23185 arg1 = static_cast< int >(val1);
23186 }
23187 {
23188 PyThreadState* __tstate = wxPyBeginAllowThreads();
23189 result = (int)wxDateTime::GetCentury(arg1);
23190 wxPyEndAllowThreads(__tstate);
23191 if (PyErr_Occurred()) SWIG_fail;
23192 }
23193 resultobj = SWIG_From_int(static_cast< int >(result));
23194 return resultobj;
23195 fail:
23196 return NULL;
23197 }
23198
23199
23200 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23201 PyObject *resultobj = 0;
23202 int arg1 ;
23203 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23204 int result;
23205 int val1 ;
23206 int ecode1 = 0 ;
23207 int val2 ;
23208 int ecode2 = 0 ;
23209 PyObject * obj0 = 0 ;
23210 PyObject * obj1 = 0 ;
23211 char * kwnames[] = {
23212 (char *) "year",(char *) "cal", NULL
23213 };
23214
23215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23216 ecode1 = SWIG_AsVal_int(obj0, &val1);
23217 if (!SWIG_IsOK(ecode1)) {
23218 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23219 }
23220 arg1 = static_cast< int >(val1);
23221 if (obj1) {
23222 ecode2 = SWIG_AsVal_int(obj1, &val2);
23223 if (!SWIG_IsOK(ecode2)) {
23224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23225 }
23226 arg2 = static_cast< wxDateTime::Calendar >(val2);
23227 }
23228 {
23229 PyThreadState* __tstate = wxPyBeginAllowThreads();
23230 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23231 wxPyEndAllowThreads(__tstate);
23232 if (PyErr_Occurred()) SWIG_fail;
23233 }
23234 resultobj = SWIG_From_int(static_cast< int >(result));
23235 return resultobj;
23236 fail:
23237 return NULL;
23238 }
23239
23240
23241 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23242 PyObject *resultobj = 0;
23243 wxDateTime::Month arg1 ;
23244 int arg2 = (int) wxDateTime::Inv_Year ;
23245 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23246 int result;
23247 int val1 ;
23248 int ecode1 = 0 ;
23249 int val2 ;
23250 int ecode2 = 0 ;
23251 int val3 ;
23252 int ecode3 = 0 ;
23253 PyObject * obj0 = 0 ;
23254 PyObject * obj1 = 0 ;
23255 PyObject * obj2 = 0 ;
23256 char * kwnames[] = {
23257 (char *) "month",(char *) "year",(char *) "cal", NULL
23258 };
23259
23260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23261 ecode1 = SWIG_AsVal_int(obj0, &val1);
23262 if (!SWIG_IsOK(ecode1)) {
23263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23264 }
23265 arg1 = static_cast< wxDateTime::Month >(val1);
23266 if (obj1) {
23267 ecode2 = SWIG_AsVal_int(obj1, &val2);
23268 if (!SWIG_IsOK(ecode2)) {
23269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23270 }
23271 arg2 = static_cast< int >(val2);
23272 }
23273 if (obj2) {
23274 ecode3 = SWIG_AsVal_int(obj2, &val3);
23275 if (!SWIG_IsOK(ecode3)) {
23276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23277 }
23278 arg3 = static_cast< wxDateTime::Calendar >(val3);
23279 }
23280 {
23281 PyThreadState* __tstate = wxPyBeginAllowThreads();
23282 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23283 wxPyEndAllowThreads(__tstate);
23284 if (PyErr_Occurred()) SWIG_fail;
23285 }
23286 resultobj = SWIG_From_int(static_cast< int >(result));
23287 return resultobj;
23288 fail:
23289 return NULL;
23290 }
23291
23292
23293 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23294 PyObject *resultobj = 0;
23295 wxDateTime::Month arg1 ;
23296 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23297 wxString result;
23298 int val1 ;
23299 int ecode1 = 0 ;
23300 int val2 ;
23301 int ecode2 = 0 ;
23302 PyObject * obj0 = 0 ;
23303 PyObject * obj1 = 0 ;
23304 char * kwnames[] = {
23305 (char *) "month",(char *) "flags", NULL
23306 };
23307
23308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23309 ecode1 = SWIG_AsVal_int(obj0, &val1);
23310 if (!SWIG_IsOK(ecode1)) {
23311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23312 }
23313 arg1 = static_cast< wxDateTime::Month >(val1);
23314 if (obj1) {
23315 ecode2 = SWIG_AsVal_int(obj1, &val2);
23316 if (!SWIG_IsOK(ecode2)) {
23317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23318 }
23319 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23320 }
23321 {
23322 PyThreadState* __tstate = wxPyBeginAllowThreads();
23323 result = wxDateTime::GetMonthName(arg1,arg2);
23324 wxPyEndAllowThreads(__tstate);
23325 if (PyErr_Occurred()) SWIG_fail;
23326 }
23327 {
23328 #if wxUSE_UNICODE
23329 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23330 #else
23331 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23332 #endif
23333 }
23334 return resultobj;
23335 fail:
23336 return NULL;
23337 }
23338
23339
23340 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23341 PyObject *resultobj = 0;
23342 wxDateTime::WeekDay arg1 ;
23343 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23344 wxString result;
23345 int val1 ;
23346 int ecode1 = 0 ;
23347 int val2 ;
23348 int ecode2 = 0 ;
23349 PyObject * obj0 = 0 ;
23350 PyObject * obj1 = 0 ;
23351 char * kwnames[] = {
23352 (char *) "weekday",(char *) "flags", NULL
23353 };
23354
23355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23356 ecode1 = SWIG_AsVal_int(obj0, &val1);
23357 if (!SWIG_IsOK(ecode1)) {
23358 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23359 }
23360 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23361 if (obj1) {
23362 ecode2 = SWIG_AsVal_int(obj1, &val2);
23363 if (!SWIG_IsOK(ecode2)) {
23364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23365 }
23366 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23367 }
23368 {
23369 PyThreadState* __tstate = wxPyBeginAllowThreads();
23370 result = wxDateTime::GetWeekDayName(arg1,arg2);
23371 wxPyEndAllowThreads(__tstate);
23372 if (PyErr_Occurred()) SWIG_fail;
23373 }
23374 {
23375 #if wxUSE_UNICODE
23376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23377 #else
23378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23379 #endif
23380 }
23381 return resultobj;
23382 fail:
23383 return NULL;
23384 }
23385
23386
23387 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23388 PyObject *resultobj = 0;
23389 PyObject *result = 0 ;
23390
23391 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23392 {
23393 PyThreadState* __tstate = wxPyBeginAllowThreads();
23394 result = (PyObject *)wxDateTime_GetAmPmStrings();
23395 wxPyEndAllowThreads(__tstate);
23396 if (PyErr_Occurred()) SWIG_fail;
23397 }
23398 resultobj = result;
23399 return resultobj;
23400 fail:
23401 return NULL;
23402 }
23403
23404
23405 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23406 PyObject *resultobj = 0;
23407 int arg1 = (int) wxDateTime::Inv_Year ;
23408 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23409 bool result;
23410 int val1 ;
23411 int ecode1 = 0 ;
23412 int val2 ;
23413 int ecode2 = 0 ;
23414 PyObject * obj0 = 0 ;
23415 PyObject * obj1 = 0 ;
23416 char * kwnames[] = {
23417 (char *) "year",(char *) "country", NULL
23418 };
23419
23420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23421 if (obj0) {
23422 ecode1 = SWIG_AsVal_int(obj0, &val1);
23423 if (!SWIG_IsOK(ecode1)) {
23424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23425 }
23426 arg1 = static_cast< int >(val1);
23427 }
23428 if (obj1) {
23429 ecode2 = SWIG_AsVal_int(obj1, &val2);
23430 if (!SWIG_IsOK(ecode2)) {
23431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23432 }
23433 arg2 = static_cast< wxDateTime::Country >(val2);
23434 }
23435 {
23436 PyThreadState* __tstate = wxPyBeginAllowThreads();
23437 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23438 wxPyEndAllowThreads(__tstate);
23439 if (PyErr_Occurred()) SWIG_fail;
23440 }
23441 {
23442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23443 }
23444 return resultobj;
23445 fail:
23446 return NULL;
23447 }
23448
23449
23450 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23451 PyObject *resultobj = 0;
23452 int arg1 = (int) wxDateTime::Inv_Year ;
23453 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23454 wxDateTime result;
23455 int val1 ;
23456 int ecode1 = 0 ;
23457 int val2 ;
23458 int ecode2 = 0 ;
23459 PyObject * obj0 = 0 ;
23460 PyObject * obj1 = 0 ;
23461 char * kwnames[] = {
23462 (char *) "year",(char *) "country", NULL
23463 };
23464
23465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23466 if (obj0) {
23467 ecode1 = SWIG_AsVal_int(obj0, &val1);
23468 if (!SWIG_IsOK(ecode1)) {
23469 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23470 }
23471 arg1 = static_cast< int >(val1);
23472 }
23473 if (obj1) {
23474 ecode2 = SWIG_AsVal_int(obj1, &val2);
23475 if (!SWIG_IsOK(ecode2)) {
23476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23477 }
23478 arg2 = static_cast< wxDateTime::Country >(val2);
23479 }
23480 {
23481 PyThreadState* __tstate = wxPyBeginAllowThreads();
23482 result = wxDateTime::GetBeginDST(arg1,arg2);
23483 wxPyEndAllowThreads(__tstate);
23484 if (PyErr_Occurred()) SWIG_fail;
23485 }
23486 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23487 return resultobj;
23488 fail:
23489 return NULL;
23490 }
23491
23492
23493 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23494 PyObject *resultobj = 0;
23495 int arg1 = (int) wxDateTime::Inv_Year ;
23496 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23497 wxDateTime result;
23498 int val1 ;
23499 int ecode1 = 0 ;
23500 int val2 ;
23501 int ecode2 = 0 ;
23502 PyObject * obj0 = 0 ;
23503 PyObject * obj1 = 0 ;
23504 char * kwnames[] = {
23505 (char *) "year",(char *) "country", NULL
23506 };
23507
23508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23509 if (obj0) {
23510 ecode1 = SWIG_AsVal_int(obj0, &val1);
23511 if (!SWIG_IsOK(ecode1)) {
23512 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23513 }
23514 arg1 = static_cast< int >(val1);
23515 }
23516 if (obj1) {
23517 ecode2 = SWIG_AsVal_int(obj1, &val2);
23518 if (!SWIG_IsOK(ecode2)) {
23519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23520 }
23521 arg2 = static_cast< wxDateTime::Country >(val2);
23522 }
23523 {
23524 PyThreadState* __tstate = wxPyBeginAllowThreads();
23525 result = wxDateTime::GetEndDST(arg1,arg2);
23526 wxPyEndAllowThreads(__tstate);
23527 if (PyErr_Occurred()) SWIG_fail;
23528 }
23529 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23530 return resultobj;
23531 fail:
23532 return NULL;
23533 }
23534
23535
23536 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23537 PyObject *resultobj = 0;
23538 wxDateTime result;
23539
23540 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23541 {
23542 PyThreadState* __tstate = wxPyBeginAllowThreads();
23543 result = wxDateTime::Now();
23544 wxPyEndAllowThreads(__tstate);
23545 if (PyErr_Occurred()) SWIG_fail;
23546 }
23547 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23548 return resultobj;
23549 fail:
23550 return NULL;
23551 }
23552
23553
23554 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23555 PyObject *resultobj = 0;
23556 wxDateTime result;
23557
23558 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23559 {
23560 PyThreadState* __tstate = wxPyBeginAllowThreads();
23561 result = wxDateTime::UNow();
23562 wxPyEndAllowThreads(__tstate);
23563 if (PyErr_Occurred()) SWIG_fail;
23564 }
23565 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23566 return resultobj;
23567 fail:
23568 return NULL;
23569 }
23570
23571
23572 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23573 PyObject *resultobj = 0;
23574 wxDateTime result;
23575
23576 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23577 {
23578 PyThreadState* __tstate = wxPyBeginAllowThreads();
23579 result = wxDateTime::Today();
23580 wxPyEndAllowThreads(__tstate);
23581 if (PyErr_Occurred()) SWIG_fail;
23582 }
23583 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23584 return resultobj;
23585 fail:
23586 return NULL;
23587 }
23588
23589
23590 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23591 PyObject *resultobj = 0;
23592 wxDateTime *result = 0 ;
23593
23594 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23595 {
23596 PyThreadState* __tstate = wxPyBeginAllowThreads();
23597 result = (wxDateTime *)new wxDateTime();
23598 wxPyEndAllowThreads(__tstate);
23599 if (PyErr_Occurred()) SWIG_fail;
23600 }
23601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23602 return resultobj;
23603 fail:
23604 return NULL;
23605 }
23606
23607
23608 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23609 PyObject *resultobj = 0;
23610 time_t arg1 ;
23611 wxDateTime *result = 0 ;
23612 unsigned int val1 ;
23613 int ecode1 = 0 ;
23614 PyObject * obj0 = 0 ;
23615 char * kwnames[] = {
23616 (char *) "timet", NULL
23617 };
23618
23619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23620 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23621 if (!SWIG_IsOK(ecode1)) {
23622 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23623 }
23624 arg1 = static_cast< time_t >(val1);
23625 {
23626 PyThreadState* __tstate = wxPyBeginAllowThreads();
23627 result = (wxDateTime *)new wxDateTime(arg1);
23628 wxPyEndAllowThreads(__tstate);
23629 if (PyErr_Occurred()) SWIG_fail;
23630 }
23631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23632 return resultobj;
23633 fail:
23634 return NULL;
23635 }
23636
23637
23638 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23639 PyObject *resultobj = 0;
23640 double arg1 ;
23641 wxDateTime *result = 0 ;
23642 double val1 ;
23643 int ecode1 = 0 ;
23644 PyObject * obj0 = 0 ;
23645 char * kwnames[] = {
23646 (char *) "jdn", NULL
23647 };
23648
23649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23650 ecode1 = SWIG_AsVal_double(obj0, &val1);
23651 if (!SWIG_IsOK(ecode1)) {
23652 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23653 }
23654 arg1 = static_cast< double >(val1);
23655 {
23656 PyThreadState* __tstate = wxPyBeginAllowThreads();
23657 result = (wxDateTime *)new wxDateTime(arg1);
23658 wxPyEndAllowThreads(__tstate);
23659 if (PyErr_Occurred()) SWIG_fail;
23660 }
23661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23662 return resultobj;
23663 fail:
23664 return NULL;
23665 }
23666
23667
23668 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23669 PyObject *resultobj = 0;
23670 int arg1 ;
23671 int arg2 = (int) 0 ;
23672 int arg3 = (int) 0 ;
23673 int arg4 = (int) 0 ;
23674 wxDateTime *result = 0 ;
23675 int val1 ;
23676 int ecode1 = 0 ;
23677 int val2 ;
23678 int ecode2 = 0 ;
23679 int val3 ;
23680 int ecode3 = 0 ;
23681 int val4 ;
23682 int ecode4 = 0 ;
23683 PyObject * obj0 = 0 ;
23684 PyObject * obj1 = 0 ;
23685 PyObject * obj2 = 0 ;
23686 PyObject * obj3 = 0 ;
23687 char * kwnames[] = {
23688 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23689 };
23690
23691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23692 ecode1 = SWIG_AsVal_int(obj0, &val1);
23693 if (!SWIG_IsOK(ecode1)) {
23694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23695 }
23696 arg1 = static_cast< int >(val1);
23697 if (obj1) {
23698 ecode2 = SWIG_AsVal_int(obj1, &val2);
23699 if (!SWIG_IsOK(ecode2)) {
23700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23701 }
23702 arg2 = static_cast< int >(val2);
23703 }
23704 if (obj2) {
23705 ecode3 = SWIG_AsVal_int(obj2, &val3);
23706 if (!SWIG_IsOK(ecode3)) {
23707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23708 }
23709 arg3 = static_cast< int >(val3);
23710 }
23711 if (obj3) {
23712 ecode4 = SWIG_AsVal_int(obj3, &val4);
23713 if (!SWIG_IsOK(ecode4)) {
23714 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23715 }
23716 arg4 = static_cast< int >(val4);
23717 }
23718 {
23719 PyThreadState* __tstate = wxPyBeginAllowThreads();
23720 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23721 wxPyEndAllowThreads(__tstate);
23722 if (PyErr_Occurred()) SWIG_fail;
23723 }
23724 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23725 return resultobj;
23726 fail:
23727 return NULL;
23728 }
23729
23730
23731 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23732 PyObject *resultobj = 0;
23733 int arg1 ;
23734 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23735 int arg3 = (int) wxDateTime::Inv_Year ;
23736 int arg4 = (int) 0 ;
23737 int arg5 = (int) 0 ;
23738 int arg6 = (int) 0 ;
23739 int arg7 = (int) 0 ;
23740 wxDateTime *result = 0 ;
23741 int val1 ;
23742 int ecode1 = 0 ;
23743 int val2 ;
23744 int ecode2 = 0 ;
23745 int val3 ;
23746 int ecode3 = 0 ;
23747 int val4 ;
23748 int ecode4 = 0 ;
23749 int val5 ;
23750 int ecode5 = 0 ;
23751 int val6 ;
23752 int ecode6 = 0 ;
23753 int val7 ;
23754 int ecode7 = 0 ;
23755 PyObject * obj0 = 0 ;
23756 PyObject * obj1 = 0 ;
23757 PyObject * obj2 = 0 ;
23758 PyObject * obj3 = 0 ;
23759 PyObject * obj4 = 0 ;
23760 PyObject * obj5 = 0 ;
23761 PyObject * obj6 = 0 ;
23762 char * kwnames[] = {
23763 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23764 };
23765
23766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23767 ecode1 = SWIG_AsVal_int(obj0, &val1);
23768 if (!SWIG_IsOK(ecode1)) {
23769 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23770 }
23771 arg1 = static_cast< int >(val1);
23772 if (obj1) {
23773 ecode2 = SWIG_AsVal_int(obj1, &val2);
23774 if (!SWIG_IsOK(ecode2)) {
23775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23776 }
23777 arg2 = static_cast< wxDateTime::Month >(val2);
23778 }
23779 if (obj2) {
23780 ecode3 = SWIG_AsVal_int(obj2, &val3);
23781 if (!SWIG_IsOK(ecode3)) {
23782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
23783 }
23784 arg3 = static_cast< int >(val3);
23785 }
23786 if (obj3) {
23787 ecode4 = SWIG_AsVal_int(obj3, &val4);
23788 if (!SWIG_IsOK(ecode4)) {
23789 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
23790 }
23791 arg4 = static_cast< int >(val4);
23792 }
23793 if (obj4) {
23794 ecode5 = SWIG_AsVal_int(obj4, &val5);
23795 if (!SWIG_IsOK(ecode5)) {
23796 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
23797 }
23798 arg5 = static_cast< int >(val5);
23799 }
23800 if (obj5) {
23801 ecode6 = SWIG_AsVal_int(obj5, &val6);
23802 if (!SWIG_IsOK(ecode6)) {
23803 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
23804 }
23805 arg6 = static_cast< int >(val6);
23806 }
23807 if (obj6) {
23808 ecode7 = SWIG_AsVal_int(obj6, &val7);
23809 if (!SWIG_IsOK(ecode7)) {
23810 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
23811 }
23812 arg7 = static_cast< int >(val7);
23813 }
23814 {
23815 PyThreadState* __tstate = wxPyBeginAllowThreads();
23816 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
23817 wxPyEndAllowThreads(__tstate);
23818 if (PyErr_Occurred()) SWIG_fail;
23819 }
23820 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23821 return resultobj;
23822 fail:
23823 return NULL;
23824 }
23825
23826
23827 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23828 PyObject *resultobj = 0;
23829 wxDateTime *arg1 = 0 ;
23830 wxDateTime *result = 0 ;
23831 void *argp1 = 0 ;
23832 int res1 = 0 ;
23833 PyObject * obj0 = 0 ;
23834 char * kwnames[] = {
23835 (char *) "date", NULL
23836 };
23837
23838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
23839 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
23840 if (!SWIG_IsOK(res1)) {
23841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23842 }
23843 if (!argp1) {
23844 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23845 }
23846 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23847 {
23848 PyThreadState* __tstate = wxPyBeginAllowThreads();
23849 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
23850 wxPyEndAllowThreads(__tstate);
23851 if (PyErr_Occurred()) SWIG_fail;
23852 }
23853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23854 return resultobj;
23855 fail:
23856 return NULL;
23857 }
23858
23859
23860 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23861 PyObject *resultobj = 0;
23862 wxDateTime *arg1 = (wxDateTime *) 0 ;
23863 void *argp1 = 0 ;
23864 int res1 = 0 ;
23865 PyObject *swig_obj[1] ;
23866
23867 if (!args) SWIG_fail;
23868 swig_obj[0] = args;
23869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
23870 if (!SWIG_IsOK(res1)) {
23871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23872 }
23873 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23874 {
23875 PyThreadState* __tstate = wxPyBeginAllowThreads();
23876 delete arg1;
23877
23878 wxPyEndAllowThreads(__tstate);
23879 if (PyErr_Occurred()) SWIG_fail;
23880 }
23881 resultobj = SWIG_Py_Void();
23882 return resultobj;
23883 fail:
23884 return NULL;
23885 }
23886
23887
23888 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23889 PyObject *resultobj = 0;
23890 wxDateTime *arg1 = (wxDateTime *) 0 ;
23891 wxDateTime *result = 0 ;
23892 void *argp1 = 0 ;
23893 int res1 = 0 ;
23894 PyObject *swig_obj[1] ;
23895
23896 if (!args) SWIG_fail;
23897 swig_obj[0] = args;
23898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23899 if (!SWIG_IsOK(res1)) {
23900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
23901 }
23902 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23903 {
23904 PyThreadState* __tstate = wxPyBeginAllowThreads();
23905 {
23906 wxDateTime &_result_ref = (arg1)->SetToCurrent();
23907 result = (wxDateTime *) &_result_ref;
23908 }
23909 wxPyEndAllowThreads(__tstate);
23910 if (PyErr_Occurred()) SWIG_fail;
23911 }
23912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23913 return resultobj;
23914 fail:
23915 return NULL;
23916 }
23917
23918
23919 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23920 PyObject *resultobj = 0;
23921 wxDateTime *arg1 = (wxDateTime *) 0 ;
23922 time_t arg2 ;
23923 wxDateTime *result = 0 ;
23924 void *argp1 = 0 ;
23925 int res1 = 0 ;
23926 unsigned int val2 ;
23927 int ecode2 = 0 ;
23928 PyObject * obj0 = 0 ;
23929 PyObject * obj1 = 0 ;
23930 char * kwnames[] = {
23931 (char *) "self",(char *) "timet", NULL
23932 };
23933
23934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
23935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23936 if (!SWIG_IsOK(res1)) {
23937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
23938 }
23939 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23940 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
23941 if (!SWIG_IsOK(ecode2)) {
23942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
23943 }
23944 arg2 = static_cast< time_t >(val2);
23945 {
23946 PyThreadState* __tstate = wxPyBeginAllowThreads();
23947 {
23948 wxDateTime &_result_ref = (arg1)->Set(arg2);
23949 result = (wxDateTime *) &_result_ref;
23950 }
23951 wxPyEndAllowThreads(__tstate);
23952 if (PyErr_Occurred()) SWIG_fail;
23953 }
23954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23955 return resultobj;
23956 fail:
23957 return NULL;
23958 }
23959
23960
23961 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23962 PyObject *resultobj = 0;
23963 wxDateTime *arg1 = (wxDateTime *) 0 ;
23964 double arg2 ;
23965 wxDateTime *result = 0 ;
23966 void *argp1 = 0 ;
23967 int res1 = 0 ;
23968 double val2 ;
23969 int ecode2 = 0 ;
23970 PyObject * obj0 = 0 ;
23971 PyObject * obj1 = 0 ;
23972 char * kwnames[] = {
23973 (char *) "self",(char *) "jdn", NULL
23974 };
23975
23976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
23977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23978 if (!SWIG_IsOK(res1)) {
23979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
23980 }
23981 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23982 ecode2 = SWIG_AsVal_double(obj1, &val2);
23983 if (!SWIG_IsOK(ecode2)) {
23984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
23985 }
23986 arg2 = static_cast< double >(val2);
23987 {
23988 PyThreadState* __tstate = wxPyBeginAllowThreads();
23989 {
23990 wxDateTime &_result_ref = (arg1)->Set(arg2);
23991 result = (wxDateTime *) &_result_ref;
23992 }
23993 wxPyEndAllowThreads(__tstate);
23994 if (PyErr_Occurred()) SWIG_fail;
23995 }
23996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23997 return resultobj;
23998 fail:
23999 return NULL;
24000 }
24001
24002
24003 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24004 PyObject *resultobj = 0;
24005 wxDateTime *arg1 = (wxDateTime *) 0 ;
24006 int arg2 ;
24007 int arg3 = (int) 0 ;
24008 int arg4 = (int) 0 ;
24009 int arg5 = (int) 0 ;
24010 wxDateTime *result = 0 ;
24011 void *argp1 = 0 ;
24012 int res1 = 0 ;
24013 int val2 ;
24014 int ecode2 = 0 ;
24015 int val3 ;
24016 int ecode3 = 0 ;
24017 int val4 ;
24018 int ecode4 = 0 ;
24019 int val5 ;
24020 int ecode5 = 0 ;
24021 PyObject * obj0 = 0 ;
24022 PyObject * obj1 = 0 ;
24023 PyObject * obj2 = 0 ;
24024 PyObject * obj3 = 0 ;
24025 PyObject * obj4 = 0 ;
24026 char * kwnames[] = {
24027 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24028 };
24029
24030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24032 if (!SWIG_IsOK(res1)) {
24033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24034 }
24035 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24036 ecode2 = SWIG_AsVal_int(obj1, &val2);
24037 if (!SWIG_IsOK(ecode2)) {
24038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24039 }
24040 arg2 = static_cast< int >(val2);
24041 if (obj2) {
24042 ecode3 = SWIG_AsVal_int(obj2, &val3);
24043 if (!SWIG_IsOK(ecode3)) {
24044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24045 }
24046 arg3 = static_cast< int >(val3);
24047 }
24048 if (obj3) {
24049 ecode4 = SWIG_AsVal_int(obj3, &val4);
24050 if (!SWIG_IsOK(ecode4)) {
24051 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24052 }
24053 arg4 = static_cast< int >(val4);
24054 }
24055 if (obj4) {
24056 ecode5 = SWIG_AsVal_int(obj4, &val5);
24057 if (!SWIG_IsOK(ecode5)) {
24058 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24059 }
24060 arg5 = static_cast< int >(val5);
24061 }
24062 {
24063 PyThreadState* __tstate = wxPyBeginAllowThreads();
24064 {
24065 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24066 result = (wxDateTime *) &_result_ref;
24067 }
24068 wxPyEndAllowThreads(__tstate);
24069 if (PyErr_Occurred()) SWIG_fail;
24070 }
24071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24072 return resultobj;
24073 fail:
24074 return NULL;
24075 }
24076
24077
24078 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24079 PyObject *resultobj = 0;
24080 wxDateTime *arg1 = (wxDateTime *) 0 ;
24081 int arg2 ;
24082 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24083 int arg4 = (int) wxDateTime::Inv_Year ;
24084 int arg5 = (int) 0 ;
24085 int arg6 = (int) 0 ;
24086 int arg7 = (int) 0 ;
24087 int arg8 = (int) 0 ;
24088 wxDateTime *result = 0 ;
24089 void *argp1 = 0 ;
24090 int res1 = 0 ;
24091 int val2 ;
24092 int ecode2 = 0 ;
24093 int val3 ;
24094 int ecode3 = 0 ;
24095 int val4 ;
24096 int ecode4 = 0 ;
24097 int val5 ;
24098 int ecode5 = 0 ;
24099 int val6 ;
24100 int ecode6 = 0 ;
24101 int val7 ;
24102 int ecode7 = 0 ;
24103 int val8 ;
24104 int ecode8 = 0 ;
24105 PyObject * obj0 = 0 ;
24106 PyObject * obj1 = 0 ;
24107 PyObject * obj2 = 0 ;
24108 PyObject * obj3 = 0 ;
24109 PyObject * obj4 = 0 ;
24110 PyObject * obj5 = 0 ;
24111 PyObject * obj6 = 0 ;
24112 PyObject * obj7 = 0 ;
24113 char * kwnames[] = {
24114 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24115 };
24116
24117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24119 if (!SWIG_IsOK(res1)) {
24120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24121 }
24122 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24123 ecode2 = SWIG_AsVal_int(obj1, &val2);
24124 if (!SWIG_IsOK(ecode2)) {
24125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24126 }
24127 arg2 = static_cast< int >(val2);
24128 if (obj2) {
24129 ecode3 = SWIG_AsVal_int(obj2, &val3);
24130 if (!SWIG_IsOK(ecode3)) {
24131 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24132 }
24133 arg3 = static_cast< wxDateTime::Month >(val3);
24134 }
24135 if (obj3) {
24136 ecode4 = SWIG_AsVal_int(obj3, &val4);
24137 if (!SWIG_IsOK(ecode4)) {
24138 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24139 }
24140 arg4 = static_cast< int >(val4);
24141 }
24142 if (obj4) {
24143 ecode5 = SWIG_AsVal_int(obj4, &val5);
24144 if (!SWIG_IsOK(ecode5)) {
24145 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24146 }
24147 arg5 = static_cast< int >(val5);
24148 }
24149 if (obj5) {
24150 ecode6 = SWIG_AsVal_int(obj5, &val6);
24151 if (!SWIG_IsOK(ecode6)) {
24152 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24153 }
24154 arg6 = static_cast< int >(val6);
24155 }
24156 if (obj6) {
24157 ecode7 = SWIG_AsVal_int(obj6, &val7);
24158 if (!SWIG_IsOK(ecode7)) {
24159 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24160 }
24161 arg7 = static_cast< int >(val7);
24162 }
24163 if (obj7) {
24164 ecode8 = SWIG_AsVal_int(obj7, &val8);
24165 if (!SWIG_IsOK(ecode8)) {
24166 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24167 }
24168 arg8 = static_cast< int >(val8);
24169 }
24170 {
24171 PyThreadState* __tstate = wxPyBeginAllowThreads();
24172 {
24173 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24174 result = (wxDateTime *) &_result_ref;
24175 }
24176 wxPyEndAllowThreads(__tstate);
24177 if (PyErr_Occurred()) SWIG_fail;
24178 }
24179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24180 return resultobj;
24181 fail:
24182 return NULL;
24183 }
24184
24185
24186 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24187 PyObject *resultobj = 0;
24188 wxDateTime *arg1 = (wxDateTime *) 0 ;
24189 wxDateTime *result = 0 ;
24190 void *argp1 = 0 ;
24191 int res1 = 0 ;
24192 PyObject *swig_obj[1] ;
24193
24194 if (!args) SWIG_fail;
24195 swig_obj[0] = args;
24196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24197 if (!SWIG_IsOK(res1)) {
24198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24199 }
24200 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24201 {
24202 PyThreadState* __tstate = wxPyBeginAllowThreads();
24203 {
24204 wxDateTime &_result_ref = (arg1)->ResetTime();
24205 result = (wxDateTime *) &_result_ref;
24206 }
24207 wxPyEndAllowThreads(__tstate);
24208 if (PyErr_Occurred()) SWIG_fail;
24209 }
24210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24211 return resultobj;
24212 fail:
24213 return NULL;
24214 }
24215
24216
24217 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24218 PyObject *resultobj = 0;
24219 wxDateTime *arg1 = (wxDateTime *) 0 ;
24220 int arg2 ;
24221 wxDateTime *result = 0 ;
24222 void *argp1 = 0 ;
24223 int res1 = 0 ;
24224 int val2 ;
24225 int ecode2 = 0 ;
24226 PyObject * obj0 = 0 ;
24227 PyObject * obj1 = 0 ;
24228 char * kwnames[] = {
24229 (char *) "self",(char *) "year", NULL
24230 };
24231
24232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24234 if (!SWIG_IsOK(res1)) {
24235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24236 }
24237 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24238 ecode2 = SWIG_AsVal_int(obj1, &val2);
24239 if (!SWIG_IsOK(ecode2)) {
24240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24241 }
24242 arg2 = static_cast< int >(val2);
24243 {
24244 PyThreadState* __tstate = wxPyBeginAllowThreads();
24245 {
24246 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24247 result = (wxDateTime *) &_result_ref;
24248 }
24249 wxPyEndAllowThreads(__tstate);
24250 if (PyErr_Occurred()) SWIG_fail;
24251 }
24252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24253 return resultobj;
24254 fail:
24255 return NULL;
24256 }
24257
24258
24259 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24260 PyObject *resultobj = 0;
24261 wxDateTime *arg1 = (wxDateTime *) 0 ;
24262 wxDateTime::Month arg2 ;
24263 wxDateTime *result = 0 ;
24264 void *argp1 = 0 ;
24265 int res1 = 0 ;
24266 int val2 ;
24267 int ecode2 = 0 ;
24268 PyObject * obj0 = 0 ;
24269 PyObject * obj1 = 0 ;
24270 char * kwnames[] = {
24271 (char *) "self",(char *) "month", NULL
24272 };
24273
24274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24276 if (!SWIG_IsOK(res1)) {
24277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24278 }
24279 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24280 ecode2 = SWIG_AsVal_int(obj1, &val2);
24281 if (!SWIG_IsOK(ecode2)) {
24282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24283 }
24284 arg2 = static_cast< wxDateTime::Month >(val2);
24285 {
24286 PyThreadState* __tstate = wxPyBeginAllowThreads();
24287 {
24288 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24289 result = (wxDateTime *) &_result_ref;
24290 }
24291 wxPyEndAllowThreads(__tstate);
24292 if (PyErr_Occurred()) SWIG_fail;
24293 }
24294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24295 return resultobj;
24296 fail:
24297 return NULL;
24298 }
24299
24300
24301 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24302 PyObject *resultobj = 0;
24303 wxDateTime *arg1 = (wxDateTime *) 0 ;
24304 int arg2 ;
24305 wxDateTime *result = 0 ;
24306 void *argp1 = 0 ;
24307 int res1 = 0 ;
24308 int val2 ;
24309 int ecode2 = 0 ;
24310 PyObject * obj0 = 0 ;
24311 PyObject * obj1 = 0 ;
24312 char * kwnames[] = {
24313 (char *) "self",(char *) "day", NULL
24314 };
24315
24316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24318 if (!SWIG_IsOK(res1)) {
24319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24320 }
24321 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24322 ecode2 = SWIG_AsVal_int(obj1, &val2);
24323 if (!SWIG_IsOK(ecode2)) {
24324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24325 }
24326 arg2 = static_cast< int >(val2);
24327 {
24328 PyThreadState* __tstate = wxPyBeginAllowThreads();
24329 {
24330 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24331 result = (wxDateTime *) &_result_ref;
24332 }
24333 wxPyEndAllowThreads(__tstate);
24334 if (PyErr_Occurred()) SWIG_fail;
24335 }
24336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24337 return resultobj;
24338 fail:
24339 return NULL;
24340 }
24341
24342
24343 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24344 PyObject *resultobj = 0;
24345 wxDateTime *arg1 = (wxDateTime *) 0 ;
24346 int arg2 ;
24347 wxDateTime *result = 0 ;
24348 void *argp1 = 0 ;
24349 int res1 = 0 ;
24350 int val2 ;
24351 int ecode2 = 0 ;
24352 PyObject * obj0 = 0 ;
24353 PyObject * obj1 = 0 ;
24354 char * kwnames[] = {
24355 (char *) "self",(char *) "hour", NULL
24356 };
24357
24358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24360 if (!SWIG_IsOK(res1)) {
24361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24362 }
24363 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24364 ecode2 = SWIG_AsVal_int(obj1, &val2);
24365 if (!SWIG_IsOK(ecode2)) {
24366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24367 }
24368 arg2 = static_cast< int >(val2);
24369 {
24370 PyThreadState* __tstate = wxPyBeginAllowThreads();
24371 {
24372 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24373 result = (wxDateTime *) &_result_ref;
24374 }
24375 wxPyEndAllowThreads(__tstate);
24376 if (PyErr_Occurred()) SWIG_fail;
24377 }
24378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24379 return resultobj;
24380 fail:
24381 return NULL;
24382 }
24383
24384
24385 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24386 PyObject *resultobj = 0;
24387 wxDateTime *arg1 = (wxDateTime *) 0 ;
24388 int arg2 ;
24389 wxDateTime *result = 0 ;
24390 void *argp1 = 0 ;
24391 int res1 = 0 ;
24392 int val2 ;
24393 int ecode2 = 0 ;
24394 PyObject * obj0 = 0 ;
24395 PyObject * obj1 = 0 ;
24396 char * kwnames[] = {
24397 (char *) "self",(char *) "minute", NULL
24398 };
24399
24400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24402 if (!SWIG_IsOK(res1)) {
24403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24404 }
24405 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24406 ecode2 = SWIG_AsVal_int(obj1, &val2);
24407 if (!SWIG_IsOK(ecode2)) {
24408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24409 }
24410 arg2 = static_cast< int >(val2);
24411 {
24412 PyThreadState* __tstate = wxPyBeginAllowThreads();
24413 {
24414 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24415 result = (wxDateTime *) &_result_ref;
24416 }
24417 wxPyEndAllowThreads(__tstate);
24418 if (PyErr_Occurred()) SWIG_fail;
24419 }
24420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24421 return resultobj;
24422 fail:
24423 return NULL;
24424 }
24425
24426
24427 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24428 PyObject *resultobj = 0;
24429 wxDateTime *arg1 = (wxDateTime *) 0 ;
24430 int arg2 ;
24431 wxDateTime *result = 0 ;
24432 void *argp1 = 0 ;
24433 int res1 = 0 ;
24434 int val2 ;
24435 int ecode2 = 0 ;
24436 PyObject * obj0 = 0 ;
24437 PyObject * obj1 = 0 ;
24438 char * kwnames[] = {
24439 (char *) "self",(char *) "second", NULL
24440 };
24441
24442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24444 if (!SWIG_IsOK(res1)) {
24445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24446 }
24447 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24448 ecode2 = SWIG_AsVal_int(obj1, &val2);
24449 if (!SWIG_IsOK(ecode2)) {
24450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24451 }
24452 arg2 = static_cast< int >(val2);
24453 {
24454 PyThreadState* __tstate = wxPyBeginAllowThreads();
24455 {
24456 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24457 result = (wxDateTime *) &_result_ref;
24458 }
24459 wxPyEndAllowThreads(__tstate);
24460 if (PyErr_Occurred()) SWIG_fail;
24461 }
24462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24463 return resultobj;
24464 fail:
24465 return NULL;
24466 }
24467
24468
24469 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24470 PyObject *resultobj = 0;
24471 wxDateTime *arg1 = (wxDateTime *) 0 ;
24472 int arg2 ;
24473 wxDateTime *result = 0 ;
24474 void *argp1 = 0 ;
24475 int res1 = 0 ;
24476 int val2 ;
24477 int ecode2 = 0 ;
24478 PyObject * obj0 = 0 ;
24479 PyObject * obj1 = 0 ;
24480 char * kwnames[] = {
24481 (char *) "self",(char *) "millisecond", NULL
24482 };
24483
24484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24486 if (!SWIG_IsOK(res1)) {
24487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24488 }
24489 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24490 ecode2 = SWIG_AsVal_int(obj1, &val2);
24491 if (!SWIG_IsOK(ecode2)) {
24492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24493 }
24494 arg2 = static_cast< int >(val2);
24495 {
24496 PyThreadState* __tstate = wxPyBeginAllowThreads();
24497 {
24498 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24499 result = (wxDateTime *) &_result_ref;
24500 }
24501 wxPyEndAllowThreads(__tstate);
24502 if (PyErr_Occurred()) SWIG_fail;
24503 }
24504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24505 return resultobj;
24506 fail:
24507 return NULL;
24508 }
24509
24510
24511 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24512 PyObject *resultobj = 0;
24513 wxDateTime *arg1 = (wxDateTime *) 0 ;
24514 wxDateTime::WeekDay arg2 ;
24515 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24516 wxDateTime *result = 0 ;
24517 void *argp1 = 0 ;
24518 int res1 = 0 ;
24519 int val2 ;
24520 int ecode2 = 0 ;
24521 int val3 ;
24522 int ecode3 = 0 ;
24523 PyObject * obj0 = 0 ;
24524 PyObject * obj1 = 0 ;
24525 PyObject * obj2 = 0 ;
24526 char * kwnames[] = {
24527 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24528 };
24529
24530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24532 if (!SWIG_IsOK(res1)) {
24533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24534 }
24535 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24536 ecode2 = SWIG_AsVal_int(obj1, &val2);
24537 if (!SWIG_IsOK(ecode2)) {
24538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24539 }
24540 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24541 if (obj2) {
24542 ecode3 = SWIG_AsVal_int(obj2, &val3);
24543 if (!SWIG_IsOK(ecode3)) {
24544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24545 }
24546 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24547 }
24548 {
24549 PyThreadState* __tstate = wxPyBeginAllowThreads();
24550 {
24551 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24552 result = (wxDateTime *) &_result_ref;
24553 }
24554 wxPyEndAllowThreads(__tstate);
24555 if (PyErr_Occurred()) SWIG_fail;
24556 }
24557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24558 return resultobj;
24559 fail:
24560 return NULL;
24561 }
24562
24563
24564 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24565 PyObject *resultobj = 0;
24566 wxDateTime *arg1 = (wxDateTime *) 0 ;
24567 wxDateTime::WeekDay arg2 ;
24568 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24569 wxDateTime result;
24570 void *argp1 = 0 ;
24571 int res1 = 0 ;
24572 int val2 ;
24573 int ecode2 = 0 ;
24574 int val3 ;
24575 int ecode3 = 0 ;
24576 PyObject * obj0 = 0 ;
24577 PyObject * obj1 = 0 ;
24578 PyObject * obj2 = 0 ;
24579 char * kwnames[] = {
24580 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24581 };
24582
24583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24585 if (!SWIG_IsOK(res1)) {
24586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24587 }
24588 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24589 ecode2 = SWIG_AsVal_int(obj1, &val2);
24590 if (!SWIG_IsOK(ecode2)) {
24591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24592 }
24593 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24594 if (obj2) {
24595 ecode3 = SWIG_AsVal_int(obj2, &val3);
24596 if (!SWIG_IsOK(ecode3)) {
24597 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24598 }
24599 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24600 }
24601 {
24602 PyThreadState* __tstate = wxPyBeginAllowThreads();
24603 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24604 wxPyEndAllowThreads(__tstate);
24605 if (PyErr_Occurred()) SWIG_fail;
24606 }
24607 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24608 return resultobj;
24609 fail:
24610 return NULL;
24611 }
24612
24613
24614 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24615 PyObject *resultobj = 0;
24616 wxDateTime *arg1 = (wxDateTime *) 0 ;
24617 wxDateTime::WeekDay arg2 ;
24618 wxDateTime *result = 0 ;
24619 void *argp1 = 0 ;
24620 int res1 = 0 ;
24621 int val2 ;
24622 int ecode2 = 0 ;
24623 PyObject * obj0 = 0 ;
24624 PyObject * obj1 = 0 ;
24625 char * kwnames[] = {
24626 (char *) "self",(char *) "weekday", NULL
24627 };
24628
24629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24631 if (!SWIG_IsOK(res1)) {
24632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24633 }
24634 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24635 ecode2 = SWIG_AsVal_int(obj1, &val2);
24636 if (!SWIG_IsOK(ecode2)) {
24637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24638 }
24639 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24640 {
24641 PyThreadState* __tstate = wxPyBeginAllowThreads();
24642 {
24643 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24644 result = (wxDateTime *) &_result_ref;
24645 }
24646 wxPyEndAllowThreads(__tstate);
24647 if (PyErr_Occurred()) SWIG_fail;
24648 }
24649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24650 return resultobj;
24651 fail:
24652 return NULL;
24653 }
24654
24655
24656 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24657 PyObject *resultobj = 0;
24658 wxDateTime *arg1 = (wxDateTime *) 0 ;
24659 wxDateTime::WeekDay arg2 ;
24660 wxDateTime result;
24661 void *argp1 = 0 ;
24662 int res1 = 0 ;
24663 int val2 ;
24664 int ecode2 = 0 ;
24665 PyObject * obj0 = 0 ;
24666 PyObject * obj1 = 0 ;
24667 char * kwnames[] = {
24668 (char *) "self",(char *) "weekday", NULL
24669 };
24670
24671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24673 if (!SWIG_IsOK(res1)) {
24674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24675 }
24676 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24677 ecode2 = SWIG_AsVal_int(obj1, &val2);
24678 if (!SWIG_IsOK(ecode2)) {
24679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24680 }
24681 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24682 {
24683 PyThreadState* __tstate = wxPyBeginAllowThreads();
24684 result = (arg1)->GetNextWeekDay(arg2);
24685 wxPyEndAllowThreads(__tstate);
24686 if (PyErr_Occurred()) SWIG_fail;
24687 }
24688 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24689 return resultobj;
24690 fail:
24691 return NULL;
24692 }
24693
24694
24695 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24696 PyObject *resultobj = 0;
24697 wxDateTime *arg1 = (wxDateTime *) 0 ;
24698 wxDateTime::WeekDay arg2 ;
24699 wxDateTime *result = 0 ;
24700 void *argp1 = 0 ;
24701 int res1 = 0 ;
24702 int val2 ;
24703 int ecode2 = 0 ;
24704 PyObject * obj0 = 0 ;
24705 PyObject * obj1 = 0 ;
24706 char * kwnames[] = {
24707 (char *) "self",(char *) "weekday", NULL
24708 };
24709
24710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24712 if (!SWIG_IsOK(res1)) {
24713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24714 }
24715 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24716 ecode2 = SWIG_AsVal_int(obj1, &val2);
24717 if (!SWIG_IsOK(ecode2)) {
24718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24719 }
24720 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24721 {
24722 PyThreadState* __tstate = wxPyBeginAllowThreads();
24723 {
24724 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24725 result = (wxDateTime *) &_result_ref;
24726 }
24727 wxPyEndAllowThreads(__tstate);
24728 if (PyErr_Occurred()) SWIG_fail;
24729 }
24730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24731 return resultobj;
24732 fail:
24733 return NULL;
24734 }
24735
24736
24737 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24738 PyObject *resultobj = 0;
24739 wxDateTime *arg1 = (wxDateTime *) 0 ;
24740 wxDateTime::WeekDay arg2 ;
24741 wxDateTime result;
24742 void *argp1 = 0 ;
24743 int res1 = 0 ;
24744 int val2 ;
24745 int ecode2 = 0 ;
24746 PyObject * obj0 = 0 ;
24747 PyObject * obj1 = 0 ;
24748 char * kwnames[] = {
24749 (char *) "self",(char *) "weekday", NULL
24750 };
24751
24752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24754 if (!SWIG_IsOK(res1)) {
24755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24756 }
24757 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24758 ecode2 = SWIG_AsVal_int(obj1, &val2);
24759 if (!SWIG_IsOK(ecode2)) {
24760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24761 }
24762 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24763 {
24764 PyThreadState* __tstate = wxPyBeginAllowThreads();
24765 result = (arg1)->GetPrevWeekDay(arg2);
24766 wxPyEndAllowThreads(__tstate);
24767 if (PyErr_Occurred()) SWIG_fail;
24768 }
24769 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24770 return resultobj;
24771 fail:
24772 return NULL;
24773 }
24774
24775
24776 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24777 PyObject *resultobj = 0;
24778 wxDateTime *arg1 = (wxDateTime *) 0 ;
24779 wxDateTime::WeekDay arg2 ;
24780 int arg3 = (int) 1 ;
24781 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24782 int arg5 = (int) wxDateTime::Inv_Year ;
24783 bool result;
24784 void *argp1 = 0 ;
24785 int res1 = 0 ;
24786 int val2 ;
24787 int ecode2 = 0 ;
24788 int val3 ;
24789 int ecode3 = 0 ;
24790 int val4 ;
24791 int ecode4 = 0 ;
24792 int val5 ;
24793 int ecode5 = 0 ;
24794 PyObject * obj0 = 0 ;
24795 PyObject * obj1 = 0 ;
24796 PyObject * obj2 = 0 ;
24797 PyObject * obj3 = 0 ;
24798 PyObject * obj4 = 0 ;
24799 char * kwnames[] = {
24800 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
24801 };
24802
24803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24805 if (!SWIG_IsOK(res1)) {
24806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24807 }
24808 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24809 ecode2 = SWIG_AsVal_int(obj1, &val2);
24810 if (!SWIG_IsOK(ecode2)) {
24811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24812 }
24813 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24814 if (obj2) {
24815 ecode3 = SWIG_AsVal_int(obj2, &val3);
24816 if (!SWIG_IsOK(ecode3)) {
24817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
24818 }
24819 arg3 = static_cast< int >(val3);
24820 }
24821 if (obj3) {
24822 ecode4 = SWIG_AsVal_int(obj3, &val4);
24823 if (!SWIG_IsOK(ecode4)) {
24824 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
24825 }
24826 arg4 = static_cast< wxDateTime::Month >(val4);
24827 }
24828 if (obj4) {
24829 ecode5 = SWIG_AsVal_int(obj4, &val5);
24830 if (!SWIG_IsOK(ecode5)) {
24831 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
24832 }
24833 arg5 = static_cast< int >(val5);
24834 }
24835 {
24836 PyThreadState* __tstate = wxPyBeginAllowThreads();
24837 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
24838 wxPyEndAllowThreads(__tstate);
24839 if (PyErr_Occurred()) SWIG_fail;
24840 }
24841 {
24842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24843 }
24844 return resultobj;
24845 fail:
24846 return NULL;
24847 }
24848
24849
24850 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24851 PyObject *resultobj = 0;
24852 wxDateTime *arg1 = (wxDateTime *) 0 ;
24853 wxDateTime::WeekDay arg2 ;
24854 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24855 int arg4 = (int) wxDateTime::Inv_Year ;
24856 bool result;
24857 void *argp1 = 0 ;
24858 int res1 = 0 ;
24859 int val2 ;
24860 int ecode2 = 0 ;
24861 int val3 ;
24862 int ecode3 = 0 ;
24863 int val4 ;
24864 int ecode4 = 0 ;
24865 PyObject * obj0 = 0 ;
24866 PyObject * obj1 = 0 ;
24867 PyObject * obj2 = 0 ;
24868 PyObject * obj3 = 0 ;
24869 char * kwnames[] = {
24870 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
24871 };
24872
24873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24875 if (!SWIG_IsOK(res1)) {
24876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24877 }
24878 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24879 ecode2 = SWIG_AsVal_int(obj1, &val2);
24880 if (!SWIG_IsOK(ecode2)) {
24881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24882 }
24883 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24884 if (obj2) {
24885 ecode3 = SWIG_AsVal_int(obj2, &val3);
24886 if (!SWIG_IsOK(ecode3)) {
24887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24888 }
24889 arg3 = static_cast< wxDateTime::Month >(val3);
24890 }
24891 if (obj3) {
24892 ecode4 = SWIG_AsVal_int(obj3, &val4);
24893 if (!SWIG_IsOK(ecode4)) {
24894 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
24895 }
24896 arg4 = static_cast< int >(val4);
24897 }
24898 {
24899 PyThreadState* __tstate = wxPyBeginAllowThreads();
24900 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
24901 wxPyEndAllowThreads(__tstate);
24902 if (PyErr_Occurred()) SWIG_fail;
24903 }
24904 {
24905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24906 }
24907 return resultobj;
24908 fail:
24909 return NULL;
24910 }
24911
24912
24913 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24914 PyObject *resultobj = 0;
24915 wxDateTime *arg1 = (wxDateTime *) 0 ;
24916 wxDateTime::WeekDay arg2 ;
24917 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24918 int arg4 = (int) wxDateTime::Inv_Year ;
24919 wxDateTime result;
24920 void *argp1 = 0 ;
24921 int res1 = 0 ;
24922 int val2 ;
24923 int ecode2 = 0 ;
24924 int val3 ;
24925 int ecode3 = 0 ;
24926 int val4 ;
24927 int ecode4 = 0 ;
24928 PyObject * obj0 = 0 ;
24929 PyObject * obj1 = 0 ;
24930 PyObject * obj2 = 0 ;
24931 PyObject * obj3 = 0 ;
24932 char * kwnames[] = {
24933 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
24934 };
24935
24936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24938 if (!SWIG_IsOK(res1)) {
24939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24940 }
24941 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24942 ecode2 = SWIG_AsVal_int(obj1, &val2);
24943 if (!SWIG_IsOK(ecode2)) {
24944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24945 }
24946 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24947 if (obj2) {
24948 ecode3 = SWIG_AsVal_int(obj2, &val3);
24949 if (!SWIG_IsOK(ecode3)) {
24950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24951 }
24952 arg3 = static_cast< wxDateTime::Month >(val3);
24953 }
24954 if (obj3) {
24955 ecode4 = SWIG_AsVal_int(obj3, &val4);
24956 if (!SWIG_IsOK(ecode4)) {
24957 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
24958 }
24959 arg4 = static_cast< int >(val4);
24960 }
24961 {
24962 PyThreadState* __tstate = wxPyBeginAllowThreads();
24963 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
24964 wxPyEndAllowThreads(__tstate);
24965 if (PyErr_Occurred()) SWIG_fail;
24966 }
24967 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24968 return resultobj;
24969 fail:
24970 return NULL;
24971 }
24972
24973
24974 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24975 PyObject *resultobj = 0;
24976 wxDateTime *arg1 = (wxDateTime *) 0 ;
24977 int arg2 ;
24978 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24979 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24980 bool result;
24981 void *argp1 = 0 ;
24982 int res1 = 0 ;
24983 int val2 ;
24984 int ecode2 = 0 ;
24985 int val3 ;
24986 int ecode3 = 0 ;
24987 int val4 ;
24988 int ecode4 = 0 ;
24989 PyObject * obj0 = 0 ;
24990 PyObject * obj1 = 0 ;
24991 PyObject * obj2 = 0 ;
24992 PyObject * obj3 = 0 ;
24993 char * kwnames[] = {
24994 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24995 };
24996
24997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24999 if (!SWIG_IsOK(res1)) {
25000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25001 }
25002 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25003 ecode2 = SWIG_AsVal_int(obj1, &val2);
25004 if (!SWIG_IsOK(ecode2)) {
25005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25006 }
25007 arg2 = static_cast< int >(val2);
25008 if (obj2) {
25009 ecode3 = SWIG_AsVal_int(obj2, &val3);
25010 if (!SWIG_IsOK(ecode3)) {
25011 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25012 }
25013 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25014 }
25015 if (obj3) {
25016 ecode4 = SWIG_AsVal_int(obj3, &val4);
25017 if (!SWIG_IsOK(ecode4)) {
25018 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25019 }
25020 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25021 }
25022 {
25023 PyThreadState* __tstate = wxPyBeginAllowThreads();
25024 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25025 wxPyEndAllowThreads(__tstate);
25026 if (PyErr_Occurred()) SWIG_fail;
25027 }
25028 {
25029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25030 }
25031 return resultobj;
25032 fail:
25033 return NULL;
25034 }
25035
25036
25037 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25038 PyObject *resultobj = 0;
25039 wxDateTime *arg1 = (wxDateTime *) 0 ;
25040 int arg2 ;
25041 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25042 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25043 wxDateTime result;
25044 void *argp1 = 0 ;
25045 int res1 = 0 ;
25046 int val2 ;
25047 int ecode2 = 0 ;
25048 int val3 ;
25049 int ecode3 = 0 ;
25050 int val4 ;
25051 int ecode4 = 0 ;
25052 PyObject * obj0 = 0 ;
25053 PyObject * obj1 = 0 ;
25054 PyObject * obj2 = 0 ;
25055 PyObject * obj3 = 0 ;
25056 char * kwnames[] = {
25057 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25058 };
25059
25060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25062 if (!SWIG_IsOK(res1)) {
25063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25064 }
25065 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25066 ecode2 = SWIG_AsVal_int(obj1, &val2);
25067 if (!SWIG_IsOK(ecode2)) {
25068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25069 }
25070 arg2 = static_cast< int >(val2);
25071 if (obj2) {
25072 ecode3 = SWIG_AsVal_int(obj2, &val3);
25073 if (!SWIG_IsOK(ecode3)) {
25074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25075 }
25076 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25077 }
25078 if (obj3) {
25079 ecode4 = SWIG_AsVal_int(obj3, &val4);
25080 if (!SWIG_IsOK(ecode4)) {
25081 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25082 }
25083 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25084 }
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 result = (arg1)->GetWeek(arg2,arg3,arg4);
25088 wxPyEndAllowThreads(__tstate);
25089 if (PyErr_Occurred()) SWIG_fail;
25090 }
25091 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25092 return resultobj;
25093 fail:
25094 return NULL;
25095 }
25096
25097
25098 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25099 PyObject *resultobj = 0;
25100 int arg1 ;
25101 int arg2 ;
25102 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25103 wxDateTime result;
25104 int val1 ;
25105 int ecode1 = 0 ;
25106 int val2 ;
25107 int ecode2 = 0 ;
25108 int val3 ;
25109 int ecode3 = 0 ;
25110 PyObject * obj0 = 0 ;
25111 PyObject * obj1 = 0 ;
25112 PyObject * obj2 = 0 ;
25113 char * kwnames[] = {
25114 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25115 };
25116
25117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25118 ecode1 = SWIG_AsVal_int(obj0, &val1);
25119 if (!SWIG_IsOK(ecode1)) {
25120 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25121 }
25122 arg1 = static_cast< int >(val1);
25123 ecode2 = SWIG_AsVal_int(obj1, &val2);
25124 if (!SWIG_IsOK(ecode2)) {
25125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25126 }
25127 arg2 = static_cast< int >(val2);
25128 if (obj2) {
25129 ecode3 = SWIG_AsVal_int(obj2, &val3);
25130 if (!SWIG_IsOK(ecode3)) {
25131 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25132 }
25133 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25134 }
25135 {
25136 PyThreadState* __tstate = wxPyBeginAllowThreads();
25137 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25138 wxPyEndAllowThreads(__tstate);
25139 if (PyErr_Occurred()) SWIG_fail;
25140 }
25141 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25142 return resultobj;
25143 fail:
25144 return NULL;
25145 }
25146
25147
25148 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25149 PyObject *resultobj = 0;
25150 wxDateTime *arg1 = (wxDateTime *) 0 ;
25151 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25152 int arg3 = (int) wxDateTime::Inv_Year ;
25153 wxDateTime *result = 0 ;
25154 void *argp1 = 0 ;
25155 int res1 = 0 ;
25156 int val2 ;
25157 int ecode2 = 0 ;
25158 int val3 ;
25159 int ecode3 = 0 ;
25160 PyObject * obj0 = 0 ;
25161 PyObject * obj1 = 0 ;
25162 PyObject * obj2 = 0 ;
25163 char * kwnames[] = {
25164 (char *) "self",(char *) "month",(char *) "year", NULL
25165 };
25166
25167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25169 if (!SWIG_IsOK(res1)) {
25170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25171 }
25172 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25173 if (obj1) {
25174 ecode2 = SWIG_AsVal_int(obj1, &val2);
25175 if (!SWIG_IsOK(ecode2)) {
25176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25177 }
25178 arg2 = static_cast< wxDateTime::Month >(val2);
25179 }
25180 if (obj2) {
25181 ecode3 = SWIG_AsVal_int(obj2, &val3);
25182 if (!SWIG_IsOK(ecode3)) {
25183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25184 }
25185 arg3 = static_cast< int >(val3);
25186 }
25187 {
25188 PyThreadState* __tstate = wxPyBeginAllowThreads();
25189 {
25190 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25191 result = (wxDateTime *) &_result_ref;
25192 }
25193 wxPyEndAllowThreads(__tstate);
25194 if (PyErr_Occurred()) SWIG_fail;
25195 }
25196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25197 return resultobj;
25198 fail:
25199 return NULL;
25200 }
25201
25202
25203 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25204 PyObject *resultobj = 0;
25205 wxDateTime *arg1 = (wxDateTime *) 0 ;
25206 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25207 int arg3 = (int) wxDateTime::Inv_Year ;
25208 wxDateTime result;
25209 void *argp1 = 0 ;
25210 int res1 = 0 ;
25211 int val2 ;
25212 int ecode2 = 0 ;
25213 int val3 ;
25214 int ecode3 = 0 ;
25215 PyObject * obj0 = 0 ;
25216 PyObject * obj1 = 0 ;
25217 PyObject * obj2 = 0 ;
25218 char * kwnames[] = {
25219 (char *) "self",(char *) "month",(char *) "year", NULL
25220 };
25221
25222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25224 if (!SWIG_IsOK(res1)) {
25225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25226 }
25227 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25228 if (obj1) {
25229 ecode2 = SWIG_AsVal_int(obj1, &val2);
25230 if (!SWIG_IsOK(ecode2)) {
25231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25232 }
25233 arg2 = static_cast< wxDateTime::Month >(val2);
25234 }
25235 if (obj2) {
25236 ecode3 = SWIG_AsVal_int(obj2, &val3);
25237 if (!SWIG_IsOK(ecode3)) {
25238 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25239 }
25240 arg3 = static_cast< int >(val3);
25241 }
25242 {
25243 PyThreadState* __tstate = wxPyBeginAllowThreads();
25244 result = (arg1)->GetLastMonthDay(arg2,arg3);
25245 wxPyEndAllowThreads(__tstate);
25246 if (PyErr_Occurred()) SWIG_fail;
25247 }
25248 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25249 return resultobj;
25250 fail:
25251 return NULL;
25252 }
25253
25254
25255 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25256 PyObject *resultobj = 0;
25257 wxDateTime *arg1 = (wxDateTime *) 0 ;
25258 int arg2 ;
25259 wxDateTime *result = 0 ;
25260 void *argp1 = 0 ;
25261 int res1 = 0 ;
25262 int val2 ;
25263 int ecode2 = 0 ;
25264 PyObject * obj0 = 0 ;
25265 PyObject * obj1 = 0 ;
25266 char * kwnames[] = {
25267 (char *) "self",(char *) "yday", NULL
25268 };
25269
25270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25272 if (!SWIG_IsOK(res1)) {
25273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25274 }
25275 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25276 ecode2 = SWIG_AsVal_int(obj1, &val2);
25277 if (!SWIG_IsOK(ecode2)) {
25278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25279 }
25280 arg2 = static_cast< int >(val2);
25281 {
25282 PyThreadState* __tstate = wxPyBeginAllowThreads();
25283 {
25284 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25285 result = (wxDateTime *) &_result_ref;
25286 }
25287 wxPyEndAllowThreads(__tstate);
25288 if (PyErr_Occurred()) SWIG_fail;
25289 }
25290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25291 return resultobj;
25292 fail:
25293 return NULL;
25294 }
25295
25296
25297 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25298 PyObject *resultobj = 0;
25299 wxDateTime *arg1 = (wxDateTime *) 0 ;
25300 int arg2 ;
25301 wxDateTime result;
25302 void *argp1 = 0 ;
25303 int res1 = 0 ;
25304 int val2 ;
25305 int ecode2 = 0 ;
25306 PyObject * obj0 = 0 ;
25307 PyObject * obj1 = 0 ;
25308 char * kwnames[] = {
25309 (char *) "self",(char *) "yday", NULL
25310 };
25311
25312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25314 if (!SWIG_IsOK(res1)) {
25315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25316 }
25317 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25318 ecode2 = SWIG_AsVal_int(obj1, &val2);
25319 if (!SWIG_IsOK(ecode2)) {
25320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25321 }
25322 arg2 = static_cast< int >(val2);
25323 {
25324 PyThreadState* __tstate = wxPyBeginAllowThreads();
25325 result = (arg1)->GetYearDay(arg2);
25326 wxPyEndAllowThreads(__tstate);
25327 if (PyErr_Occurred()) SWIG_fail;
25328 }
25329 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25330 return resultobj;
25331 fail:
25332 return NULL;
25333 }
25334
25335
25336 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25337 PyObject *resultobj = 0;
25338 wxDateTime *arg1 = (wxDateTime *) 0 ;
25339 double result;
25340 void *argp1 = 0 ;
25341 int res1 = 0 ;
25342 PyObject *swig_obj[1] ;
25343
25344 if (!args) SWIG_fail;
25345 swig_obj[0] = args;
25346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25347 if (!SWIG_IsOK(res1)) {
25348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25349 }
25350 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25351 {
25352 PyThreadState* __tstate = wxPyBeginAllowThreads();
25353 result = (double)(arg1)->GetJulianDayNumber();
25354 wxPyEndAllowThreads(__tstate);
25355 if (PyErr_Occurred()) SWIG_fail;
25356 }
25357 resultobj = SWIG_From_double(static_cast< double >(result));
25358 return resultobj;
25359 fail:
25360 return NULL;
25361 }
25362
25363
25364 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25365 PyObject *resultobj = 0;
25366 wxDateTime *arg1 = (wxDateTime *) 0 ;
25367 double result;
25368 void *argp1 = 0 ;
25369 int res1 = 0 ;
25370 PyObject *swig_obj[1] ;
25371
25372 if (!args) SWIG_fail;
25373 swig_obj[0] = args;
25374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25375 if (!SWIG_IsOK(res1)) {
25376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25377 }
25378 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25379 {
25380 PyThreadState* __tstate = wxPyBeginAllowThreads();
25381 result = (double)(arg1)->GetJDN();
25382 wxPyEndAllowThreads(__tstate);
25383 if (PyErr_Occurred()) SWIG_fail;
25384 }
25385 resultobj = SWIG_From_double(static_cast< double >(result));
25386 return resultobj;
25387 fail:
25388 return NULL;
25389 }
25390
25391
25392 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25393 PyObject *resultobj = 0;
25394 wxDateTime *arg1 = (wxDateTime *) 0 ;
25395 double result;
25396 void *argp1 = 0 ;
25397 int res1 = 0 ;
25398 PyObject *swig_obj[1] ;
25399
25400 if (!args) SWIG_fail;
25401 swig_obj[0] = args;
25402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25403 if (!SWIG_IsOK(res1)) {
25404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25405 }
25406 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25407 {
25408 PyThreadState* __tstate = wxPyBeginAllowThreads();
25409 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25410 wxPyEndAllowThreads(__tstate);
25411 if (PyErr_Occurred()) SWIG_fail;
25412 }
25413 resultobj = SWIG_From_double(static_cast< double >(result));
25414 return resultobj;
25415 fail:
25416 return NULL;
25417 }
25418
25419
25420 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25421 PyObject *resultobj = 0;
25422 wxDateTime *arg1 = (wxDateTime *) 0 ;
25423 double result;
25424 void *argp1 = 0 ;
25425 int res1 = 0 ;
25426 PyObject *swig_obj[1] ;
25427
25428 if (!args) SWIG_fail;
25429 swig_obj[0] = args;
25430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25431 if (!SWIG_IsOK(res1)) {
25432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25433 }
25434 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25435 {
25436 PyThreadState* __tstate = wxPyBeginAllowThreads();
25437 result = (double)(arg1)->GetMJD();
25438 wxPyEndAllowThreads(__tstate);
25439 if (PyErr_Occurred()) SWIG_fail;
25440 }
25441 resultobj = SWIG_From_double(static_cast< double >(result));
25442 return resultobj;
25443 fail:
25444 return NULL;
25445 }
25446
25447
25448 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25449 PyObject *resultobj = 0;
25450 wxDateTime *arg1 = (wxDateTime *) 0 ;
25451 double result;
25452 void *argp1 = 0 ;
25453 int res1 = 0 ;
25454 PyObject *swig_obj[1] ;
25455
25456 if (!args) SWIG_fail;
25457 swig_obj[0] = args;
25458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25459 if (!SWIG_IsOK(res1)) {
25460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25461 }
25462 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25463 {
25464 PyThreadState* __tstate = wxPyBeginAllowThreads();
25465 result = (double)(arg1)->GetRataDie();
25466 wxPyEndAllowThreads(__tstate);
25467 if (PyErr_Occurred()) SWIG_fail;
25468 }
25469 resultobj = SWIG_From_double(static_cast< double >(result));
25470 return resultobj;
25471 fail:
25472 return NULL;
25473 }
25474
25475
25476 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25477 PyObject *resultobj = 0;
25478 wxDateTime *arg1 = (wxDateTime *) 0 ;
25479 wxDateTime::TimeZone *arg2 = 0 ;
25480 bool arg3 = (bool) false ;
25481 wxDateTime result;
25482 void *argp1 = 0 ;
25483 int res1 = 0 ;
25484 bool temp2 = false ;
25485 bool val3 ;
25486 int ecode3 = 0 ;
25487 PyObject * obj0 = 0 ;
25488 PyObject * obj1 = 0 ;
25489 PyObject * obj2 = 0 ;
25490 char * kwnames[] = {
25491 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25492 };
25493
25494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25496 if (!SWIG_IsOK(res1)) {
25497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25498 }
25499 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25500 {
25501 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25502 temp2 = true;
25503 }
25504 if (obj2) {
25505 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25506 if (!SWIG_IsOK(ecode3)) {
25507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25508 }
25509 arg3 = static_cast< bool >(val3);
25510 }
25511 {
25512 PyThreadState* __tstate = wxPyBeginAllowThreads();
25513 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25514 wxPyEndAllowThreads(__tstate);
25515 if (PyErr_Occurred()) SWIG_fail;
25516 }
25517 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25518 {
25519 if (temp2) delete arg2;
25520 }
25521 return resultobj;
25522 fail:
25523 {
25524 if (temp2) delete arg2;
25525 }
25526 return NULL;
25527 }
25528
25529
25530 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25531 PyObject *resultobj = 0;
25532 wxDateTime *arg1 = (wxDateTime *) 0 ;
25533 wxDateTime::TimeZone *arg2 = 0 ;
25534 bool arg3 = (bool) false ;
25535 wxDateTime *result = 0 ;
25536 void *argp1 = 0 ;
25537 int res1 = 0 ;
25538 bool temp2 = false ;
25539 bool val3 ;
25540 int ecode3 = 0 ;
25541 PyObject * obj0 = 0 ;
25542 PyObject * obj1 = 0 ;
25543 PyObject * obj2 = 0 ;
25544 char * kwnames[] = {
25545 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25546 };
25547
25548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25550 if (!SWIG_IsOK(res1)) {
25551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25552 }
25553 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25554 {
25555 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25556 temp2 = true;
25557 }
25558 if (obj2) {
25559 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25560 if (!SWIG_IsOK(ecode3)) {
25561 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25562 }
25563 arg3 = static_cast< bool >(val3);
25564 }
25565 {
25566 PyThreadState* __tstate = wxPyBeginAllowThreads();
25567 {
25568 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25569 result = (wxDateTime *) &_result_ref;
25570 }
25571 wxPyEndAllowThreads(__tstate);
25572 if (PyErr_Occurred()) SWIG_fail;
25573 }
25574 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25575 {
25576 if (temp2) delete arg2;
25577 }
25578 return resultobj;
25579 fail:
25580 {
25581 if (temp2) delete arg2;
25582 }
25583 return NULL;
25584 }
25585
25586
25587 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25588 PyObject *resultobj = 0;
25589 wxDateTime *arg1 = (wxDateTime *) 0 ;
25590 wxDateTime::TimeZone *arg2 = 0 ;
25591 bool arg3 = (bool) false ;
25592 wxDateTime result;
25593 void *argp1 = 0 ;
25594 int res1 = 0 ;
25595 bool temp2 = false ;
25596 bool val3 ;
25597 int ecode3 = 0 ;
25598 PyObject * obj0 = 0 ;
25599 PyObject * obj1 = 0 ;
25600 PyObject * obj2 = 0 ;
25601 char * kwnames[] = {
25602 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25603 };
25604
25605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25607 if (!SWIG_IsOK(res1)) {
25608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25609 }
25610 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25611 {
25612 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25613 temp2 = true;
25614 }
25615 if (obj2) {
25616 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25617 if (!SWIG_IsOK(ecode3)) {
25618 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25619 }
25620 arg3 = static_cast< bool >(val3);
25621 }
25622 {
25623 PyThreadState* __tstate = wxPyBeginAllowThreads();
25624 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25625 wxPyEndAllowThreads(__tstate);
25626 if (PyErr_Occurred()) SWIG_fail;
25627 }
25628 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25629 {
25630 if (temp2) delete arg2;
25631 }
25632 return resultobj;
25633 fail:
25634 {
25635 if (temp2) delete arg2;
25636 }
25637 return NULL;
25638 }
25639
25640
25641 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25642 PyObject *resultobj = 0;
25643 wxDateTime *arg1 = (wxDateTime *) 0 ;
25644 wxDateTime::TimeZone *arg2 = 0 ;
25645 bool arg3 = (bool) false ;
25646 wxDateTime *result = 0 ;
25647 void *argp1 = 0 ;
25648 int res1 = 0 ;
25649 bool temp2 = false ;
25650 bool val3 ;
25651 int ecode3 = 0 ;
25652 PyObject * obj0 = 0 ;
25653 PyObject * obj1 = 0 ;
25654 PyObject * obj2 = 0 ;
25655 char * kwnames[] = {
25656 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25657 };
25658
25659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25661 if (!SWIG_IsOK(res1)) {
25662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25663 }
25664 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25665 {
25666 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25667 temp2 = true;
25668 }
25669 if (obj2) {
25670 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25671 if (!SWIG_IsOK(ecode3)) {
25672 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25673 }
25674 arg3 = static_cast< bool >(val3);
25675 }
25676 {
25677 PyThreadState* __tstate = wxPyBeginAllowThreads();
25678 {
25679 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25680 result = (wxDateTime *) &_result_ref;
25681 }
25682 wxPyEndAllowThreads(__tstate);
25683 if (PyErr_Occurred()) SWIG_fail;
25684 }
25685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25686 {
25687 if (temp2) delete arg2;
25688 }
25689 return resultobj;
25690 fail:
25691 {
25692 if (temp2) delete arg2;
25693 }
25694 return NULL;
25695 }
25696
25697
25698 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25699 PyObject *resultobj = 0;
25700 wxDateTime *arg1 = (wxDateTime *) 0 ;
25701 bool arg2 = (bool) false ;
25702 wxDateTime result;
25703 void *argp1 = 0 ;
25704 int res1 = 0 ;
25705 bool val2 ;
25706 int ecode2 = 0 ;
25707 PyObject * obj0 = 0 ;
25708 PyObject * obj1 = 0 ;
25709 char * kwnames[] = {
25710 (char *) "self",(char *) "noDST", NULL
25711 };
25712
25713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25715 if (!SWIG_IsOK(res1)) {
25716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25717 }
25718 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25719 if (obj1) {
25720 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25721 if (!SWIG_IsOK(ecode2)) {
25722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25723 }
25724 arg2 = static_cast< bool >(val2);
25725 }
25726 {
25727 PyThreadState* __tstate = wxPyBeginAllowThreads();
25728 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25729 wxPyEndAllowThreads(__tstate);
25730 if (PyErr_Occurred()) SWIG_fail;
25731 }
25732 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25733 return resultobj;
25734 fail:
25735 return NULL;
25736 }
25737
25738
25739 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25740 PyObject *resultobj = 0;
25741 wxDateTime *arg1 = (wxDateTime *) 0 ;
25742 bool arg2 = (bool) false ;
25743 wxDateTime *result = 0 ;
25744 void *argp1 = 0 ;
25745 int res1 = 0 ;
25746 bool val2 ;
25747 int ecode2 = 0 ;
25748 PyObject * obj0 = 0 ;
25749 PyObject * obj1 = 0 ;
25750 char * kwnames[] = {
25751 (char *) "self",(char *) "noDST", NULL
25752 };
25753
25754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25756 if (!SWIG_IsOK(res1)) {
25757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25758 }
25759 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25760 if (obj1) {
25761 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25762 if (!SWIG_IsOK(ecode2)) {
25763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25764 }
25765 arg2 = static_cast< bool >(val2);
25766 }
25767 {
25768 PyThreadState* __tstate = wxPyBeginAllowThreads();
25769 {
25770 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25771 result = (wxDateTime *) &_result_ref;
25772 }
25773 wxPyEndAllowThreads(__tstate);
25774 if (PyErr_Occurred()) SWIG_fail;
25775 }
25776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25777 return resultobj;
25778 fail:
25779 return NULL;
25780 }
25781
25782
25783 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25784 PyObject *resultobj = 0;
25785 wxDateTime *arg1 = (wxDateTime *) 0 ;
25786 bool arg2 = (bool) false ;
25787 wxDateTime result;
25788 void *argp1 = 0 ;
25789 int res1 = 0 ;
25790 bool val2 ;
25791 int ecode2 = 0 ;
25792 PyObject * obj0 = 0 ;
25793 PyObject * obj1 = 0 ;
25794 char * kwnames[] = {
25795 (char *) "self",(char *) "noDST", NULL
25796 };
25797
25798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25800 if (!SWIG_IsOK(res1)) {
25801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25802 }
25803 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25804 if (obj1) {
25805 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25806 if (!SWIG_IsOK(ecode2)) {
25807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
25808 }
25809 arg2 = static_cast< bool >(val2);
25810 }
25811 {
25812 PyThreadState* __tstate = wxPyBeginAllowThreads();
25813 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
25814 wxPyEndAllowThreads(__tstate);
25815 if (PyErr_Occurred()) SWIG_fail;
25816 }
25817 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25818 return resultobj;
25819 fail:
25820 return NULL;
25821 }
25822
25823
25824 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25825 PyObject *resultobj = 0;
25826 wxDateTime *arg1 = (wxDateTime *) 0 ;
25827 bool arg2 = (bool) false ;
25828 wxDateTime *result = 0 ;
25829 void *argp1 = 0 ;
25830 int res1 = 0 ;
25831 bool val2 ;
25832 int ecode2 = 0 ;
25833 PyObject * obj0 = 0 ;
25834 PyObject * obj1 = 0 ;
25835 char * kwnames[] = {
25836 (char *) "self",(char *) "noDST", NULL
25837 };
25838
25839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25841 if (!SWIG_IsOK(res1)) {
25842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
25843 }
25844 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25845 if (obj1) {
25846 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25847 if (!SWIG_IsOK(ecode2)) {
25848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
25849 }
25850 arg2 = static_cast< bool >(val2);
25851 }
25852 {
25853 PyThreadState* __tstate = wxPyBeginAllowThreads();
25854 {
25855 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
25856 result = (wxDateTime *) &_result_ref;
25857 }
25858 wxPyEndAllowThreads(__tstate);
25859 if (PyErr_Occurred()) SWIG_fail;
25860 }
25861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25862 return resultobj;
25863 fail:
25864 return NULL;
25865 }
25866
25867
25868 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25869 PyObject *resultobj = 0;
25870 wxDateTime *arg1 = (wxDateTime *) 0 ;
25871 bool arg2 = (bool) false ;
25872 wxDateTime result;
25873 void *argp1 = 0 ;
25874 int res1 = 0 ;
25875 bool val2 ;
25876 int ecode2 = 0 ;
25877 PyObject * obj0 = 0 ;
25878 PyObject * obj1 = 0 ;
25879 char * kwnames[] = {
25880 (char *) "self",(char *) "noDST", NULL
25881 };
25882
25883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25885 if (!SWIG_IsOK(res1)) {
25886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25887 }
25888 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25889 if (obj1) {
25890 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25891 if (!SWIG_IsOK(ecode2)) {
25892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
25893 }
25894 arg2 = static_cast< bool >(val2);
25895 }
25896 {
25897 PyThreadState* __tstate = wxPyBeginAllowThreads();
25898 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
25899 wxPyEndAllowThreads(__tstate);
25900 if (PyErr_Occurred()) SWIG_fail;
25901 }
25902 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25903 return resultobj;
25904 fail:
25905 return NULL;
25906 }
25907
25908
25909 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25910 PyObject *resultobj = 0;
25911 wxDateTime *arg1 = (wxDateTime *) 0 ;
25912 bool arg2 = (bool) false ;
25913 wxDateTime *result = 0 ;
25914 void *argp1 = 0 ;
25915 int res1 = 0 ;
25916 bool val2 ;
25917 int ecode2 = 0 ;
25918 PyObject * obj0 = 0 ;
25919 PyObject * obj1 = 0 ;
25920 char * kwnames[] = {
25921 (char *) "self",(char *) "noDST", NULL
25922 };
25923
25924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25926 if (!SWIG_IsOK(res1)) {
25927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25928 }
25929 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25930 if (obj1) {
25931 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25932 if (!SWIG_IsOK(ecode2)) {
25933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
25934 }
25935 arg2 = static_cast< bool >(val2);
25936 }
25937 {
25938 PyThreadState* __tstate = wxPyBeginAllowThreads();
25939 {
25940 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
25941 result = (wxDateTime *) &_result_ref;
25942 }
25943 wxPyEndAllowThreads(__tstate);
25944 if (PyErr_Occurred()) SWIG_fail;
25945 }
25946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25947 return resultobj;
25948 fail:
25949 return NULL;
25950 }
25951
25952
25953 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25954 PyObject *resultobj = 0;
25955 wxDateTime *arg1 = (wxDateTime *) 0 ;
25956 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25957 int result;
25958 void *argp1 = 0 ;
25959 int res1 = 0 ;
25960 int val2 ;
25961 int ecode2 = 0 ;
25962 PyObject * obj0 = 0 ;
25963 PyObject * obj1 = 0 ;
25964 char * kwnames[] = {
25965 (char *) "self",(char *) "country", NULL
25966 };
25967
25968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
25969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25970 if (!SWIG_IsOK(res1)) {
25971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
25972 }
25973 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25974 if (obj1) {
25975 ecode2 = SWIG_AsVal_int(obj1, &val2);
25976 if (!SWIG_IsOK(ecode2)) {
25977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25978 }
25979 arg2 = static_cast< wxDateTime::Country >(val2);
25980 }
25981 {
25982 PyThreadState* __tstate = wxPyBeginAllowThreads();
25983 result = (int)(arg1)->IsDST(arg2);
25984 wxPyEndAllowThreads(__tstate);
25985 if (PyErr_Occurred()) SWIG_fail;
25986 }
25987 resultobj = SWIG_From_int(static_cast< int >(result));
25988 return resultobj;
25989 fail:
25990 return NULL;
25991 }
25992
25993
25994 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25995 PyObject *resultobj = 0;
25996 wxDateTime *arg1 = (wxDateTime *) 0 ;
25997 bool result;
25998 void *argp1 = 0 ;
25999 int res1 = 0 ;
26000 PyObject *swig_obj[1] ;
26001
26002 if (!args) SWIG_fail;
26003 swig_obj[0] = args;
26004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26005 if (!SWIG_IsOK(res1)) {
26006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26007 }
26008 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26009 {
26010 PyThreadState* __tstate = wxPyBeginAllowThreads();
26011 result = (bool)((wxDateTime const *)arg1)->IsValid();
26012 wxPyEndAllowThreads(__tstate);
26013 if (PyErr_Occurred()) SWIG_fail;
26014 }
26015 {
26016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26017 }
26018 return resultobj;
26019 fail:
26020 return NULL;
26021 }
26022
26023
26024 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26025 PyObject *resultobj = 0;
26026 wxDateTime *arg1 = (wxDateTime *) 0 ;
26027 time_t result;
26028 void *argp1 = 0 ;
26029 int res1 = 0 ;
26030 PyObject *swig_obj[1] ;
26031
26032 if (!args) SWIG_fail;
26033 swig_obj[0] = args;
26034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26035 if (!SWIG_IsOK(res1)) {
26036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26037 }
26038 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26039 {
26040 PyThreadState* __tstate = wxPyBeginAllowThreads();
26041 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26042 wxPyEndAllowThreads(__tstate);
26043 if (PyErr_Occurred()) SWIG_fail;
26044 }
26045 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26046 return resultobj;
26047 fail:
26048 return NULL;
26049 }
26050
26051
26052 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26053 PyObject *resultobj = 0;
26054 wxDateTime *arg1 = (wxDateTime *) 0 ;
26055 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26056 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26057 int result;
26058 void *argp1 = 0 ;
26059 int res1 = 0 ;
26060 bool temp2 = false ;
26061 PyObject * obj0 = 0 ;
26062 PyObject * obj1 = 0 ;
26063 char * kwnames[] = {
26064 (char *) "self",(char *) "tz", NULL
26065 };
26066
26067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26069 if (!SWIG_IsOK(res1)) {
26070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26071 }
26072 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26073 if (obj1) {
26074 {
26075 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26076 temp2 = true;
26077 }
26078 }
26079 {
26080 PyThreadState* __tstate = wxPyBeginAllowThreads();
26081 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26082 wxPyEndAllowThreads(__tstate);
26083 if (PyErr_Occurred()) SWIG_fail;
26084 }
26085 resultobj = SWIG_From_int(static_cast< int >(result));
26086 {
26087 if (temp2) delete arg2;
26088 }
26089 return resultobj;
26090 fail:
26091 {
26092 if (temp2) delete arg2;
26093 }
26094 return NULL;
26095 }
26096
26097
26098 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26099 PyObject *resultobj = 0;
26100 wxDateTime *arg1 = (wxDateTime *) 0 ;
26101 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26102 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26103 wxDateTime::Month result;
26104 void *argp1 = 0 ;
26105 int res1 = 0 ;
26106 bool temp2 = false ;
26107 PyObject * obj0 = 0 ;
26108 PyObject * obj1 = 0 ;
26109 char * kwnames[] = {
26110 (char *) "self",(char *) "tz", NULL
26111 };
26112
26113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26115 if (!SWIG_IsOK(res1)) {
26116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26117 }
26118 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26119 if (obj1) {
26120 {
26121 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26122 temp2 = true;
26123 }
26124 }
26125 {
26126 PyThreadState* __tstate = wxPyBeginAllowThreads();
26127 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26128 wxPyEndAllowThreads(__tstate);
26129 if (PyErr_Occurred()) SWIG_fail;
26130 }
26131 resultobj = SWIG_From_int(static_cast< int >(result));
26132 {
26133 if (temp2) delete arg2;
26134 }
26135 return resultobj;
26136 fail:
26137 {
26138 if (temp2) delete arg2;
26139 }
26140 return NULL;
26141 }
26142
26143
26144 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26145 PyObject *resultobj = 0;
26146 wxDateTime *arg1 = (wxDateTime *) 0 ;
26147 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26148 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26149 int result;
26150 void *argp1 = 0 ;
26151 int res1 = 0 ;
26152 bool temp2 = false ;
26153 PyObject * obj0 = 0 ;
26154 PyObject * obj1 = 0 ;
26155 char * kwnames[] = {
26156 (char *) "self",(char *) "tz", NULL
26157 };
26158
26159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26161 if (!SWIG_IsOK(res1)) {
26162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26163 }
26164 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26165 if (obj1) {
26166 {
26167 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26168 temp2 = true;
26169 }
26170 }
26171 {
26172 PyThreadState* __tstate = wxPyBeginAllowThreads();
26173 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26174 wxPyEndAllowThreads(__tstate);
26175 if (PyErr_Occurred()) SWIG_fail;
26176 }
26177 resultobj = SWIG_From_int(static_cast< int >(result));
26178 {
26179 if (temp2) delete arg2;
26180 }
26181 return resultobj;
26182 fail:
26183 {
26184 if (temp2) delete arg2;
26185 }
26186 return NULL;
26187 }
26188
26189
26190 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26191 PyObject *resultobj = 0;
26192 wxDateTime *arg1 = (wxDateTime *) 0 ;
26193 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26194 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26195 wxDateTime::WeekDay result;
26196 void *argp1 = 0 ;
26197 int res1 = 0 ;
26198 bool temp2 = false ;
26199 PyObject * obj0 = 0 ;
26200 PyObject * obj1 = 0 ;
26201 char * kwnames[] = {
26202 (char *) "self",(char *) "tz", NULL
26203 };
26204
26205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26207 if (!SWIG_IsOK(res1)) {
26208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26209 }
26210 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26211 if (obj1) {
26212 {
26213 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26214 temp2 = true;
26215 }
26216 }
26217 {
26218 PyThreadState* __tstate = wxPyBeginAllowThreads();
26219 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26220 wxPyEndAllowThreads(__tstate);
26221 if (PyErr_Occurred()) SWIG_fail;
26222 }
26223 resultobj = SWIG_From_int(static_cast< int >(result));
26224 {
26225 if (temp2) delete arg2;
26226 }
26227 return resultobj;
26228 fail:
26229 {
26230 if (temp2) delete arg2;
26231 }
26232 return NULL;
26233 }
26234
26235
26236 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26237 PyObject *resultobj = 0;
26238 wxDateTime *arg1 = (wxDateTime *) 0 ;
26239 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26240 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26241 int result;
26242 void *argp1 = 0 ;
26243 int res1 = 0 ;
26244 bool temp2 = false ;
26245 PyObject * obj0 = 0 ;
26246 PyObject * obj1 = 0 ;
26247 char * kwnames[] = {
26248 (char *) "self",(char *) "tz", NULL
26249 };
26250
26251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26253 if (!SWIG_IsOK(res1)) {
26254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26255 }
26256 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26257 if (obj1) {
26258 {
26259 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26260 temp2 = true;
26261 }
26262 }
26263 {
26264 PyThreadState* __tstate = wxPyBeginAllowThreads();
26265 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26266 wxPyEndAllowThreads(__tstate);
26267 if (PyErr_Occurred()) SWIG_fail;
26268 }
26269 resultobj = SWIG_From_int(static_cast< int >(result));
26270 {
26271 if (temp2) delete arg2;
26272 }
26273 return resultobj;
26274 fail:
26275 {
26276 if (temp2) delete arg2;
26277 }
26278 return NULL;
26279 }
26280
26281
26282 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26283 PyObject *resultobj = 0;
26284 wxDateTime *arg1 = (wxDateTime *) 0 ;
26285 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26286 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26287 int result;
26288 void *argp1 = 0 ;
26289 int res1 = 0 ;
26290 bool temp2 = false ;
26291 PyObject * obj0 = 0 ;
26292 PyObject * obj1 = 0 ;
26293 char * kwnames[] = {
26294 (char *) "self",(char *) "tz", NULL
26295 };
26296
26297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26299 if (!SWIG_IsOK(res1)) {
26300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26301 }
26302 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26303 if (obj1) {
26304 {
26305 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26306 temp2 = true;
26307 }
26308 }
26309 {
26310 PyThreadState* __tstate = wxPyBeginAllowThreads();
26311 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26312 wxPyEndAllowThreads(__tstate);
26313 if (PyErr_Occurred()) SWIG_fail;
26314 }
26315 resultobj = SWIG_From_int(static_cast< int >(result));
26316 {
26317 if (temp2) delete arg2;
26318 }
26319 return resultobj;
26320 fail:
26321 {
26322 if (temp2) delete arg2;
26323 }
26324 return NULL;
26325 }
26326
26327
26328 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26329 PyObject *resultobj = 0;
26330 wxDateTime *arg1 = (wxDateTime *) 0 ;
26331 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26332 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26333 int result;
26334 void *argp1 = 0 ;
26335 int res1 = 0 ;
26336 bool temp2 = false ;
26337 PyObject * obj0 = 0 ;
26338 PyObject * obj1 = 0 ;
26339 char * kwnames[] = {
26340 (char *) "self",(char *) "tz", NULL
26341 };
26342
26343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26345 if (!SWIG_IsOK(res1)) {
26346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26347 }
26348 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26349 if (obj1) {
26350 {
26351 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26352 temp2 = true;
26353 }
26354 }
26355 {
26356 PyThreadState* __tstate = wxPyBeginAllowThreads();
26357 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26358 wxPyEndAllowThreads(__tstate);
26359 if (PyErr_Occurred()) SWIG_fail;
26360 }
26361 resultobj = SWIG_From_int(static_cast< int >(result));
26362 {
26363 if (temp2) delete arg2;
26364 }
26365 return resultobj;
26366 fail:
26367 {
26368 if (temp2) delete arg2;
26369 }
26370 return NULL;
26371 }
26372
26373
26374 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26375 PyObject *resultobj = 0;
26376 wxDateTime *arg1 = (wxDateTime *) 0 ;
26377 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26378 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26379 int result;
26380 void *argp1 = 0 ;
26381 int res1 = 0 ;
26382 bool temp2 = false ;
26383 PyObject * obj0 = 0 ;
26384 PyObject * obj1 = 0 ;
26385 char * kwnames[] = {
26386 (char *) "self",(char *) "tz", NULL
26387 };
26388
26389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26391 if (!SWIG_IsOK(res1)) {
26392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26393 }
26394 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26395 if (obj1) {
26396 {
26397 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26398 temp2 = true;
26399 }
26400 }
26401 {
26402 PyThreadState* __tstate = wxPyBeginAllowThreads();
26403 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26404 wxPyEndAllowThreads(__tstate);
26405 if (PyErr_Occurred()) SWIG_fail;
26406 }
26407 resultobj = SWIG_From_int(static_cast< int >(result));
26408 {
26409 if (temp2) delete arg2;
26410 }
26411 return resultobj;
26412 fail:
26413 {
26414 if (temp2) delete arg2;
26415 }
26416 return NULL;
26417 }
26418
26419
26420 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26421 PyObject *resultobj = 0;
26422 wxDateTime *arg1 = (wxDateTime *) 0 ;
26423 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26424 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26425 int result;
26426 void *argp1 = 0 ;
26427 int res1 = 0 ;
26428 bool temp2 = false ;
26429 PyObject * obj0 = 0 ;
26430 PyObject * obj1 = 0 ;
26431 char * kwnames[] = {
26432 (char *) "self",(char *) "tz", NULL
26433 };
26434
26435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26437 if (!SWIG_IsOK(res1)) {
26438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26439 }
26440 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26441 if (obj1) {
26442 {
26443 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26444 temp2 = true;
26445 }
26446 }
26447 {
26448 PyThreadState* __tstate = wxPyBeginAllowThreads();
26449 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26450 wxPyEndAllowThreads(__tstate);
26451 if (PyErr_Occurred()) SWIG_fail;
26452 }
26453 resultobj = SWIG_From_int(static_cast< int >(result));
26454 {
26455 if (temp2) delete arg2;
26456 }
26457 return resultobj;
26458 fail:
26459 {
26460 if (temp2) delete arg2;
26461 }
26462 return NULL;
26463 }
26464
26465
26466 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26467 PyObject *resultobj = 0;
26468 wxDateTime *arg1 = (wxDateTime *) 0 ;
26469 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26470 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26471 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26472 int result;
26473 void *argp1 = 0 ;
26474 int res1 = 0 ;
26475 int val2 ;
26476 int ecode2 = 0 ;
26477 bool temp3 = false ;
26478 PyObject * obj0 = 0 ;
26479 PyObject * obj1 = 0 ;
26480 PyObject * obj2 = 0 ;
26481 char * kwnames[] = {
26482 (char *) "self",(char *) "flags",(char *) "tz", NULL
26483 };
26484
26485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26487 if (!SWIG_IsOK(res1)) {
26488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26489 }
26490 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26491 if (obj1) {
26492 ecode2 = SWIG_AsVal_int(obj1, &val2);
26493 if (!SWIG_IsOK(ecode2)) {
26494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26495 }
26496 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26497 }
26498 if (obj2) {
26499 {
26500 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26501 temp3 = true;
26502 }
26503 }
26504 {
26505 PyThreadState* __tstate = wxPyBeginAllowThreads();
26506 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26507 wxPyEndAllowThreads(__tstate);
26508 if (PyErr_Occurred()) SWIG_fail;
26509 }
26510 resultobj = SWIG_From_int(static_cast< int >(result));
26511 {
26512 if (temp3) delete arg3;
26513 }
26514 return resultobj;
26515 fail:
26516 {
26517 if (temp3) delete arg3;
26518 }
26519 return NULL;
26520 }
26521
26522
26523 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26524 PyObject *resultobj = 0;
26525 wxDateTime *arg1 = (wxDateTime *) 0 ;
26526 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26527 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26528 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26529 int result;
26530 void *argp1 = 0 ;
26531 int res1 = 0 ;
26532 int val2 ;
26533 int ecode2 = 0 ;
26534 bool temp3 = false ;
26535 PyObject * obj0 = 0 ;
26536 PyObject * obj1 = 0 ;
26537 PyObject * obj2 = 0 ;
26538 char * kwnames[] = {
26539 (char *) "self",(char *) "flags",(char *) "tz", NULL
26540 };
26541
26542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26544 if (!SWIG_IsOK(res1)) {
26545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26546 }
26547 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26548 if (obj1) {
26549 ecode2 = SWIG_AsVal_int(obj1, &val2);
26550 if (!SWIG_IsOK(ecode2)) {
26551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26552 }
26553 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26554 }
26555 if (obj2) {
26556 {
26557 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26558 temp3 = true;
26559 }
26560 }
26561 {
26562 PyThreadState* __tstate = wxPyBeginAllowThreads();
26563 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26564 wxPyEndAllowThreads(__tstate);
26565 if (PyErr_Occurred()) SWIG_fail;
26566 }
26567 resultobj = SWIG_From_int(static_cast< int >(result));
26568 {
26569 if (temp3) delete arg3;
26570 }
26571 return resultobj;
26572 fail:
26573 {
26574 if (temp3) delete arg3;
26575 }
26576 return NULL;
26577 }
26578
26579
26580 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26581 PyObject *resultobj = 0;
26582 wxDateTime *arg1 = (wxDateTime *) 0 ;
26583 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26584 bool result;
26585 void *argp1 = 0 ;
26586 int res1 = 0 ;
26587 int val2 ;
26588 int ecode2 = 0 ;
26589 PyObject * obj0 = 0 ;
26590 PyObject * obj1 = 0 ;
26591 char * kwnames[] = {
26592 (char *) "self",(char *) "country", NULL
26593 };
26594
26595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26597 if (!SWIG_IsOK(res1)) {
26598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26599 }
26600 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26601 if (obj1) {
26602 ecode2 = SWIG_AsVal_int(obj1, &val2);
26603 if (!SWIG_IsOK(ecode2)) {
26604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26605 }
26606 arg2 = static_cast< wxDateTime::Country >(val2);
26607 }
26608 {
26609 PyThreadState* __tstate = wxPyBeginAllowThreads();
26610 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26611 wxPyEndAllowThreads(__tstate);
26612 if (PyErr_Occurred()) SWIG_fail;
26613 }
26614 {
26615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26616 }
26617 return resultobj;
26618 fail:
26619 return NULL;
26620 }
26621
26622
26623 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26624 PyObject *resultobj = 0;
26625 wxDateTime *arg1 = (wxDateTime *) 0 ;
26626 wxDateTime *arg2 = 0 ;
26627 bool result;
26628 void *argp1 = 0 ;
26629 int res1 = 0 ;
26630 void *argp2 = 0 ;
26631 int res2 = 0 ;
26632 PyObject * obj0 = 0 ;
26633 PyObject * obj1 = 0 ;
26634 char * kwnames[] = {
26635 (char *) "self",(char *) "datetime", NULL
26636 };
26637
26638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26640 if (!SWIG_IsOK(res1)) {
26641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26642 }
26643 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26644 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26645 if (!SWIG_IsOK(res2)) {
26646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26647 }
26648 if (!argp2) {
26649 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26650 }
26651 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26652 {
26653 PyThreadState* __tstate = wxPyBeginAllowThreads();
26654 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26655 wxPyEndAllowThreads(__tstate);
26656 if (PyErr_Occurred()) SWIG_fail;
26657 }
26658 {
26659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26660 }
26661 return resultobj;
26662 fail:
26663 return NULL;
26664 }
26665
26666
26667 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26668 PyObject *resultobj = 0;
26669 wxDateTime *arg1 = (wxDateTime *) 0 ;
26670 wxDateTime *arg2 = 0 ;
26671 bool result;
26672 void *argp1 = 0 ;
26673 int res1 = 0 ;
26674 void *argp2 = 0 ;
26675 int res2 = 0 ;
26676 PyObject * obj0 = 0 ;
26677 PyObject * obj1 = 0 ;
26678 char * kwnames[] = {
26679 (char *) "self",(char *) "datetime", NULL
26680 };
26681
26682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26684 if (!SWIG_IsOK(res1)) {
26685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26686 }
26687 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26688 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26689 if (!SWIG_IsOK(res2)) {
26690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26691 }
26692 if (!argp2) {
26693 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26694 }
26695 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26696 {
26697 PyThreadState* __tstate = wxPyBeginAllowThreads();
26698 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26699 wxPyEndAllowThreads(__tstate);
26700 if (PyErr_Occurred()) SWIG_fail;
26701 }
26702 {
26703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26704 }
26705 return resultobj;
26706 fail:
26707 return NULL;
26708 }
26709
26710
26711 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26712 PyObject *resultobj = 0;
26713 wxDateTime *arg1 = (wxDateTime *) 0 ;
26714 wxDateTime *arg2 = 0 ;
26715 bool result;
26716 void *argp1 = 0 ;
26717 int res1 = 0 ;
26718 void *argp2 = 0 ;
26719 int res2 = 0 ;
26720 PyObject * obj0 = 0 ;
26721 PyObject * obj1 = 0 ;
26722 char * kwnames[] = {
26723 (char *) "self",(char *) "datetime", NULL
26724 };
26725
26726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26728 if (!SWIG_IsOK(res1)) {
26729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26730 }
26731 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26732 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26733 if (!SWIG_IsOK(res2)) {
26734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26735 }
26736 if (!argp2) {
26737 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26738 }
26739 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26740 {
26741 PyThreadState* __tstate = wxPyBeginAllowThreads();
26742 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26743 wxPyEndAllowThreads(__tstate);
26744 if (PyErr_Occurred()) SWIG_fail;
26745 }
26746 {
26747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26748 }
26749 return resultobj;
26750 fail:
26751 return NULL;
26752 }
26753
26754
26755 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26756 PyObject *resultobj = 0;
26757 wxDateTime *arg1 = (wxDateTime *) 0 ;
26758 wxDateTime *arg2 = 0 ;
26759 wxDateTime *arg3 = 0 ;
26760 bool result;
26761 void *argp1 = 0 ;
26762 int res1 = 0 ;
26763 void *argp2 = 0 ;
26764 int res2 = 0 ;
26765 void *argp3 = 0 ;
26766 int res3 = 0 ;
26767 PyObject * obj0 = 0 ;
26768 PyObject * obj1 = 0 ;
26769 PyObject * obj2 = 0 ;
26770 char * kwnames[] = {
26771 (char *) "self",(char *) "t1",(char *) "t2", NULL
26772 };
26773
26774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26776 if (!SWIG_IsOK(res1)) {
26777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26778 }
26779 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26780 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26781 if (!SWIG_IsOK(res2)) {
26782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26783 }
26784 if (!argp2) {
26785 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26786 }
26787 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26788 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26789 if (!SWIG_IsOK(res3)) {
26790 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26791 }
26792 if (!argp3) {
26793 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26794 }
26795 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26796 {
26797 PyThreadState* __tstate = wxPyBeginAllowThreads();
26798 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26799 wxPyEndAllowThreads(__tstate);
26800 if (PyErr_Occurred()) SWIG_fail;
26801 }
26802 {
26803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26804 }
26805 return resultobj;
26806 fail:
26807 return NULL;
26808 }
26809
26810
26811 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26812 PyObject *resultobj = 0;
26813 wxDateTime *arg1 = (wxDateTime *) 0 ;
26814 wxDateTime *arg2 = 0 ;
26815 wxDateTime *arg3 = 0 ;
26816 bool result;
26817 void *argp1 = 0 ;
26818 int res1 = 0 ;
26819 void *argp2 = 0 ;
26820 int res2 = 0 ;
26821 void *argp3 = 0 ;
26822 int res3 = 0 ;
26823 PyObject * obj0 = 0 ;
26824 PyObject * obj1 = 0 ;
26825 PyObject * obj2 = 0 ;
26826 char * kwnames[] = {
26827 (char *) "self",(char *) "t1",(char *) "t2", NULL
26828 };
26829
26830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26832 if (!SWIG_IsOK(res1)) {
26833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26834 }
26835 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26836 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26837 if (!SWIG_IsOK(res2)) {
26838 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26839 }
26840 if (!argp2) {
26841 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26842 }
26843 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26844 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26845 if (!SWIG_IsOK(res3)) {
26846 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26847 }
26848 if (!argp3) {
26849 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26850 }
26851 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26852 {
26853 PyThreadState* __tstate = wxPyBeginAllowThreads();
26854 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26855 wxPyEndAllowThreads(__tstate);
26856 if (PyErr_Occurred()) SWIG_fail;
26857 }
26858 {
26859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26860 }
26861 return resultobj;
26862 fail:
26863 return NULL;
26864 }
26865
26866
26867 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26868 PyObject *resultobj = 0;
26869 wxDateTime *arg1 = (wxDateTime *) 0 ;
26870 wxDateTime *arg2 = 0 ;
26871 bool result;
26872 void *argp1 = 0 ;
26873 int res1 = 0 ;
26874 void *argp2 = 0 ;
26875 int res2 = 0 ;
26876 PyObject * obj0 = 0 ;
26877 PyObject * obj1 = 0 ;
26878 char * kwnames[] = {
26879 (char *) "self",(char *) "dt", NULL
26880 };
26881
26882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
26883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26884 if (!SWIG_IsOK(res1)) {
26885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26886 }
26887 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26888 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26889 if (!SWIG_IsOK(res2)) {
26890 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26891 }
26892 if (!argp2) {
26893 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26894 }
26895 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26896 {
26897 PyThreadState* __tstate = wxPyBeginAllowThreads();
26898 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
26899 wxPyEndAllowThreads(__tstate);
26900 if (PyErr_Occurred()) SWIG_fail;
26901 }
26902 {
26903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26904 }
26905 return resultobj;
26906 fail:
26907 return NULL;
26908 }
26909
26910
26911 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26912 PyObject *resultobj = 0;
26913 wxDateTime *arg1 = (wxDateTime *) 0 ;
26914 wxDateTime *arg2 = 0 ;
26915 bool result;
26916 void *argp1 = 0 ;
26917 int res1 = 0 ;
26918 void *argp2 = 0 ;
26919 int res2 = 0 ;
26920 PyObject * obj0 = 0 ;
26921 PyObject * obj1 = 0 ;
26922 char * kwnames[] = {
26923 (char *) "self",(char *) "dt", NULL
26924 };
26925
26926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
26927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26928 if (!SWIG_IsOK(res1)) {
26929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26930 }
26931 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26932 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26933 if (!SWIG_IsOK(res2)) {
26934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26935 }
26936 if (!argp2) {
26937 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26938 }
26939 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26940 {
26941 PyThreadState* __tstate = wxPyBeginAllowThreads();
26942 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
26943 wxPyEndAllowThreads(__tstate);
26944 if (PyErr_Occurred()) SWIG_fail;
26945 }
26946 {
26947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26948 }
26949 return resultobj;
26950 fail:
26951 return NULL;
26952 }
26953
26954
26955 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26956 PyObject *resultobj = 0;
26957 wxDateTime *arg1 = (wxDateTime *) 0 ;
26958 wxDateTime *arg2 = 0 ;
26959 wxTimeSpan *arg3 = 0 ;
26960 bool result;
26961 void *argp1 = 0 ;
26962 int res1 = 0 ;
26963 void *argp2 = 0 ;
26964 int res2 = 0 ;
26965 void *argp3 = 0 ;
26966 int res3 = 0 ;
26967 PyObject * obj0 = 0 ;
26968 PyObject * obj1 = 0 ;
26969 PyObject * obj2 = 0 ;
26970 char * kwnames[] = {
26971 (char *) "self",(char *) "dt",(char *) "ts", NULL
26972 };
26973
26974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26976 if (!SWIG_IsOK(res1)) {
26977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26978 }
26979 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26980 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26981 if (!SWIG_IsOK(res2)) {
26982 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26983 }
26984 if (!argp2) {
26985 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26986 }
26987 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26988 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26989 if (!SWIG_IsOK(res3)) {
26990 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26991 }
26992 if (!argp3) {
26993 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26994 }
26995 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
26996 {
26997 PyThreadState* __tstate = wxPyBeginAllowThreads();
26998 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
26999 wxPyEndAllowThreads(__tstate);
27000 if (PyErr_Occurred()) SWIG_fail;
27001 }
27002 {
27003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27004 }
27005 return resultobj;
27006 fail:
27007 return NULL;
27008 }
27009
27010
27011 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27012 PyObject *resultobj = 0;
27013 wxDateTime *arg1 = (wxDateTime *) 0 ;
27014 wxTimeSpan *arg2 = 0 ;
27015 wxDateTime *result = 0 ;
27016 void *argp1 = 0 ;
27017 int res1 = 0 ;
27018 void *argp2 = 0 ;
27019 int res2 = 0 ;
27020 PyObject * obj0 = 0 ;
27021 PyObject * obj1 = 0 ;
27022 char * kwnames[] = {
27023 (char *) "self",(char *) "diff", NULL
27024 };
27025
27026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27028 if (!SWIG_IsOK(res1)) {
27029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27030 }
27031 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27032 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27033 if (!SWIG_IsOK(res2)) {
27034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27035 }
27036 if (!argp2) {
27037 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27038 }
27039 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27040 {
27041 PyThreadState* __tstate = wxPyBeginAllowThreads();
27042 {
27043 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27044 result = (wxDateTime *) &_result_ref;
27045 }
27046 wxPyEndAllowThreads(__tstate);
27047 if (PyErr_Occurred()) SWIG_fail;
27048 }
27049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27050 return resultobj;
27051 fail:
27052 return NULL;
27053 }
27054
27055
27056 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27057 PyObject *resultobj = 0;
27058 wxDateTime *arg1 = (wxDateTime *) 0 ;
27059 wxDateSpan *arg2 = 0 ;
27060 wxDateTime *result = 0 ;
27061 void *argp1 = 0 ;
27062 int res1 = 0 ;
27063 void *argp2 = 0 ;
27064 int res2 = 0 ;
27065 PyObject * obj0 = 0 ;
27066 PyObject * obj1 = 0 ;
27067 char * kwnames[] = {
27068 (char *) "self",(char *) "diff", NULL
27069 };
27070
27071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27073 if (!SWIG_IsOK(res1)) {
27074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27075 }
27076 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27077 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27078 if (!SWIG_IsOK(res2)) {
27079 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27080 }
27081 if (!argp2) {
27082 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27083 }
27084 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27085 {
27086 PyThreadState* __tstate = wxPyBeginAllowThreads();
27087 {
27088 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27089 result = (wxDateTime *) &_result_ref;
27090 }
27091 wxPyEndAllowThreads(__tstate);
27092 if (PyErr_Occurred()) SWIG_fail;
27093 }
27094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27095 return resultobj;
27096 fail:
27097 return NULL;
27098 }
27099
27100
27101 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27102 PyObject *resultobj = 0;
27103 wxDateTime *arg1 = (wxDateTime *) 0 ;
27104 wxTimeSpan *arg2 = 0 ;
27105 wxDateTime *result = 0 ;
27106 void *argp1 = 0 ;
27107 int res1 = 0 ;
27108 void *argp2 = 0 ;
27109 int res2 = 0 ;
27110 PyObject * obj0 = 0 ;
27111 PyObject * obj1 = 0 ;
27112 char * kwnames[] = {
27113 (char *) "self",(char *) "diff", NULL
27114 };
27115
27116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27118 if (!SWIG_IsOK(res1)) {
27119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27120 }
27121 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27122 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27123 if (!SWIG_IsOK(res2)) {
27124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27125 }
27126 if (!argp2) {
27127 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27128 }
27129 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27130 {
27131 PyThreadState* __tstate = wxPyBeginAllowThreads();
27132 {
27133 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27134 result = (wxDateTime *) &_result_ref;
27135 }
27136 wxPyEndAllowThreads(__tstate);
27137 if (PyErr_Occurred()) SWIG_fail;
27138 }
27139 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27140 return resultobj;
27141 fail:
27142 return NULL;
27143 }
27144
27145
27146 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27147 PyObject *resultobj = 0;
27148 wxDateTime *arg1 = (wxDateTime *) 0 ;
27149 wxDateSpan *arg2 = 0 ;
27150 wxDateTime *result = 0 ;
27151 void *argp1 = 0 ;
27152 int res1 = 0 ;
27153 void *argp2 = 0 ;
27154 int res2 = 0 ;
27155 PyObject * obj0 = 0 ;
27156 PyObject * obj1 = 0 ;
27157 char * kwnames[] = {
27158 (char *) "self",(char *) "diff", NULL
27159 };
27160
27161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27163 if (!SWIG_IsOK(res1)) {
27164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27165 }
27166 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27167 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27168 if (!SWIG_IsOK(res2)) {
27169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27170 }
27171 if (!argp2) {
27172 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27173 }
27174 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27175 {
27176 PyThreadState* __tstate = wxPyBeginAllowThreads();
27177 {
27178 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27179 result = (wxDateTime *) &_result_ref;
27180 }
27181 wxPyEndAllowThreads(__tstate);
27182 if (PyErr_Occurred()) SWIG_fail;
27183 }
27184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27185 return resultobj;
27186 fail:
27187 return NULL;
27188 }
27189
27190
27191 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27192 PyObject *resultobj = 0;
27193 wxDateTime *arg1 = (wxDateTime *) 0 ;
27194 wxDateTime *arg2 = 0 ;
27195 wxTimeSpan result;
27196 void *argp1 = 0 ;
27197 int res1 = 0 ;
27198 void *argp2 = 0 ;
27199 int res2 = 0 ;
27200 PyObject * obj0 = 0 ;
27201 PyObject * obj1 = 0 ;
27202 char * kwnames[] = {
27203 (char *) "self",(char *) "dt", NULL
27204 };
27205
27206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27208 if (!SWIG_IsOK(res1)) {
27209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27210 }
27211 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27212 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27213 if (!SWIG_IsOK(res2)) {
27214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27215 }
27216 if (!argp2) {
27217 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27218 }
27219 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27220 {
27221 PyThreadState* __tstate = wxPyBeginAllowThreads();
27222 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27223 wxPyEndAllowThreads(__tstate);
27224 if (PyErr_Occurred()) SWIG_fail;
27225 }
27226 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27227 return resultobj;
27228 fail:
27229 return NULL;
27230 }
27231
27232
27233 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27234 PyObject *resultobj = 0;
27235 wxDateTime *arg1 = (wxDateTime *) 0 ;
27236 wxTimeSpan *arg2 = 0 ;
27237 wxDateTime *result = 0 ;
27238 void *argp1 = 0 ;
27239 int res1 = 0 ;
27240 void *argp2 = 0 ;
27241 int res2 = 0 ;
27242
27243 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27245 if (!SWIG_IsOK(res1)) {
27246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27247 }
27248 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27249 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27250 if (!SWIG_IsOK(res2)) {
27251 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27252 }
27253 if (!argp2) {
27254 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27255 }
27256 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27257 {
27258 PyThreadState* __tstate = wxPyBeginAllowThreads();
27259 {
27260 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27261 result = (wxDateTime *) &_result_ref;
27262 }
27263 wxPyEndAllowThreads(__tstate);
27264 if (PyErr_Occurred()) SWIG_fail;
27265 }
27266 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27267 return resultobj;
27268 fail:
27269 return NULL;
27270 }
27271
27272
27273 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27274 PyObject *resultobj = 0;
27275 wxDateTime *arg1 = (wxDateTime *) 0 ;
27276 wxDateSpan *arg2 = 0 ;
27277 wxDateTime *result = 0 ;
27278 void *argp1 = 0 ;
27279 int res1 = 0 ;
27280 void *argp2 = 0 ;
27281 int res2 = 0 ;
27282
27283 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27285 if (!SWIG_IsOK(res1)) {
27286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27287 }
27288 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27289 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27290 if (!SWIG_IsOK(res2)) {
27291 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27292 }
27293 if (!argp2) {
27294 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27295 }
27296 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27297 {
27298 PyThreadState* __tstate = wxPyBeginAllowThreads();
27299 {
27300 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27301 result = (wxDateTime *) &_result_ref;
27302 }
27303 wxPyEndAllowThreads(__tstate);
27304 if (PyErr_Occurred()) SWIG_fail;
27305 }
27306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27307 return resultobj;
27308 fail:
27309 return NULL;
27310 }
27311
27312
27313 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27314 int argc;
27315 PyObject *argv[3];
27316
27317 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27318 --argc;
27319 if (argc == 2) {
27320 int _v = 0;
27321 {
27322 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27323 _v = SWIG_CheckState(res);
27324 }
27325 if (!_v) goto check_1;
27326 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27327 }
27328 check_1:
27329
27330 if (argc == 2) {
27331 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27332 }
27333
27334 fail:
27335 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27336 return NULL;
27337 }
27338
27339
27340 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27341 PyObject *resultobj = 0;
27342 wxDateTime *arg1 = (wxDateTime *) 0 ;
27343 wxTimeSpan *arg2 = 0 ;
27344 wxDateTime *result = 0 ;
27345 void *argp1 = 0 ;
27346 int res1 = 0 ;
27347 void *argp2 = 0 ;
27348 int res2 = 0 ;
27349
27350 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27352 if (!SWIG_IsOK(res1)) {
27353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27354 }
27355 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27356 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27357 if (!SWIG_IsOK(res2)) {
27358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27359 }
27360 if (!argp2) {
27361 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27362 }
27363 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27364 {
27365 PyThreadState* __tstate = wxPyBeginAllowThreads();
27366 {
27367 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27368 result = (wxDateTime *) &_result_ref;
27369 }
27370 wxPyEndAllowThreads(__tstate);
27371 if (PyErr_Occurred()) SWIG_fail;
27372 }
27373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27374 return resultobj;
27375 fail:
27376 return NULL;
27377 }
27378
27379
27380 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27381 PyObject *resultobj = 0;
27382 wxDateTime *arg1 = (wxDateTime *) 0 ;
27383 wxDateSpan *arg2 = 0 ;
27384 wxDateTime *result = 0 ;
27385 void *argp1 = 0 ;
27386 int res1 = 0 ;
27387 void *argp2 = 0 ;
27388 int res2 = 0 ;
27389
27390 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27392 if (!SWIG_IsOK(res1)) {
27393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27394 }
27395 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27396 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27397 if (!SWIG_IsOK(res2)) {
27398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27399 }
27400 if (!argp2) {
27401 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27402 }
27403 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27404 {
27405 PyThreadState* __tstate = wxPyBeginAllowThreads();
27406 {
27407 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27408 result = (wxDateTime *) &_result_ref;
27409 }
27410 wxPyEndAllowThreads(__tstate);
27411 if (PyErr_Occurred()) SWIG_fail;
27412 }
27413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27414 return resultobj;
27415 fail:
27416 return NULL;
27417 }
27418
27419
27420 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27421 int argc;
27422 PyObject *argv[3];
27423
27424 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27425 --argc;
27426 if (argc == 2) {
27427 int _v = 0;
27428 {
27429 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27430 _v = SWIG_CheckState(res);
27431 }
27432 if (!_v) goto check_1;
27433 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27434 }
27435 check_1:
27436
27437 if (argc == 2) {
27438 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27439 }
27440
27441 fail:
27442 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27443 return NULL;
27444 }
27445
27446
27447 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27448 PyObject *resultobj = 0;
27449 wxDateTime *arg1 = (wxDateTime *) 0 ;
27450 wxTimeSpan *arg2 = 0 ;
27451 wxDateTime result;
27452 void *argp1 = 0 ;
27453 int res1 = 0 ;
27454 void *argp2 = 0 ;
27455 int res2 = 0 ;
27456
27457 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27459 if (!SWIG_IsOK(res1)) {
27460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27461 }
27462 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27463 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27464 if (!SWIG_IsOK(res2)) {
27465 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27466 }
27467 if (!argp2) {
27468 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27469 }
27470 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27471 {
27472 PyThreadState* __tstate = wxPyBeginAllowThreads();
27473 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27474 wxPyEndAllowThreads(__tstate);
27475 if (PyErr_Occurred()) SWIG_fail;
27476 }
27477 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27478 return resultobj;
27479 fail:
27480 return NULL;
27481 }
27482
27483
27484 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27485 PyObject *resultobj = 0;
27486 wxDateTime *arg1 = (wxDateTime *) 0 ;
27487 wxDateSpan *arg2 = 0 ;
27488 wxDateTime result;
27489 void *argp1 = 0 ;
27490 int res1 = 0 ;
27491 void *argp2 = 0 ;
27492 int res2 = 0 ;
27493
27494 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27496 if (!SWIG_IsOK(res1)) {
27497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27498 }
27499 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27500 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27501 if (!SWIG_IsOK(res2)) {
27502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27503 }
27504 if (!argp2) {
27505 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27506 }
27507 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27508 {
27509 PyThreadState* __tstate = wxPyBeginAllowThreads();
27510 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27511 wxPyEndAllowThreads(__tstate);
27512 if (PyErr_Occurred()) SWIG_fail;
27513 }
27514 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27515 return resultobj;
27516 fail:
27517 return NULL;
27518 }
27519
27520
27521 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27522 int argc;
27523 PyObject *argv[3];
27524
27525 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27526 --argc;
27527 if (argc == 2) {
27528 int _v = 0;
27529 {
27530 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27531 _v = SWIG_CheckState(res);
27532 }
27533 if (!_v) goto check_1;
27534 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27535 }
27536 check_1:
27537
27538 if (argc == 2) {
27539 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27540 }
27541
27542 fail:
27543 Py_INCREF(Py_NotImplemented);
27544 return Py_NotImplemented;
27545 }
27546
27547
27548 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27549 PyObject *resultobj = 0;
27550 wxDateTime *arg1 = (wxDateTime *) 0 ;
27551 wxDateTime *arg2 = 0 ;
27552 wxTimeSpan result;
27553 void *argp1 = 0 ;
27554 int res1 = 0 ;
27555 void *argp2 = 0 ;
27556 int res2 = 0 ;
27557
27558 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27560 if (!SWIG_IsOK(res1)) {
27561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27562 }
27563 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27564 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27565 if (!SWIG_IsOK(res2)) {
27566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27567 }
27568 if (!argp2) {
27569 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27570 }
27571 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27572 {
27573 PyThreadState* __tstate = wxPyBeginAllowThreads();
27574 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27575 wxPyEndAllowThreads(__tstate);
27576 if (PyErr_Occurred()) SWIG_fail;
27577 }
27578 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27579 return resultobj;
27580 fail:
27581 return NULL;
27582 }
27583
27584
27585 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27586 PyObject *resultobj = 0;
27587 wxDateTime *arg1 = (wxDateTime *) 0 ;
27588 wxTimeSpan *arg2 = 0 ;
27589 wxDateTime result;
27590 void *argp1 = 0 ;
27591 int res1 = 0 ;
27592 void *argp2 = 0 ;
27593 int res2 = 0 ;
27594
27595 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27597 if (!SWIG_IsOK(res1)) {
27598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27599 }
27600 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27601 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27602 if (!SWIG_IsOK(res2)) {
27603 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27604 }
27605 if (!argp2) {
27606 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27607 }
27608 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27609 {
27610 PyThreadState* __tstate = wxPyBeginAllowThreads();
27611 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27612 wxPyEndAllowThreads(__tstate);
27613 if (PyErr_Occurred()) SWIG_fail;
27614 }
27615 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27616 return resultobj;
27617 fail:
27618 return NULL;
27619 }
27620
27621
27622 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27623 PyObject *resultobj = 0;
27624 wxDateTime *arg1 = (wxDateTime *) 0 ;
27625 wxDateSpan *arg2 = 0 ;
27626 wxDateTime result;
27627 void *argp1 = 0 ;
27628 int res1 = 0 ;
27629 void *argp2 = 0 ;
27630 int res2 = 0 ;
27631
27632 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27634 if (!SWIG_IsOK(res1)) {
27635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27636 }
27637 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27638 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27639 if (!SWIG_IsOK(res2)) {
27640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27641 }
27642 if (!argp2) {
27643 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27644 }
27645 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27646 {
27647 PyThreadState* __tstate = wxPyBeginAllowThreads();
27648 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27649 wxPyEndAllowThreads(__tstate);
27650 if (PyErr_Occurred()) SWIG_fail;
27651 }
27652 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27653 return resultobj;
27654 fail:
27655 return NULL;
27656 }
27657
27658
27659 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27660 int argc;
27661 PyObject *argv[3];
27662
27663 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27664 --argc;
27665 if (argc == 2) {
27666 int _v = 0;
27667 {
27668 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27669 _v = SWIG_CheckState(res);
27670 }
27671 if (!_v) goto check_1;
27672 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27673 }
27674 check_1:
27675
27676 if (argc == 2) {
27677 int _v = 0;
27678 {
27679 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27680 _v = SWIG_CheckState(res);
27681 }
27682 if (!_v) goto check_2;
27683 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27684 }
27685 check_2:
27686
27687 if (argc == 2) {
27688 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27689 }
27690
27691 fail:
27692 Py_INCREF(Py_NotImplemented);
27693 return Py_NotImplemented;
27694 }
27695
27696
27697 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27698 PyObject *resultobj = 0;
27699 wxDateTime *arg1 = (wxDateTime *) 0 ;
27700 wxDateTime *arg2 = (wxDateTime *) 0 ;
27701 bool result;
27702 void *argp1 = 0 ;
27703 int res1 = 0 ;
27704 void *argp2 = 0 ;
27705 int res2 = 0 ;
27706 PyObject * obj0 = 0 ;
27707 PyObject * obj1 = 0 ;
27708 char * kwnames[] = {
27709 (char *) "self",(char *) "other", NULL
27710 };
27711
27712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27714 if (!SWIG_IsOK(res1)) {
27715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27716 }
27717 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27718 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27719 if (!SWIG_IsOK(res2)) {
27720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27721 }
27722 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27723 {
27724 PyThreadState* __tstate = wxPyBeginAllowThreads();
27725 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27726 wxPyEndAllowThreads(__tstate);
27727 if (PyErr_Occurred()) SWIG_fail;
27728 }
27729 {
27730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27731 }
27732 return resultobj;
27733 fail:
27734 return NULL;
27735 }
27736
27737
27738 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27739 PyObject *resultobj = 0;
27740 wxDateTime *arg1 = (wxDateTime *) 0 ;
27741 wxDateTime *arg2 = (wxDateTime *) 0 ;
27742 bool result;
27743 void *argp1 = 0 ;
27744 int res1 = 0 ;
27745 void *argp2 = 0 ;
27746 int res2 = 0 ;
27747 PyObject * obj0 = 0 ;
27748 PyObject * obj1 = 0 ;
27749 char * kwnames[] = {
27750 (char *) "self",(char *) "other", NULL
27751 };
27752
27753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27755 if (!SWIG_IsOK(res1)) {
27756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27757 }
27758 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27759 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27760 if (!SWIG_IsOK(res2)) {
27761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27762 }
27763 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27764 {
27765 PyThreadState* __tstate = wxPyBeginAllowThreads();
27766 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27767 wxPyEndAllowThreads(__tstate);
27768 if (PyErr_Occurred()) SWIG_fail;
27769 }
27770 {
27771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27772 }
27773 return resultobj;
27774 fail:
27775 return NULL;
27776 }
27777
27778
27779 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27780 PyObject *resultobj = 0;
27781 wxDateTime *arg1 = (wxDateTime *) 0 ;
27782 wxDateTime *arg2 = (wxDateTime *) 0 ;
27783 bool result;
27784 void *argp1 = 0 ;
27785 int res1 = 0 ;
27786 void *argp2 = 0 ;
27787 int res2 = 0 ;
27788 PyObject * obj0 = 0 ;
27789 PyObject * obj1 = 0 ;
27790 char * kwnames[] = {
27791 (char *) "self",(char *) "other", NULL
27792 };
27793
27794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
27795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27796 if (!SWIG_IsOK(res1)) {
27797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27798 }
27799 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27800 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27801 if (!SWIG_IsOK(res2)) {
27802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27803 }
27804 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27805 {
27806 PyThreadState* __tstate = wxPyBeginAllowThreads();
27807 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
27808 wxPyEndAllowThreads(__tstate);
27809 if (PyErr_Occurred()) SWIG_fail;
27810 }
27811 {
27812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27813 }
27814 return resultobj;
27815 fail:
27816 return NULL;
27817 }
27818
27819
27820 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27821 PyObject *resultobj = 0;
27822 wxDateTime *arg1 = (wxDateTime *) 0 ;
27823 wxDateTime *arg2 = (wxDateTime *) 0 ;
27824 bool result;
27825 void *argp1 = 0 ;
27826 int res1 = 0 ;
27827 void *argp2 = 0 ;
27828 int res2 = 0 ;
27829 PyObject * obj0 = 0 ;
27830 PyObject * obj1 = 0 ;
27831 char * kwnames[] = {
27832 (char *) "self",(char *) "other", NULL
27833 };
27834
27835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
27836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27837 if (!SWIG_IsOK(res1)) {
27838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27839 }
27840 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27841 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27842 if (!SWIG_IsOK(res2)) {
27843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27844 }
27845 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27846 {
27847 PyThreadState* __tstate = wxPyBeginAllowThreads();
27848 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
27849 wxPyEndAllowThreads(__tstate);
27850 if (PyErr_Occurred()) SWIG_fail;
27851 }
27852 {
27853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27854 }
27855 return resultobj;
27856 fail:
27857 return NULL;
27858 }
27859
27860
27861 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27862 PyObject *resultobj = 0;
27863 wxDateTime *arg1 = (wxDateTime *) 0 ;
27864 wxDateTime *arg2 = (wxDateTime *) 0 ;
27865 bool result;
27866 void *argp1 = 0 ;
27867 int res1 = 0 ;
27868 void *argp2 = 0 ;
27869 int res2 = 0 ;
27870 PyObject * obj0 = 0 ;
27871 PyObject * obj1 = 0 ;
27872 char * kwnames[] = {
27873 (char *) "self",(char *) "other", NULL
27874 };
27875
27876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
27877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27878 if (!SWIG_IsOK(res1)) {
27879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27880 }
27881 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27882 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27883 if (!SWIG_IsOK(res2)) {
27884 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27885 }
27886 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27887 {
27888 PyThreadState* __tstate = wxPyBeginAllowThreads();
27889 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
27890 wxPyEndAllowThreads(__tstate);
27891 if (PyErr_Occurred()) SWIG_fail;
27892 }
27893 {
27894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27895 }
27896 return resultobj;
27897 fail:
27898 return NULL;
27899 }
27900
27901
27902 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27903 PyObject *resultobj = 0;
27904 wxDateTime *arg1 = (wxDateTime *) 0 ;
27905 wxDateTime *arg2 = (wxDateTime *) 0 ;
27906 bool result;
27907 void *argp1 = 0 ;
27908 int res1 = 0 ;
27909 void *argp2 = 0 ;
27910 int res2 = 0 ;
27911 PyObject * obj0 = 0 ;
27912 PyObject * obj1 = 0 ;
27913 char * kwnames[] = {
27914 (char *) "self",(char *) "other", NULL
27915 };
27916
27917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
27918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27919 if (!SWIG_IsOK(res1)) {
27920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27921 }
27922 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27923 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27924 if (!SWIG_IsOK(res2)) {
27925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27926 }
27927 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27928 {
27929 PyThreadState* __tstate = wxPyBeginAllowThreads();
27930 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
27931 wxPyEndAllowThreads(__tstate);
27932 if (PyErr_Occurred()) SWIG_fail;
27933 }
27934 {
27935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27936 }
27937 return resultobj;
27938 fail:
27939 return NULL;
27940 }
27941
27942
27943 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27944 PyObject *resultobj = 0;
27945 wxDateTime *arg1 = (wxDateTime *) 0 ;
27946 wxString *arg2 = 0 ;
27947 int result;
27948 void *argp1 = 0 ;
27949 int res1 = 0 ;
27950 bool temp2 = false ;
27951 PyObject * obj0 = 0 ;
27952 PyObject * obj1 = 0 ;
27953 char * kwnames[] = {
27954 (char *) "self",(char *) "date", NULL
27955 };
27956
27957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
27958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27959 if (!SWIG_IsOK(res1)) {
27960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
27961 }
27962 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27963 {
27964 arg2 = wxString_in_helper(obj1);
27965 if (arg2 == NULL) SWIG_fail;
27966 temp2 = true;
27967 }
27968 {
27969 PyThreadState* __tstate = wxPyBeginAllowThreads();
27970 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
27971 wxPyEndAllowThreads(__tstate);
27972 if (PyErr_Occurred()) SWIG_fail;
27973 }
27974 resultobj = SWIG_From_int(static_cast< int >(result));
27975 {
27976 if (temp2)
27977 delete arg2;
27978 }
27979 return resultobj;
27980 fail:
27981 {
27982 if (temp2)
27983 delete arg2;
27984 }
27985 return NULL;
27986 }
27987
27988
27989 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27990 PyObject *resultobj = 0;
27991 wxDateTime *arg1 = (wxDateTime *) 0 ;
27992 wxString *arg2 = 0 ;
27993 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
27994 wxString *arg3 = (wxString *) &arg3_defvalue ;
27995 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
27996 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
27997 int result;
27998 void *argp1 = 0 ;
27999 int res1 = 0 ;
28000 bool temp2 = false ;
28001 bool temp3 = false ;
28002 void *argp4 = 0 ;
28003 int res4 = 0 ;
28004 PyObject * obj0 = 0 ;
28005 PyObject * obj1 = 0 ;
28006 PyObject * obj2 = 0 ;
28007 PyObject * obj3 = 0 ;
28008 char * kwnames[] = {
28009 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28010 };
28011
28012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28014 if (!SWIG_IsOK(res1)) {
28015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28016 }
28017 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28018 {
28019 arg2 = wxString_in_helper(obj1);
28020 if (arg2 == NULL) SWIG_fail;
28021 temp2 = true;
28022 }
28023 if (obj2) {
28024 {
28025 arg3 = wxString_in_helper(obj2);
28026 if (arg3 == NULL) SWIG_fail;
28027 temp3 = true;
28028 }
28029 }
28030 if (obj3) {
28031 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28032 if (!SWIG_IsOK(res4)) {
28033 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28034 }
28035 if (!argp4) {
28036 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28037 }
28038 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28039 }
28040 {
28041 PyThreadState* __tstate = wxPyBeginAllowThreads();
28042 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28043 wxPyEndAllowThreads(__tstate);
28044 if (PyErr_Occurred()) SWIG_fail;
28045 }
28046 resultobj = SWIG_From_int(static_cast< int >(result));
28047 {
28048 if (temp2)
28049 delete arg2;
28050 }
28051 {
28052 if (temp3)
28053 delete arg3;
28054 }
28055 return resultobj;
28056 fail:
28057 {
28058 if (temp2)
28059 delete arg2;
28060 }
28061 {
28062 if (temp3)
28063 delete arg3;
28064 }
28065 return NULL;
28066 }
28067
28068
28069 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28070 PyObject *resultobj = 0;
28071 wxDateTime *arg1 = (wxDateTime *) 0 ;
28072 wxString *arg2 = 0 ;
28073 int result;
28074 void *argp1 = 0 ;
28075 int res1 = 0 ;
28076 bool temp2 = false ;
28077 PyObject * obj0 = 0 ;
28078 PyObject * obj1 = 0 ;
28079 char * kwnames[] = {
28080 (char *) "self",(char *) "datetime", NULL
28081 };
28082
28083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28085 if (!SWIG_IsOK(res1)) {
28086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28087 }
28088 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28089 {
28090 arg2 = wxString_in_helper(obj1);
28091 if (arg2 == NULL) SWIG_fail;
28092 temp2 = true;
28093 }
28094 {
28095 PyThreadState* __tstate = wxPyBeginAllowThreads();
28096 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28097 wxPyEndAllowThreads(__tstate);
28098 if (PyErr_Occurred()) SWIG_fail;
28099 }
28100 resultobj = SWIG_From_int(static_cast< int >(result));
28101 {
28102 if (temp2)
28103 delete arg2;
28104 }
28105 return resultobj;
28106 fail:
28107 {
28108 if (temp2)
28109 delete arg2;
28110 }
28111 return NULL;
28112 }
28113
28114
28115 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28116 PyObject *resultobj = 0;
28117 wxDateTime *arg1 = (wxDateTime *) 0 ;
28118 wxString *arg2 = 0 ;
28119 int result;
28120 void *argp1 = 0 ;
28121 int res1 = 0 ;
28122 bool temp2 = false ;
28123 PyObject * obj0 = 0 ;
28124 PyObject * obj1 = 0 ;
28125 char * kwnames[] = {
28126 (char *) "self",(char *) "date", NULL
28127 };
28128
28129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28131 if (!SWIG_IsOK(res1)) {
28132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28133 }
28134 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28135 {
28136 arg2 = wxString_in_helper(obj1);
28137 if (arg2 == NULL) SWIG_fail;
28138 temp2 = true;
28139 }
28140 {
28141 PyThreadState* __tstate = wxPyBeginAllowThreads();
28142 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28143 wxPyEndAllowThreads(__tstate);
28144 if (PyErr_Occurred()) SWIG_fail;
28145 }
28146 resultobj = SWIG_From_int(static_cast< int >(result));
28147 {
28148 if (temp2)
28149 delete arg2;
28150 }
28151 return resultobj;
28152 fail:
28153 {
28154 if (temp2)
28155 delete arg2;
28156 }
28157 return NULL;
28158 }
28159
28160
28161 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28162 PyObject *resultobj = 0;
28163 wxDateTime *arg1 = (wxDateTime *) 0 ;
28164 wxString *arg2 = 0 ;
28165 int result;
28166 void *argp1 = 0 ;
28167 int res1 = 0 ;
28168 bool temp2 = false ;
28169 PyObject * obj0 = 0 ;
28170 PyObject * obj1 = 0 ;
28171 char * kwnames[] = {
28172 (char *) "self",(char *) "time", NULL
28173 };
28174
28175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28177 if (!SWIG_IsOK(res1)) {
28178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28179 }
28180 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28181 {
28182 arg2 = wxString_in_helper(obj1);
28183 if (arg2 == NULL) SWIG_fail;
28184 temp2 = true;
28185 }
28186 {
28187 PyThreadState* __tstate = wxPyBeginAllowThreads();
28188 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28189 wxPyEndAllowThreads(__tstate);
28190 if (PyErr_Occurred()) SWIG_fail;
28191 }
28192 resultobj = SWIG_From_int(static_cast< int >(result));
28193 {
28194 if (temp2)
28195 delete arg2;
28196 }
28197 return resultobj;
28198 fail:
28199 {
28200 if (temp2)
28201 delete arg2;
28202 }
28203 return NULL;
28204 }
28205
28206
28207 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28208 PyObject *resultobj = 0;
28209 wxDateTime *arg1 = (wxDateTime *) 0 ;
28210 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28211 wxString *arg2 = (wxString *) &arg2_defvalue ;
28212 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28213 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28214 wxString result;
28215 void *argp1 = 0 ;
28216 int res1 = 0 ;
28217 bool temp2 = false ;
28218 bool temp3 = false ;
28219 PyObject * obj0 = 0 ;
28220 PyObject * obj1 = 0 ;
28221 PyObject * obj2 = 0 ;
28222 char * kwnames[] = {
28223 (char *) "self",(char *) "format",(char *) "tz", NULL
28224 };
28225
28226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28228 if (!SWIG_IsOK(res1)) {
28229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28230 }
28231 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28232 if (obj1) {
28233 {
28234 arg2 = wxString_in_helper(obj1);
28235 if (arg2 == NULL) SWIG_fail;
28236 temp2 = true;
28237 }
28238 }
28239 if (obj2) {
28240 {
28241 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28242 temp3 = true;
28243 }
28244 }
28245 {
28246 PyThreadState* __tstate = wxPyBeginAllowThreads();
28247 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28248 wxPyEndAllowThreads(__tstate);
28249 if (PyErr_Occurred()) SWIG_fail;
28250 }
28251 {
28252 #if wxUSE_UNICODE
28253 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28254 #else
28255 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28256 #endif
28257 }
28258 {
28259 if (temp2)
28260 delete arg2;
28261 }
28262 {
28263 if (temp3) delete arg3;
28264 }
28265 return resultobj;
28266 fail:
28267 {
28268 if (temp2)
28269 delete arg2;
28270 }
28271 {
28272 if (temp3) delete arg3;
28273 }
28274 return NULL;
28275 }
28276
28277
28278 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28279 PyObject *resultobj = 0;
28280 wxDateTime *arg1 = (wxDateTime *) 0 ;
28281 wxString result;
28282 void *argp1 = 0 ;
28283 int res1 = 0 ;
28284 PyObject *swig_obj[1] ;
28285
28286 if (!args) SWIG_fail;
28287 swig_obj[0] = args;
28288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28289 if (!SWIG_IsOK(res1)) {
28290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28291 }
28292 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28293 {
28294 PyThreadState* __tstate = wxPyBeginAllowThreads();
28295 result = ((wxDateTime const *)arg1)->FormatDate();
28296 wxPyEndAllowThreads(__tstate);
28297 if (PyErr_Occurred()) SWIG_fail;
28298 }
28299 {
28300 #if wxUSE_UNICODE
28301 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28302 #else
28303 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28304 #endif
28305 }
28306 return resultobj;
28307 fail:
28308 return NULL;
28309 }
28310
28311
28312 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28313 PyObject *resultobj = 0;
28314 wxDateTime *arg1 = (wxDateTime *) 0 ;
28315 wxString result;
28316 void *argp1 = 0 ;
28317 int res1 = 0 ;
28318 PyObject *swig_obj[1] ;
28319
28320 if (!args) SWIG_fail;
28321 swig_obj[0] = args;
28322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28323 if (!SWIG_IsOK(res1)) {
28324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28325 }
28326 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28327 {
28328 PyThreadState* __tstate = wxPyBeginAllowThreads();
28329 result = ((wxDateTime const *)arg1)->FormatTime();
28330 wxPyEndAllowThreads(__tstate);
28331 if (PyErr_Occurred()) SWIG_fail;
28332 }
28333 {
28334 #if wxUSE_UNICODE
28335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28336 #else
28337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28338 #endif
28339 }
28340 return resultobj;
28341 fail:
28342 return NULL;
28343 }
28344
28345
28346 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28347 PyObject *resultobj = 0;
28348 wxDateTime *arg1 = (wxDateTime *) 0 ;
28349 wxString result;
28350 void *argp1 = 0 ;
28351 int res1 = 0 ;
28352 PyObject *swig_obj[1] ;
28353
28354 if (!args) SWIG_fail;
28355 swig_obj[0] = args;
28356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28357 if (!SWIG_IsOK(res1)) {
28358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28359 }
28360 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28361 {
28362 PyThreadState* __tstate = wxPyBeginAllowThreads();
28363 result = ((wxDateTime const *)arg1)->FormatISODate();
28364 wxPyEndAllowThreads(__tstate);
28365 if (PyErr_Occurred()) SWIG_fail;
28366 }
28367 {
28368 #if wxUSE_UNICODE
28369 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28370 #else
28371 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28372 #endif
28373 }
28374 return resultobj;
28375 fail:
28376 return NULL;
28377 }
28378
28379
28380 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28381 PyObject *resultobj = 0;
28382 wxDateTime *arg1 = (wxDateTime *) 0 ;
28383 wxString result;
28384 void *argp1 = 0 ;
28385 int res1 = 0 ;
28386 PyObject *swig_obj[1] ;
28387
28388 if (!args) SWIG_fail;
28389 swig_obj[0] = args;
28390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28391 if (!SWIG_IsOK(res1)) {
28392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28393 }
28394 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28395 {
28396 PyThreadState* __tstate = wxPyBeginAllowThreads();
28397 result = ((wxDateTime const *)arg1)->FormatISOTime();
28398 wxPyEndAllowThreads(__tstate);
28399 if (PyErr_Occurred()) SWIG_fail;
28400 }
28401 {
28402 #if wxUSE_UNICODE
28403 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28404 #else
28405 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28406 #endif
28407 }
28408 return resultobj;
28409 fail:
28410 return NULL;
28411 }
28412
28413
28414 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28415 PyObject *obj;
28416 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28417 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28418 return SWIG_Py_Void();
28419 }
28420
28421 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28422 return SWIG_Python_InitShadowInstance(args);
28423 }
28424
28425 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28426 PyObject *resultobj = 0;
28427 long arg1 ;
28428 wxTimeSpan result;
28429 long val1 ;
28430 int ecode1 = 0 ;
28431 PyObject * obj0 = 0 ;
28432 char * kwnames[] = {
28433 (char *) "ms", NULL
28434 };
28435
28436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28437 ecode1 = SWIG_AsVal_long(obj0, &val1);
28438 if (!SWIG_IsOK(ecode1)) {
28439 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28440 }
28441 arg1 = static_cast< long >(val1);
28442 {
28443 PyThreadState* __tstate = wxPyBeginAllowThreads();
28444 result = wxTimeSpan::Milliseconds(arg1);
28445 wxPyEndAllowThreads(__tstate);
28446 if (PyErr_Occurred()) SWIG_fail;
28447 }
28448 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28449 return resultobj;
28450 fail:
28451 return NULL;
28452 }
28453
28454
28455 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28456 PyObject *resultobj = 0;
28457 wxTimeSpan result;
28458
28459 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28460 {
28461 PyThreadState* __tstate = wxPyBeginAllowThreads();
28462 result = wxTimeSpan::Millisecond();
28463 wxPyEndAllowThreads(__tstate);
28464 if (PyErr_Occurred()) SWIG_fail;
28465 }
28466 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28467 return resultobj;
28468 fail:
28469 return NULL;
28470 }
28471
28472
28473 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28474 PyObject *resultobj = 0;
28475 long arg1 ;
28476 wxTimeSpan result;
28477 long val1 ;
28478 int ecode1 = 0 ;
28479 PyObject * obj0 = 0 ;
28480 char * kwnames[] = {
28481 (char *) "sec", NULL
28482 };
28483
28484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28485 ecode1 = SWIG_AsVal_long(obj0, &val1);
28486 if (!SWIG_IsOK(ecode1)) {
28487 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28488 }
28489 arg1 = static_cast< long >(val1);
28490 {
28491 PyThreadState* __tstate = wxPyBeginAllowThreads();
28492 result = wxTimeSpan::Seconds(arg1);
28493 wxPyEndAllowThreads(__tstate);
28494 if (PyErr_Occurred()) SWIG_fail;
28495 }
28496 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28497 return resultobj;
28498 fail:
28499 return NULL;
28500 }
28501
28502
28503 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28504 PyObject *resultobj = 0;
28505 wxTimeSpan result;
28506
28507 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28508 {
28509 PyThreadState* __tstate = wxPyBeginAllowThreads();
28510 result = wxTimeSpan::Second();
28511 wxPyEndAllowThreads(__tstate);
28512 if (PyErr_Occurred()) SWIG_fail;
28513 }
28514 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28515 return resultobj;
28516 fail:
28517 return NULL;
28518 }
28519
28520
28521 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28522 PyObject *resultobj = 0;
28523 long arg1 ;
28524 wxTimeSpan result;
28525 long val1 ;
28526 int ecode1 = 0 ;
28527 PyObject * obj0 = 0 ;
28528 char * kwnames[] = {
28529 (char *) "min", NULL
28530 };
28531
28532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28533 ecode1 = SWIG_AsVal_long(obj0, &val1);
28534 if (!SWIG_IsOK(ecode1)) {
28535 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28536 }
28537 arg1 = static_cast< long >(val1);
28538 {
28539 PyThreadState* __tstate = wxPyBeginAllowThreads();
28540 result = wxTimeSpan::Minutes(arg1);
28541 wxPyEndAllowThreads(__tstate);
28542 if (PyErr_Occurred()) SWIG_fail;
28543 }
28544 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28545 return resultobj;
28546 fail:
28547 return NULL;
28548 }
28549
28550
28551 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28552 PyObject *resultobj = 0;
28553 wxTimeSpan result;
28554
28555 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28556 {
28557 PyThreadState* __tstate = wxPyBeginAllowThreads();
28558 result = wxTimeSpan::Minute();
28559 wxPyEndAllowThreads(__tstate);
28560 if (PyErr_Occurred()) SWIG_fail;
28561 }
28562 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28563 return resultobj;
28564 fail:
28565 return NULL;
28566 }
28567
28568
28569 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28570 PyObject *resultobj = 0;
28571 long arg1 ;
28572 wxTimeSpan result;
28573 long val1 ;
28574 int ecode1 = 0 ;
28575 PyObject * obj0 = 0 ;
28576 char * kwnames[] = {
28577 (char *) "hours", NULL
28578 };
28579
28580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28581 ecode1 = SWIG_AsVal_long(obj0, &val1);
28582 if (!SWIG_IsOK(ecode1)) {
28583 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28584 }
28585 arg1 = static_cast< long >(val1);
28586 {
28587 PyThreadState* __tstate = wxPyBeginAllowThreads();
28588 result = wxTimeSpan::Hours(arg1);
28589 wxPyEndAllowThreads(__tstate);
28590 if (PyErr_Occurred()) SWIG_fail;
28591 }
28592 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28593 return resultobj;
28594 fail:
28595 return NULL;
28596 }
28597
28598
28599 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28600 PyObject *resultobj = 0;
28601 wxTimeSpan result;
28602
28603 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28604 {
28605 PyThreadState* __tstate = wxPyBeginAllowThreads();
28606 result = wxTimeSpan::Hour();
28607 wxPyEndAllowThreads(__tstate);
28608 if (PyErr_Occurred()) SWIG_fail;
28609 }
28610 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28611 return resultobj;
28612 fail:
28613 return NULL;
28614 }
28615
28616
28617 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28618 PyObject *resultobj = 0;
28619 long arg1 ;
28620 wxTimeSpan result;
28621 long val1 ;
28622 int ecode1 = 0 ;
28623 PyObject * obj0 = 0 ;
28624 char * kwnames[] = {
28625 (char *) "days", NULL
28626 };
28627
28628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28629 ecode1 = SWIG_AsVal_long(obj0, &val1);
28630 if (!SWIG_IsOK(ecode1)) {
28631 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28632 }
28633 arg1 = static_cast< long >(val1);
28634 {
28635 PyThreadState* __tstate = wxPyBeginAllowThreads();
28636 result = wxTimeSpan::Days(arg1);
28637 wxPyEndAllowThreads(__tstate);
28638 if (PyErr_Occurred()) SWIG_fail;
28639 }
28640 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28641 return resultobj;
28642 fail:
28643 return NULL;
28644 }
28645
28646
28647 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28648 PyObject *resultobj = 0;
28649 wxTimeSpan result;
28650
28651 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28652 {
28653 PyThreadState* __tstate = wxPyBeginAllowThreads();
28654 result = wxTimeSpan::Day();
28655 wxPyEndAllowThreads(__tstate);
28656 if (PyErr_Occurred()) SWIG_fail;
28657 }
28658 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28659 return resultobj;
28660 fail:
28661 return NULL;
28662 }
28663
28664
28665 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28666 PyObject *resultobj = 0;
28667 long arg1 ;
28668 wxTimeSpan result;
28669 long val1 ;
28670 int ecode1 = 0 ;
28671 PyObject * obj0 = 0 ;
28672 char * kwnames[] = {
28673 (char *) "days", NULL
28674 };
28675
28676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28677 ecode1 = SWIG_AsVal_long(obj0, &val1);
28678 if (!SWIG_IsOK(ecode1)) {
28679 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28680 }
28681 arg1 = static_cast< long >(val1);
28682 {
28683 PyThreadState* __tstate = wxPyBeginAllowThreads();
28684 result = wxTimeSpan::Weeks(arg1);
28685 wxPyEndAllowThreads(__tstate);
28686 if (PyErr_Occurred()) SWIG_fail;
28687 }
28688 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28689 return resultobj;
28690 fail:
28691 return NULL;
28692 }
28693
28694
28695 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28696 PyObject *resultobj = 0;
28697 wxTimeSpan result;
28698
28699 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28700 {
28701 PyThreadState* __tstate = wxPyBeginAllowThreads();
28702 result = wxTimeSpan::Week();
28703 wxPyEndAllowThreads(__tstate);
28704 if (PyErr_Occurred()) SWIG_fail;
28705 }
28706 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28707 return resultobj;
28708 fail:
28709 return NULL;
28710 }
28711
28712
28713 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28714 PyObject *resultobj = 0;
28715 long arg1 = (long) 0 ;
28716 long arg2 = (long) 0 ;
28717 long arg3 = (long) 0 ;
28718 long arg4 = (long) 0 ;
28719 wxTimeSpan *result = 0 ;
28720 long val1 ;
28721 int ecode1 = 0 ;
28722 long val2 ;
28723 int ecode2 = 0 ;
28724 long val3 ;
28725 int ecode3 = 0 ;
28726 long val4 ;
28727 int ecode4 = 0 ;
28728 PyObject * obj0 = 0 ;
28729 PyObject * obj1 = 0 ;
28730 PyObject * obj2 = 0 ;
28731 PyObject * obj3 = 0 ;
28732 char * kwnames[] = {
28733 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28734 };
28735
28736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28737 if (obj0) {
28738 ecode1 = SWIG_AsVal_long(obj0, &val1);
28739 if (!SWIG_IsOK(ecode1)) {
28740 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28741 }
28742 arg1 = static_cast< long >(val1);
28743 }
28744 if (obj1) {
28745 ecode2 = SWIG_AsVal_long(obj1, &val2);
28746 if (!SWIG_IsOK(ecode2)) {
28747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28748 }
28749 arg2 = static_cast< long >(val2);
28750 }
28751 if (obj2) {
28752 ecode3 = SWIG_AsVal_long(obj2, &val3);
28753 if (!SWIG_IsOK(ecode3)) {
28754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28755 }
28756 arg3 = static_cast< long >(val3);
28757 }
28758 if (obj3) {
28759 ecode4 = SWIG_AsVal_long(obj3, &val4);
28760 if (!SWIG_IsOK(ecode4)) {
28761 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28762 }
28763 arg4 = static_cast< long >(val4);
28764 }
28765 {
28766 PyThreadState* __tstate = wxPyBeginAllowThreads();
28767 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28768 wxPyEndAllowThreads(__tstate);
28769 if (PyErr_Occurred()) SWIG_fail;
28770 }
28771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28772 return resultobj;
28773 fail:
28774 return NULL;
28775 }
28776
28777
28778 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28779 PyObject *resultobj = 0;
28780 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28781 void *argp1 = 0 ;
28782 int res1 = 0 ;
28783 PyObject *swig_obj[1] ;
28784
28785 if (!args) SWIG_fail;
28786 swig_obj[0] = args;
28787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28788 if (!SWIG_IsOK(res1)) {
28789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28790 }
28791 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28792 {
28793 PyThreadState* __tstate = wxPyBeginAllowThreads();
28794 delete arg1;
28795
28796 wxPyEndAllowThreads(__tstate);
28797 if (PyErr_Occurred()) SWIG_fail;
28798 }
28799 resultobj = SWIG_Py_Void();
28800 return resultobj;
28801 fail:
28802 return NULL;
28803 }
28804
28805
28806 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28807 PyObject *resultobj = 0;
28808 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28809 wxTimeSpan *arg2 = 0 ;
28810 wxTimeSpan *result = 0 ;
28811 void *argp1 = 0 ;
28812 int res1 = 0 ;
28813 void *argp2 = 0 ;
28814 int res2 = 0 ;
28815 PyObject * obj0 = 0 ;
28816 PyObject * obj1 = 0 ;
28817 char * kwnames[] = {
28818 (char *) "self",(char *) "diff", NULL
28819 };
28820
28821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
28822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28823 if (!SWIG_IsOK(res1)) {
28824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28825 }
28826 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28827 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28828 if (!SWIG_IsOK(res2)) {
28829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28830 }
28831 if (!argp2) {
28832 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28833 }
28834 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28835 {
28836 PyThreadState* __tstate = wxPyBeginAllowThreads();
28837 {
28838 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
28839 result = (wxTimeSpan *) &_result_ref;
28840 }
28841 wxPyEndAllowThreads(__tstate);
28842 if (PyErr_Occurred()) SWIG_fail;
28843 }
28844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28845 return resultobj;
28846 fail:
28847 return NULL;
28848 }
28849
28850
28851 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28852 PyObject *resultobj = 0;
28853 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28854 wxTimeSpan *arg2 = 0 ;
28855 wxTimeSpan *result = 0 ;
28856 void *argp1 = 0 ;
28857 int res1 = 0 ;
28858 void *argp2 = 0 ;
28859 int res2 = 0 ;
28860 PyObject * obj0 = 0 ;
28861 PyObject * obj1 = 0 ;
28862 char * kwnames[] = {
28863 (char *) "self",(char *) "diff", NULL
28864 };
28865
28866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
28867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28868 if (!SWIG_IsOK(res1)) {
28869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28870 }
28871 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28872 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28873 if (!SWIG_IsOK(res2)) {
28874 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28875 }
28876 if (!argp2) {
28877 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28878 }
28879 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28880 {
28881 PyThreadState* __tstate = wxPyBeginAllowThreads();
28882 {
28883 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
28884 result = (wxTimeSpan *) &_result_ref;
28885 }
28886 wxPyEndAllowThreads(__tstate);
28887 if (PyErr_Occurred()) SWIG_fail;
28888 }
28889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28890 return resultobj;
28891 fail:
28892 return NULL;
28893 }
28894
28895
28896 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28897 PyObject *resultobj = 0;
28898 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28899 int arg2 ;
28900 wxTimeSpan *result = 0 ;
28901 void *argp1 = 0 ;
28902 int res1 = 0 ;
28903 int val2 ;
28904 int ecode2 = 0 ;
28905 PyObject * obj0 = 0 ;
28906 PyObject * obj1 = 0 ;
28907 char * kwnames[] = {
28908 (char *) "self",(char *) "n", NULL
28909 };
28910
28911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
28912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28913 if (!SWIG_IsOK(res1)) {
28914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28915 }
28916 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28917 ecode2 = SWIG_AsVal_int(obj1, &val2);
28918 if (!SWIG_IsOK(ecode2)) {
28919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
28920 }
28921 arg2 = static_cast< int >(val2);
28922 {
28923 PyThreadState* __tstate = wxPyBeginAllowThreads();
28924 {
28925 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
28926 result = (wxTimeSpan *) &_result_ref;
28927 }
28928 wxPyEndAllowThreads(__tstate);
28929 if (PyErr_Occurred()) SWIG_fail;
28930 }
28931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28932 return resultobj;
28933 fail:
28934 return NULL;
28935 }
28936
28937
28938 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28939 PyObject *resultobj = 0;
28940 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28941 wxTimeSpan *result = 0 ;
28942 void *argp1 = 0 ;
28943 int res1 = 0 ;
28944 PyObject *swig_obj[1] ;
28945
28946 if (!args) SWIG_fail;
28947 swig_obj[0] = args;
28948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28949 if (!SWIG_IsOK(res1)) {
28950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28951 }
28952 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28953 {
28954 PyThreadState* __tstate = wxPyBeginAllowThreads();
28955 {
28956 wxTimeSpan &_result_ref = (arg1)->Neg();
28957 result = (wxTimeSpan *) &_result_ref;
28958 }
28959 wxPyEndAllowThreads(__tstate);
28960 if (PyErr_Occurred()) SWIG_fail;
28961 }
28962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28963 return resultobj;
28964 fail:
28965 return NULL;
28966 }
28967
28968
28969 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28970 PyObject *resultobj = 0;
28971 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28972 wxTimeSpan result;
28973 void *argp1 = 0 ;
28974 int res1 = 0 ;
28975 PyObject *swig_obj[1] ;
28976
28977 if (!args) SWIG_fail;
28978 swig_obj[0] = args;
28979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28980 if (!SWIG_IsOK(res1)) {
28981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28982 }
28983 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28984 {
28985 PyThreadState* __tstate = wxPyBeginAllowThreads();
28986 result = ((wxTimeSpan const *)arg1)->Abs();
28987 wxPyEndAllowThreads(__tstate);
28988 if (PyErr_Occurred()) SWIG_fail;
28989 }
28990 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28991 return resultobj;
28992 fail:
28993 return NULL;
28994 }
28995
28996
28997 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28998 PyObject *resultobj = 0;
28999 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29000 wxTimeSpan *arg2 = 0 ;
29001 wxTimeSpan *result = 0 ;
29002 void *argp1 = 0 ;
29003 int res1 = 0 ;
29004 void *argp2 = 0 ;
29005 int res2 = 0 ;
29006 PyObject * obj0 = 0 ;
29007 PyObject * obj1 = 0 ;
29008 char * kwnames[] = {
29009 (char *) "self",(char *) "diff", NULL
29010 };
29011
29012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29014 if (!SWIG_IsOK(res1)) {
29015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29016 }
29017 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29018 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29019 if (!SWIG_IsOK(res2)) {
29020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29021 }
29022 if (!argp2) {
29023 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29024 }
29025 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29026 {
29027 PyThreadState* __tstate = wxPyBeginAllowThreads();
29028 {
29029 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29030 result = (wxTimeSpan *) &_result_ref;
29031 }
29032 wxPyEndAllowThreads(__tstate);
29033 if (PyErr_Occurred()) SWIG_fail;
29034 }
29035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29036 return resultobj;
29037 fail:
29038 return NULL;
29039 }
29040
29041
29042 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29043 PyObject *resultobj = 0;
29044 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29045 wxTimeSpan *arg2 = 0 ;
29046 wxTimeSpan *result = 0 ;
29047 void *argp1 = 0 ;
29048 int res1 = 0 ;
29049 void *argp2 = 0 ;
29050 int res2 = 0 ;
29051 PyObject * obj0 = 0 ;
29052 PyObject * obj1 = 0 ;
29053 char * kwnames[] = {
29054 (char *) "self",(char *) "diff", NULL
29055 };
29056
29057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29059 if (!SWIG_IsOK(res1)) {
29060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29061 }
29062 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29063 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29064 if (!SWIG_IsOK(res2)) {
29065 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29066 }
29067 if (!argp2) {
29068 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29069 }
29070 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29071 {
29072 PyThreadState* __tstate = wxPyBeginAllowThreads();
29073 {
29074 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29075 result = (wxTimeSpan *) &_result_ref;
29076 }
29077 wxPyEndAllowThreads(__tstate);
29078 if (PyErr_Occurred()) SWIG_fail;
29079 }
29080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29081 return resultobj;
29082 fail:
29083 return NULL;
29084 }
29085
29086
29087 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29088 PyObject *resultobj = 0;
29089 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29090 int arg2 ;
29091 wxTimeSpan *result = 0 ;
29092 void *argp1 = 0 ;
29093 int res1 = 0 ;
29094 int val2 ;
29095 int ecode2 = 0 ;
29096 PyObject * obj0 = 0 ;
29097 PyObject * obj1 = 0 ;
29098 char * kwnames[] = {
29099 (char *) "self",(char *) "n", NULL
29100 };
29101
29102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29104 if (!SWIG_IsOK(res1)) {
29105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29106 }
29107 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29108 ecode2 = SWIG_AsVal_int(obj1, &val2);
29109 if (!SWIG_IsOK(ecode2)) {
29110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29111 }
29112 arg2 = static_cast< int >(val2);
29113 {
29114 PyThreadState* __tstate = wxPyBeginAllowThreads();
29115 {
29116 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29117 result = (wxTimeSpan *) &_result_ref;
29118 }
29119 wxPyEndAllowThreads(__tstate);
29120 if (PyErr_Occurred()) SWIG_fail;
29121 }
29122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29123 return resultobj;
29124 fail:
29125 return NULL;
29126 }
29127
29128
29129 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29130 PyObject *resultobj = 0;
29131 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29132 wxTimeSpan *result = 0 ;
29133 void *argp1 = 0 ;
29134 int res1 = 0 ;
29135 PyObject *swig_obj[1] ;
29136
29137 if (!args) SWIG_fail;
29138 swig_obj[0] = args;
29139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29140 if (!SWIG_IsOK(res1)) {
29141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29142 }
29143 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29144 {
29145 PyThreadState* __tstate = wxPyBeginAllowThreads();
29146 {
29147 wxTimeSpan &_result_ref = (arg1)->operator -();
29148 result = (wxTimeSpan *) &_result_ref;
29149 }
29150 wxPyEndAllowThreads(__tstate);
29151 if (PyErr_Occurred()) SWIG_fail;
29152 }
29153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29154 return resultobj;
29155 fail:
29156 return NULL;
29157 }
29158
29159
29160 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29161 PyObject *resultobj = 0;
29162 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29163 wxTimeSpan *arg2 = 0 ;
29164 wxTimeSpan result;
29165 void *argp1 = 0 ;
29166 int res1 = 0 ;
29167 void *argp2 = 0 ;
29168 int res2 = 0 ;
29169 PyObject * obj0 = 0 ;
29170 PyObject * obj1 = 0 ;
29171 char * kwnames[] = {
29172 (char *) "self",(char *) "other", NULL
29173 };
29174
29175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29177 if (!SWIG_IsOK(res1)) {
29178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29179 }
29180 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29181 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29182 if (!SWIG_IsOK(res2)) {
29183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29184 }
29185 if (!argp2) {
29186 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29187 }
29188 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29189 {
29190 PyThreadState* __tstate = wxPyBeginAllowThreads();
29191 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29192 wxPyEndAllowThreads(__tstate);
29193 if (PyErr_Occurred()) SWIG_fail;
29194 }
29195 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29196 return resultobj;
29197 fail:
29198 return NULL;
29199 }
29200
29201
29202 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29203 PyObject *resultobj = 0;
29204 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29205 wxTimeSpan *arg2 = 0 ;
29206 wxTimeSpan result;
29207 void *argp1 = 0 ;
29208 int res1 = 0 ;
29209 void *argp2 = 0 ;
29210 int res2 = 0 ;
29211 PyObject * obj0 = 0 ;
29212 PyObject * obj1 = 0 ;
29213 char * kwnames[] = {
29214 (char *) "self",(char *) "other", NULL
29215 };
29216
29217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29219 if (!SWIG_IsOK(res1)) {
29220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29221 }
29222 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29223 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29224 if (!SWIG_IsOK(res2)) {
29225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29226 }
29227 if (!argp2) {
29228 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29229 }
29230 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29231 {
29232 PyThreadState* __tstate = wxPyBeginAllowThreads();
29233 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29234 wxPyEndAllowThreads(__tstate);
29235 if (PyErr_Occurred()) SWIG_fail;
29236 }
29237 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29238 return resultobj;
29239 fail:
29240 return NULL;
29241 }
29242
29243
29244 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29245 PyObject *resultobj = 0;
29246 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29247 int arg2 ;
29248 wxTimeSpan result;
29249 void *argp1 = 0 ;
29250 int res1 = 0 ;
29251 int val2 ;
29252 int ecode2 = 0 ;
29253 PyObject * obj0 = 0 ;
29254 PyObject * obj1 = 0 ;
29255 char * kwnames[] = {
29256 (char *) "self",(char *) "n", NULL
29257 };
29258
29259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29261 if (!SWIG_IsOK(res1)) {
29262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29263 }
29264 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29265 ecode2 = SWIG_AsVal_int(obj1, &val2);
29266 if (!SWIG_IsOK(ecode2)) {
29267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29268 }
29269 arg2 = static_cast< int >(val2);
29270 {
29271 PyThreadState* __tstate = wxPyBeginAllowThreads();
29272 result = wxTimeSpan___mul__(arg1,arg2);
29273 wxPyEndAllowThreads(__tstate);
29274 if (PyErr_Occurred()) SWIG_fail;
29275 }
29276 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29277 return resultobj;
29278 fail:
29279 return NULL;
29280 }
29281
29282
29283 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29284 PyObject *resultobj = 0;
29285 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29286 int arg2 ;
29287 wxTimeSpan result;
29288 void *argp1 = 0 ;
29289 int res1 = 0 ;
29290 int val2 ;
29291 int ecode2 = 0 ;
29292 PyObject * obj0 = 0 ;
29293 PyObject * obj1 = 0 ;
29294 char * kwnames[] = {
29295 (char *) "self",(char *) "n", NULL
29296 };
29297
29298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29300 if (!SWIG_IsOK(res1)) {
29301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29302 }
29303 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29304 ecode2 = SWIG_AsVal_int(obj1, &val2);
29305 if (!SWIG_IsOK(ecode2)) {
29306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29307 }
29308 arg2 = static_cast< int >(val2);
29309 {
29310 PyThreadState* __tstate = wxPyBeginAllowThreads();
29311 result = wxTimeSpan___rmul__(arg1,arg2);
29312 wxPyEndAllowThreads(__tstate);
29313 if (PyErr_Occurred()) SWIG_fail;
29314 }
29315 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29316 return resultobj;
29317 fail:
29318 return NULL;
29319 }
29320
29321
29322 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29323 PyObject *resultobj = 0;
29324 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29325 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29326 bool result;
29327 void *argp1 = 0 ;
29328 int res1 = 0 ;
29329 void *argp2 = 0 ;
29330 int res2 = 0 ;
29331 PyObject * obj0 = 0 ;
29332 PyObject * obj1 = 0 ;
29333 char * kwnames[] = {
29334 (char *) "self",(char *) "other", NULL
29335 };
29336
29337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29339 if (!SWIG_IsOK(res1)) {
29340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29341 }
29342 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29343 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29344 if (!SWIG_IsOK(res2)) {
29345 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29346 }
29347 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29348 {
29349 PyThreadState* __tstate = wxPyBeginAllowThreads();
29350 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29351 wxPyEndAllowThreads(__tstate);
29352 if (PyErr_Occurred()) SWIG_fail;
29353 }
29354 {
29355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29356 }
29357 return resultobj;
29358 fail:
29359 return NULL;
29360 }
29361
29362
29363 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29364 PyObject *resultobj = 0;
29365 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29366 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29367 bool result;
29368 void *argp1 = 0 ;
29369 int res1 = 0 ;
29370 void *argp2 = 0 ;
29371 int res2 = 0 ;
29372 PyObject * obj0 = 0 ;
29373 PyObject * obj1 = 0 ;
29374 char * kwnames[] = {
29375 (char *) "self",(char *) "other", NULL
29376 };
29377
29378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29380 if (!SWIG_IsOK(res1)) {
29381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29382 }
29383 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29384 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29385 if (!SWIG_IsOK(res2)) {
29386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29387 }
29388 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29389 {
29390 PyThreadState* __tstate = wxPyBeginAllowThreads();
29391 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29392 wxPyEndAllowThreads(__tstate);
29393 if (PyErr_Occurred()) SWIG_fail;
29394 }
29395 {
29396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29397 }
29398 return resultobj;
29399 fail:
29400 return NULL;
29401 }
29402
29403
29404 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29405 PyObject *resultobj = 0;
29406 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29407 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29408 bool result;
29409 void *argp1 = 0 ;
29410 int res1 = 0 ;
29411 void *argp2 = 0 ;
29412 int res2 = 0 ;
29413 PyObject * obj0 = 0 ;
29414 PyObject * obj1 = 0 ;
29415 char * kwnames[] = {
29416 (char *) "self",(char *) "other", NULL
29417 };
29418
29419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29421 if (!SWIG_IsOK(res1)) {
29422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29423 }
29424 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29425 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29426 if (!SWIG_IsOK(res2)) {
29427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29428 }
29429 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29430 {
29431 PyThreadState* __tstate = wxPyBeginAllowThreads();
29432 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29433 wxPyEndAllowThreads(__tstate);
29434 if (PyErr_Occurred()) SWIG_fail;
29435 }
29436 {
29437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29438 }
29439 return resultobj;
29440 fail:
29441 return NULL;
29442 }
29443
29444
29445 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29446 PyObject *resultobj = 0;
29447 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29448 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29449 bool result;
29450 void *argp1 = 0 ;
29451 int res1 = 0 ;
29452 void *argp2 = 0 ;
29453 int res2 = 0 ;
29454 PyObject * obj0 = 0 ;
29455 PyObject * obj1 = 0 ;
29456 char * kwnames[] = {
29457 (char *) "self",(char *) "other", NULL
29458 };
29459
29460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29462 if (!SWIG_IsOK(res1)) {
29463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29464 }
29465 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29466 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29467 if (!SWIG_IsOK(res2)) {
29468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29469 }
29470 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29471 {
29472 PyThreadState* __tstate = wxPyBeginAllowThreads();
29473 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29474 wxPyEndAllowThreads(__tstate);
29475 if (PyErr_Occurred()) SWIG_fail;
29476 }
29477 {
29478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29479 }
29480 return resultobj;
29481 fail:
29482 return NULL;
29483 }
29484
29485
29486 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29487 PyObject *resultobj = 0;
29488 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29489 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29490 bool result;
29491 void *argp1 = 0 ;
29492 int res1 = 0 ;
29493 void *argp2 = 0 ;
29494 int res2 = 0 ;
29495 PyObject * obj0 = 0 ;
29496 PyObject * obj1 = 0 ;
29497 char * kwnames[] = {
29498 (char *) "self",(char *) "other", NULL
29499 };
29500
29501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29503 if (!SWIG_IsOK(res1)) {
29504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29505 }
29506 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29507 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29508 if (!SWIG_IsOK(res2)) {
29509 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29510 }
29511 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29512 {
29513 PyThreadState* __tstate = wxPyBeginAllowThreads();
29514 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29515 wxPyEndAllowThreads(__tstate);
29516 if (PyErr_Occurred()) SWIG_fail;
29517 }
29518 {
29519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29520 }
29521 return resultobj;
29522 fail:
29523 return NULL;
29524 }
29525
29526
29527 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29528 PyObject *resultobj = 0;
29529 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29530 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29531 bool result;
29532 void *argp1 = 0 ;
29533 int res1 = 0 ;
29534 void *argp2 = 0 ;
29535 int res2 = 0 ;
29536 PyObject * obj0 = 0 ;
29537 PyObject * obj1 = 0 ;
29538 char * kwnames[] = {
29539 (char *) "self",(char *) "other", NULL
29540 };
29541
29542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29544 if (!SWIG_IsOK(res1)) {
29545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29546 }
29547 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29548 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29549 if (!SWIG_IsOK(res2)) {
29550 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29551 }
29552 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29553 {
29554 PyThreadState* __tstate = wxPyBeginAllowThreads();
29555 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29556 wxPyEndAllowThreads(__tstate);
29557 if (PyErr_Occurred()) SWIG_fail;
29558 }
29559 {
29560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29561 }
29562 return resultobj;
29563 fail:
29564 return NULL;
29565 }
29566
29567
29568 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29569 PyObject *resultobj = 0;
29570 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29571 bool result;
29572 void *argp1 = 0 ;
29573 int res1 = 0 ;
29574 PyObject *swig_obj[1] ;
29575
29576 if (!args) SWIG_fail;
29577 swig_obj[0] = args;
29578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29579 if (!SWIG_IsOK(res1)) {
29580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29581 }
29582 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29583 {
29584 PyThreadState* __tstate = wxPyBeginAllowThreads();
29585 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29586 wxPyEndAllowThreads(__tstate);
29587 if (PyErr_Occurred()) SWIG_fail;
29588 }
29589 {
29590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29591 }
29592 return resultobj;
29593 fail:
29594 return NULL;
29595 }
29596
29597
29598 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29599 PyObject *resultobj = 0;
29600 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29601 bool result;
29602 void *argp1 = 0 ;
29603 int res1 = 0 ;
29604 PyObject *swig_obj[1] ;
29605
29606 if (!args) SWIG_fail;
29607 swig_obj[0] = args;
29608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29609 if (!SWIG_IsOK(res1)) {
29610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29611 }
29612 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29613 {
29614 PyThreadState* __tstate = wxPyBeginAllowThreads();
29615 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29616 wxPyEndAllowThreads(__tstate);
29617 if (PyErr_Occurred()) SWIG_fail;
29618 }
29619 {
29620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29621 }
29622 return resultobj;
29623 fail:
29624 return NULL;
29625 }
29626
29627
29628 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29629 PyObject *resultobj = 0;
29630 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29631 bool result;
29632 void *argp1 = 0 ;
29633 int res1 = 0 ;
29634 PyObject *swig_obj[1] ;
29635
29636 if (!args) SWIG_fail;
29637 swig_obj[0] = args;
29638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29639 if (!SWIG_IsOK(res1)) {
29640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29641 }
29642 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29643 {
29644 PyThreadState* __tstate = wxPyBeginAllowThreads();
29645 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29646 wxPyEndAllowThreads(__tstate);
29647 if (PyErr_Occurred()) SWIG_fail;
29648 }
29649 {
29650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29651 }
29652 return resultobj;
29653 fail:
29654 return NULL;
29655 }
29656
29657
29658 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29659 PyObject *resultobj = 0;
29660 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29661 wxTimeSpan *arg2 = 0 ;
29662 bool result;
29663 void *argp1 = 0 ;
29664 int res1 = 0 ;
29665 void *argp2 = 0 ;
29666 int res2 = 0 ;
29667 PyObject * obj0 = 0 ;
29668 PyObject * obj1 = 0 ;
29669 char * kwnames[] = {
29670 (char *) "self",(char *) "ts", NULL
29671 };
29672
29673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29675 if (!SWIG_IsOK(res1)) {
29676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29677 }
29678 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29679 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29680 if (!SWIG_IsOK(res2)) {
29681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29682 }
29683 if (!argp2) {
29684 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29685 }
29686 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29687 {
29688 PyThreadState* __tstate = wxPyBeginAllowThreads();
29689 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29690 wxPyEndAllowThreads(__tstate);
29691 if (PyErr_Occurred()) SWIG_fail;
29692 }
29693 {
29694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29695 }
29696 return resultobj;
29697 fail:
29698 return NULL;
29699 }
29700
29701
29702 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29703 PyObject *resultobj = 0;
29704 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29705 wxTimeSpan *arg2 = 0 ;
29706 bool result;
29707 void *argp1 = 0 ;
29708 int res1 = 0 ;
29709 void *argp2 = 0 ;
29710 int res2 = 0 ;
29711 PyObject * obj0 = 0 ;
29712 PyObject * obj1 = 0 ;
29713 char * kwnames[] = {
29714 (char *) "self",(char *) "ts", NULL
29715 };
29716
29717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29719 if (!SWIG_IsOK(res1)) {
29720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29721 }
29722 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29723 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29724 if (!SWIG_IsOK(res2)) {
29725 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29726 }
29727 if (!argp2) {
29728 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29729 }
29730 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29731 {
29732 PyThreadState* __tstate = wxPyBeginAllowThreads();
29733 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29734 wxPyEndAllowThreads(__tstate);
29735 if (PyErr_Occurred()) SWIG_fail;
29736 }
29737 {
29738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29739 }
29740 return resultobj;
29741 fail:
29742 return NULL;
29743 }
29744
29745
29746 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29747 PyObject *resultobj = 0;
29748 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29749 wxTimeSpan *arg2 = 0 ;
29750 bool result;
29751 void *argp1 = 0 ;
29752 int res1 = 0 ;
29753 void *argp2 = 0 ;
29754 int res2 = 0 ;
29755 PyObject * obj0 = 0 ;
29756 PyObject * obj1 = 0 ;
29757 char * kwnames[] = {
29758 (char *) "self",(char *) "t", NULL
29759 };
29760
29761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29763 if (!SWIG_IsOK(res1)) {
29764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29765 }
29766 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29767 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29768 if (!SWIG_IsOK(res2)) {
29769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29770 }
29771 if (!argp2) {
29772 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29773 }
29774 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29775 {
29776 PyThreadState* __tstate = wxPyBeginAllowThreads();
29777 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
29778 wxPyEndAllowThreads(__tstate);
29779 if (PyErr_Occurred()) SWIG_fail;
29780 }
29781 {
29782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29783 }
29784 return resultobj;
29785 fail:
29786 return NULL;
29787 }
29788
29789
29790 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29791 PyObject *resultobj = 0;
29792 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29793 int result;
29794 void *argp1 = 0 ;
29795 int res1 = 0 ;
29796 PyObject *swig_obj[1] ;
29797
29798 if (!args) SWIG_fail;
29799 swig_obj[0] = args;
29800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29801 if (!SWIG_IsOK(res1)) {
29802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29803 }
29804 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29805 {
29806 PyThreadState* __tstate = wxPyBeginAllowThreads();
29807 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
29808 wxPyEndAllowThreads(__tstate);
29809 if (PyErr_Occurred()) SWIG_fail;
29810 }
29811 resultobj = SWIG_From_int(static_cast< int >(result));
29812 return resultobj;
29813 fail:
29814 return NULL;
29815 }
29816
29817
29818 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29819 PyObject *resultobj = 0;
29820 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29821 int result;
29822 void *argp1 = 0 ;
29823 int res1 = 0 ;
29824 PyObject *swig_obj[1] ;
29825
29826 if (!args) SWIG_fail;
29827 swig_obj[0] = args;
29828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29829 if (!SWIG_IsOK(res1)) {
29830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29831 }
29832 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29833 {
29834 PyThreadState* __tstate = wxPyBeginAllowThreads();
29835 result = (int)((wxTimeSpan const *)arg1)->GetDays();
29836 wxPyEndAllowThreads(__tstate);
29837 if (PyErr_Occurred()) SWIG_fail;
29838 }
29839 resultobj = SWIG_From_int(static_cast< int >(result));
29840 return resultobj;
29841 fail:
29842 return NULL;
29843 }
29844
29845
29846 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29847 PyObject *resultobj = 0;
29848 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29849 int result;
29850 void *argp1 = 0 ;
29851 int res1 = 0 ;
29852 PyObject *swig_obj[1] ;
29853
29854 if (!args) SWIG_fail;
29855 swig_obj[0] = args;
29856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29857 if (!SWIG_IsOK(res1)) {
29858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29859 }
29860 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29861 {
29862 PyThreadState* __tstate = wxPyBeginAllowThreads();
29863 result = (int)((wxTimeSpan const *)arg1)->GetHours();
29864 wxPyEndAllowThreads(__tstate);
29865 if (PyErr_Occurred()) SWIG_fail;
29866 }
29867 resultobj = SWIG_From_int(static_cast< int >(result));
29868 return resultobj;
29869 fail:
29870 return NULL;
29871 }
29872
29873
29874 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29875 PyObject *resultobj = 0;
29876 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29877 int result;
29878 void *argp1 = 0 ;
29879 int res1 = 0 ;
29880 PyObject *swig_obj[1] ;
29881
29882 if (!args) SWIG_fail;
29883 swig_obj[0] = args;
29884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29885 if (!SWIG_IsOK(res1)) {
29886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29887 }
29888 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29889 {
29890 PyThreadState* __tstate = wxPyBeginAllowThreads();
29891 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
29892 wxPyEndAllowThreads(__tstate);
29893 if (PyErr_Occurred()) SWIG_fail;
29894 }
29895 resultobj = SWIG_From_int(static_cast< int >(result));
29896 return resultobj;
29897 fail:
29898 return NULL;
29899 }
29900
29901
29902 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29903 PyObject *resultobj = 0;
29904 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29905 wxLongLong result;
29906 void *argp1 = 0 ;
29907 int res1 = 0 ;
29908 PyObject *swig_obj[1] ;
29909
29910 if (!args) SWIG_fail;
29911 swig_obj[0] = args;
29912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29913 if (!SWIG_IsOK(res1)) {
29914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29915 }
29916 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29917 {
29918 PyThreadState* __tstate = wxPyBeginAllowThreads();
29919 result = ((wxTimeSpan const *)arg1)->GetSeconds();
29920 wxPyEndAllowThreads(__tstate);
29921 if (PyErr_Occurred()) SWIG_fail;
29922 }
29923 {
29924 PyObject *hi, *lo, *shifter, *shifted;
29925 hi = PyLong_FromLong( (&result)->GetHi() );
29926 lo = PyLong_FromLong( (&result)->GetLo() );
29927 shifter = PyLong_FromLong(32);
29928 shifted = PyNumber_Lshift(hi, shifter);
29929 resultobj = PyNumber_Or(shifted, lo);
29930 Py_DECREF(hi);
29931 Py_DECREF(lo);
29932 Py_DECREF(shifter);
29933 Py_DECREF(shifted);
29934 }
29935 return resultobj;
29936 fail:
29937 return NULL;
29938 }
29939
29940
29941 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29942 PyObject *resultobj = 0;
29943 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29944 wxLongLong result;
29945 void *argp1 = 0 ;
29946 int res1 = 0 ;
29947 PyObject *swig_obj[1] ;
29948
29949 if (!args) SWIG_fail;
29950 swig_obj[0] = args;
29951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29952 if (!SWIG_IsOK(res1)) {
29953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29954 }
29955 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29956 {
29957 PyThreadState* __tstate = wxPyBeginAllowThreads();
29958 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
29959 wxPyEndAllowThreads(__tstate);
29960 if (PyErr_Occurred()) SWIG_fail;
29961 }
29962 {
29963 PyObject *hi, *lo, *shifter, *shifted;
29964 hi = PyLong_FromLong( (&result)->GetHi() );
29965 lo = PyLong_FromLong( (&result)->GetLo() );
29966 shifter = PyLong_FromLong(32);
29967 shifted = PyNumber_Lshift(hi, shifter);
29968 resultobj = PyNumber_Or(shifted, lo);
29969 Py_DECREF(hi);
29970 Py_DECREF(lo);
29971 Py_DECREF(shifter);
29972 Py_DECREF(shifted);
29973 }
29974 return resultobj;
29975 fail:
29976 return NULL;
29977 }
29978
29979
29980 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29981 PyObject *resultobj = 0;
29982 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29983 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
29984 wxString *arg2 = (wxString *) &arg2_defvalue ;
29985 wxString result;
29986 void *argp1 = 0 ;
29987 int res1 = 0 ;
29988 bool temp2 = false ;
29989 PyObject * obj0 = 0 ;
29990 PyObject * obj1 = 0 ;
29991 char * kwnames[] = {
29992 (char *) "self",(char *) "format", NULL
29993 };
29994
29995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
29996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29997 if (!SWIG_IsOK(res1)) {
29998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29999 }
30000 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30001 if (obj1) {
30002 {
30003 arg2 = wxString_in_helper(obj1);
30004 if (arg2 == NULL) SWIG_fail;
30005 temp2 = true;
30006 }
30007 }
30008 {
30009 PyThreadState* __tstate = wxPyBeginAllowThreads();
30010 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30011 wxPyEndAllowThreads(__tstate);
30012 if (PyErr_Occurred()) SWIG_fail;
30013 }
30014 {
30015 #if wxUSE_UNICODE
30016 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30017 #else
30018 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30019 #endif
30020 }
30021 {
30022 if (temp2)
30023 delete arg2;
30024 }
30025 return resultobj;
30026 fail:
30027 {
30028 if (temp2)
30029 delete arg2;
30030 }
30031 return NULL;
30032 }
30033
30034
30035 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30036 PyObject *obj;
30037 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30038 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30039 return SWIG_Py_Void();
30040 }
30041
30042 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30043 return SWIG_Python_InitShadowInstance(args);
30044 }
30045
30046 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30047 PyObject *resultobj = 0;
30048 int arg1 = (int) 0 ;
30049 int arg2 = (int) 0 ;
30050 int arg3 = (int) 0 ;
30051 int arg4 = (int) 0 ;
30052 wxDateSpan *result = 0 ;
30053 int val1 ;
30054 int ecode1 = 0 ;
30055 int val2 ;
30056 int ecode2 = 0 ;
30057 int val3 ;
30058 int ecode3 = 0 ;
30059 int val4 ;
30060 int ecode4 = 0 ;
30061 PyObject * obj0 = 0 ;
30062 PyObject * obj1 = 0 ;
30063 PyObject * obj2 = 0 ;
30064 PyObject * obj3 = 0 ;
30065 char * kwnames[] = {
30066 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30067 };
30068
30069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30070 if (obj0) {
30071 ecode1 = SWIG_AsVal_int(obj0, &val1);
30072 if (!SWIG_IsOK(ecode1)) {
30073 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30074 }
30075 arg1 = static_cast< int >(val1);
30076 }
30077 if (obj1) {
30078 ecode2 = SWIG_AsVal_int(obj1, &val2);
30079 if (!SWIG_IsOK(ecode2)) {
30080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30081 }
30082 arg2 = static_cast< int >(val2);
30083 }
30084 if (obj2) {
30085 ecode3 = SWIG_AsVal_int(obj2, &val3);
30086 if (!SWIG_IsOK(ecode3)) {
30087 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30088 }
30089 arg3 = static_cast< int >(val3);
30090 }
30091 if (obj3) {
30092 ecode4 = SWIG_AsVal_int(obj3, &val4);
30093 if (!SWIG_IsOK(ecode4)) {
30094 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30095 }
30096 arg4 = static_cast< int >(val4);
30097 }
30098 {
30099 PyThreadState* __tstate = wxPyBeginAllowThreads();
30100 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30101 wxPyEndAllowThreads(__tstate);
30102 if (PyErr_Occurred()) SWIG_fail;
30103 }
30104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30105 return resultobj;
30106 fail:
30107 return NULL;
30108 }
30109
30110
30111 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30112 PyObject *resultobj = 0;
30113 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30114 void *argp1 = 0 ;
30115 int res1 = 0 ;
30116 PyObject *swig_obj[1] ;
30117
30118 if (!args) SWIG_fail;
30119 swig_obj[0] = args;
30120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30121 if (!SWIG_IsOK(res1)) {
30122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30123 }
30124 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30125 {
30126 PyThreadState* __tstate = wxPyBeginAllowThreads();
30127 delete arg1;
30128
30129 wxPyEndAllowThreads(__tstate);
30130 if (PyErr_Occurred()) SWIG_fail;
30131 }
30132 resultobj = SWIG_Py_Void();
30133 return resultobj;
30134 fail:
30135 return NULL;
30136 }
30137
30138
30139 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30140 PyObject *resultobj = 0;
30141 int arg1 ;
30142 wxDateSpan result;
30143 int val1 ;
30144 int ecode1 = 0 ;
30145 PyObject * obj0 = 0 ;
30146 char * kwnames[] = {
30147 (char *) "days", NULL
30148 };
30149
30150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30151 ecode1 = SWIG_AsVal_int(obj0, &val1);
30152 if (!SWIG_IsOK(ecode1)) {
30153 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30154 }
30155 arg1 = static_cast< int >(val1);
30156 {
30157 PyThreadState* __tstate = wxPyBeginAllowThreads();
30158 result = wxDateSpan::Days(arg1);
30159 wxPyEndAllowThreads(__tstate);
30160 if (PyErr_Occurred()) SWIG_fail;
30161 }
30162 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30163 return resultobj;
30164 fail:
30165 return NULL;
30166 }
30167
30168
30169 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30170 PyObject *resultobj = 0;
30171 wxDateSpan result;
30172
30173 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30174 {
30175 PyThreadState* __tstate = wxPyBeginAllowThreads();
30176 result = wxDateSpan::Day();
30177 wxPyEndAllowThreads(__tstate);
30178 if (PyErr_Occurred()) SWIG_fail;
30179 }
30180 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30181 return resultobj;
30182 fail:
30183 return NULL;
30184 }
30185
30186
30187 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30188 PyObject *resultobj = 0;
30189 int arg1 ;
30190 wxDateSpan result;
30191 int val1 ;
30192 int ecode1 = 0 ;
30193 PyObject * obj0 = 0 ;
30194 char * kwnames[] = {
30195 (char *) "weeks", NULL
30196 };
30197
30198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30199 ecode1 = SWIG_AsVal_int(obj0, &val1);
30200 if (!SWIG_IsOK(ecode1)) {
30201 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30202 }
30203 arg1 = static_cast< int >(val1);
30204 {
30205 PyThreadState* __tstate = wxPyBeginAllowThreads();
30206 result = wxDateSpan::Weeks(arg1);
30207 wxPyEndAllowThreads(__tstate);
30208 if (PyErr_Occurred()) SWIG_fail;
30209 }
30210 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30211 return resultobj;
30212 fail:
30213 return NULL;
30214 }
30215
30216
30217 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30218 PyObject *resultobj = 0;
30219 wxDateSpan result;
30220
30221 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30222 {
30223 PyThreadState* __tstate = wxPyBeginAllowThreads();
30224 result = wxDateSpan::Week();
30225 wxPyEndAllowThreads(__tstate);
30226 if (PyErr_Occurred()) SWIG_fail;
30227 }
30228 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30229 return resultobj;
30230 fail:
30231 return NULL;
30232 }
30233
30234
30235 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30236 PyObject *resultobj = 0;
30237 int arg1 ;
30238 wxDateSpan result;
30239 int val1 ;
30240 int ecode1 = 0 ;
30241 PyObject * obj0 = 0 ;
30242 char * kwnames[] = {
30243 (char *) "mon", NULL
30244 };
30245
30246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30247 ecode1 = SWIG_AsVal_int(obj0, &val1);
30248 if (!SWIG_IsOK(ecode1)) {
30249 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30250 }
30251 arg1 = static_cast< int >(val1);
30252 {
30253 PyThreadState* __tstate = wxPyBeginAllowThreads();
30254 result = wxDateSpan::Months(arg1);
30255 wxPyEndAllowThreads(__tstate);
30256 if (PyErr_Occurred()) SWIG_fail;
30257 }
30258 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30259 return resultobj;
30260 fail:
30261 return NULL;
30262 }
30263
30264
30265 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30266 PyObject *resultobj = 0;
30267 wxDateSpan result;
30268
30269 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30270 {
30271 PyThreadState* __tstate = wxPyBeginAllowThreads();
30272 result = wxDateSpan::Month();
30273 wxPyEndAllowThreads(__tstate);
30274 if (PyErr_Occurred()) SWIG_fail;
30275 }
30276 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30277 return resultobj;
30278 fail:
30279 return NULL;
30280 }
30281
30282
30283 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30284 PyObject *resultobj = 0;
30285 int arg1 ;
30286 wxDateSpan result;
30287 int val1 ;
30288 int ecode1 = 0 ;
30289 PyObject * obj0 = 0 ;
30290 char * kwnames[] = {
30291 (char *) "years", NULL
30292 };
30293
30294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30295 ecode1 = SWIG_AsVal_int(obj0, &val1);
30296 if (!SWIG_IsOK(ecode1)) {
30297 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30298 }
30299 arg1 = static_cast< int >(val1);
30300 {
30301 PyThreadState* __tstate = wxPyBeginAllowThreads();
30302 result = wxDateSpan::Years(arg1);
30303 wxPyEndAllowThreads(__tstate);
30304 if (PyErr_Occurred()) SWIG_fail;
30305 }
30306 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30307 return resultobj;
30308 fail:
30309 return NULL;
30310 }
30311
30312
30313 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30314 PyObject *resultobj = 0;
30315 wxDateSpan result;
30316
30317 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30318 {
30319 PyThreadState* __tstate = wxPyBeginAllowThreads();
30320 result = wxDateSpan::Year();
30321 wxPyEndAllowThreads(__tstate);
30322 if (PyErr_Occurred()) SWIG_fail;
30323 }
30324 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30325 return resultobj;
30326 fail:
30327 return NULL;
30328 }
30329
30330
30331 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30332 PyObject *resultobj = 0;
30333 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30334 int arg2 ;
30335 wxDateSpan *result = 0 ;
30336 void *argp1 = 0 ;
30337 int res1 = 0 ;
30338 int val2 ;
30339 int ecode2 = 0 ;
30340 PyObject * obj0 = 0 ;
30341 PyObject * obj1 = 0 ;
30342 char * kwnames[] = {
30343 (char *) "self",(char *) "n", NULL
30344 };
30345
30346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30348 if (!SWIG_IsOK(res1)) {
30349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30350 }
30351 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30352 ecode2 = SWIG_AsVal_int(obj1, &val2);
30353 if (!SWIG_IsOK(ecode2)) {
30354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30355 }
30356 arg2 = static_cast< int >(val2);
30357 {
30358 PyThreadState* __tstate = wxPyBeginAllowThreads();
30359 {
30360 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30361 result = (wxDateSpan *) &_result_ref;
30362 }
30363 wxPyEndAllowThreads(__tstate);
30364 if (PyErr_Occurred()) SWIG_fail;
30365 }
30366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30367 return resultobj;
30368 fail:
30369 return NULL;
30370 }
30371
30372
30373 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30374 PyObject *resultobj = 0;
30375 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30376 int arg2 ;
30377 wxDateSpan *result = 0 ;
30378 void *argp1 = 0 ;
30379 int res1 = 0 ;
30380 int val2 ;
30381 int ecode2 = 0 ;
30382 PyObject * obj0 = 0 ;
30383 PyObject * obj1 = 0 ;
30384 char * kwnames[] = {
30385 (char *) "self",(char *) "n", NULL
30386 };
30387
30388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30390 if (!SWIG_IsOK(res1)) {
30391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30392 }
30393 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30394 ecode2 = SWIG_AsVal_int(obj1, &val2);
30395 if (!SWIG_IsOK(ecode2)) {
30396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30397 }
30398 arg2 = static_cast< int >(val2);
30399 {
30400 PyThreadState* __tstate = wxPyBeginAllowThreads();
30401 {
30402 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30403 result = (wxDateSpan *) &_result_ref;
30404 }
30405 wxPyEndAllowThreads(__tstate);
30406 if (PyErr_Occurred()) SWIG_fail;
30407 }
30408 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30409 return resultobj;
30410 fail:
30411 return NULL;
30412 }
30413
30414
30415 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30416 PyObject *resultobj = 0;
30417 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30418 int arg2 ;
30419 wxDateSpan *result = 0 ;
30420 void *argp1 = 0 ;
30421 int res1 = 0 ;
30422 int val2 ;
30423 int ecode2 = 0 ;
30424 PyObject * obj0 = 0 ;
30425 PyObject * obj1 = 0 ;
30426 char * kwnames[] = {
30427 (char *) "self",(char *) "n", NULL
30428 };
30429
30430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30432 if (!SWIG_IsOK(res1)) {
30433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30434 }
30435 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30436 ecode2 = SWIG_AsVal_int(obj1, &val2);
30437 if (!SWIG_IsOK(ecode2)) {
30438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30439 }
30440 arg2 = static_cast< int >(val2);
30441 {
30442 PyThreadState* __tstate = wxPyBeginAllowThreads();
30443 {
30444 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30445 result = (wxDateSpan *) &_result_ref;
30446 }
30447 wxPyEndAllowThreads(__tstate);
30448 if (PyErr_Occurred()) SWIG_fail;
30449 }
30450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30451 return resultobj;
30452 fail:
30453 return NULL;
30454 }
30455
30456
30457 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30458 PyObject *resultobj = 0;
30459 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30460 int arg2 ;
30461 wxDateSpan *result = 0 ;
30462 void *argp1 = 0 ;
30463 int res1 = 0 ;
30464 int val2 ;
30465 int ecode2 = 0 ;
30466 PyObject * obj0 = 0 ;
30467 PyObject * obj1 = 0 ;
30468 char * kwnames[] = {
30469 (char *) "self",(char *) "n", NULL
30470 };
30471
30472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30474 if (!SWIG_IsOK(res1)) {
30475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30476 }
30477 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30478 ecode2 = SWIG_AsVal_int(obj1, &val2);
30479 if (!SWIG_IsOK(ecode2)) {
30480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30481 }
30482 arg2 = static_cast< int >(val2);
30483 {
30484 PyThreadState* __tstate = wxPyBeginAllowThreads();
30485 {
30486 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30487 result = (wxDateSpan *) &_result_ref;
30488 }
30489 wxPyEndAllowThreads(__tstate);
30490 if (PyErr_Occurred()) SWIG_fail;
30491 }
30492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30493 return resultobj;
30494 fail:
30495 return NULL;
30496 }
30497
30498
30499 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30500 PyObject *resultobj = 0;
30501 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30502 int result;
30503 void *argp1 = 0 ;
30504 int res1 = 0 ;
30505 PyObject *swig_obj[1] ;
30506
30507 if (!args) SWIG_fail;
30508 swig_obj[0] = args;
30509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30510 if (!SWIG_IsOK(res1)) {
30511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30512 }
30513 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30514 {
30515 PyThreadState* __tstate = wxPyBeginAllowThreads();
30516 result = (int)((wxDateSpan const *)arg1)->GetYears();
30517 wxPyEndAllowThreads(__tstate);
30518 if (PyErr_Occurred()) SWIG_fail;
30519 }
30520 resultobj = SWIG_From_int(static_cast< int >(result));
30521 return resultobj;
30522 fail:
30523 return NULL;
30524 }
30525
30526
30527 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30528 PyObject *resultobj = 0;
30529 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30530 int result;
30531 void *argp1 = 0 ;
30532 int res1 = 0 ;
30533 PyObject *swig_obj[1] ;
30534
30535 if (!args) SWIG_fail;
30536 swig_obj[0] = args;
30537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30538 if (!SWIG_IsOK(res1)) {
30539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30540 }
30541 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30542 {
30543 PyThreadState* __tstate = wxPyBeginAllowThreads();
30544 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30545 wxPyEndAllowThreads(__tstate);
30546 if (PyErr_Occurred()) SWIG_fail;
30547 }
30548 resultobj = SWIG_From_int(static_cast< int >(result));
30549 return resultobj;
30550 fail:
30551 return NULL;
30552 }
30553
30554
30555 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30556 PyObject *resultobj = 0;
30557 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30558 int result;
30559 void *argp1 = 0 ;
30560 int res1 = 0 ;
30561 PyObject *swig_obj[1] ;
30562
30563 if (!args) SWIG_fail;
30564 swig_obj[0] = args;
30565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30566 if (!SWIG_IsOK(res1)) {
30567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30568 }
30569 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30570 {
30571 PyThreadState* __tstate = wxPyBeginAllowThreads();
30572 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30573 wxPyEndAllowThreads(__tstate);
30574 if (PyErr_Occurred()) SWIG_fail;
30575 }
30576 resultobj = SWIG_From_int(static_cast< int >(result));
30577 return resultobj;
30578 fail:
30579 return NULL;
30580 }
30581
30582
30583 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30584 PyObject *resultobj = 0;
30585 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30586 int result;
30587 void *argp1 = 0 ;
30588 int res1 = 0 ;
30589 PyObject *swig_obj[1] ;
30590
30591 if (!args) SWIG_fail;
30592 swig_obj[0] = args;
30593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30594 if (!SWIG_IsOK(res1)) {
30595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30596 }
30597 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30598 {
30599 PyThreadState* __tstate = wxPyBeginAllowThreads();
30600 result = (int)((wxDateSpan const *)arg1)->GetDays();
30601 wxPyEndAllowThreads(__tstate);
30602 if (PyErr_Occurred()) SWIG_fail;
30603 }
30604 resultobj = SWIG_From_int(static_cast< int >(result));
30605 return resultobj;
30606 fail:
30607 return NULL;
30608 }
30609
30610
30611 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30612 PyObject *resultobj = 0;
30613 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30614 int result;
30615 void *argp1 = 0 ;
30616 int res1 = 0 ;
30617 PyObject *swig_obj[1] ;
30618
30619 if (!args) SWIG_fail;
30620 swig_obj[0] = args;
30621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30622 if (!SWIG_IsOK(res1)) {
30623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30624 }
30625 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30626 {
30627 PyThreadState* __tstate = wxPyBeginAllowThreads();
30628 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30629 wxPyEndAllowThreads(__tstate);
30630 if (PyErr_Occurred()) SWIG_fail;
30631 }
30632 resultobj = SWIG_From_int(static_cast< int >(result));
30633 return resultobj;
30634 fail:
30635 return NULL;
30636 }
30637
30638
30639 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30640 PyObject *resultobj = 0;
30641 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30642 wxDateSpan *arg2 = 0 ;
30643 wxDateSpan *result = 0 ;
30644 void *argp1 = 0 ;
30645 int res1 = 0 ;
30646 void *argp2 = 0 ;
30647 int res2 = 0 ;
30648 PyObject * obj0 = 0 ;
30649 PyObject * obj1 = 0 ;
30650 char * kwnames[] = {
30651 (char *) "self",(char *) "other", NULL
30652 };
30653
30654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30656 if (!SWIG_IsOK(res1)) {
30657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30658 }
30659 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30660 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30661 if (!SWIG_IsOK(res2)) {
30662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30663 }
30664 if (!argp2) {
30665 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30666 }
30667 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30668 {
30669 PyThreadState* __tstate = wxPyBeginAllowThreads();
30670 {
30671 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30672 result = (wxDateSpan *) &_result_ref;
30673 }
30674 wxPyEndAllowThreads(__tstate);
30675 if (PyErr_Occurred()) SWIG_fail;
30676 }
30677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30678 return resultobj;
30679 fail:
30680 return NULL;
30681 }
30682
30683
30684 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30685 PyObject *resultobj = 0;
30686 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30687 wxDateSpan *arg2 = 0 ;
30688 wxDateSpan *result = 0 ;
30689 void *argp1 = 0 ;
30690 int res1 = 0 ;
30691 void *argp2 = 0 ;
30692 int res2 = 0 ;
30693 PyObject * obj0 = 0 ;
30694 PyObject * obj1 = 0 ;
30695 char * kwnames[] = {
30696 (char *) "self",(char *) "other", NULL
30697 };
30698
30699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30701 if (!SWIG_IsOK(res1)) {
30702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30703 }
30704 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30705 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30706 if (!SWIG_IsOK(res2)) {
30707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30708 }
30709 if (!argp2) {
30710 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30711 }
30712 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30713 {
30714 PyThreadState* __tstate = wxPyBeginAllowThreads();
30715 {
30716 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30717 result = (wxDateSpan *) &_result_ref;
30718 }
30719 wxPyEndAllowThreads(__tstate);
30720 if (PyErr_Occurred()) SWIG_fail;
30721 }
30722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30723 return resultobj;
30724 fail:
30725 return NULL;
30726 }
30727
30728
30729 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30730 PyObject *resultobj = 0;
30731 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30732 wxDateSpan *result = 0 ;
30733 void *argp1 = 0 ;
30734 int res1 = 0 ;
30735 PyObject *swig_obj[1] ;
30736
30737 if (!args) SWIG_fail;
30738 swig_obj[0] = args;
30739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30740 if (!SWIG_IsOK(res1)) {
30741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30742 }
30743 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30744 {
30745 PyThreadState* __tstate = wxPyBeginAllowThreads();
30746 {
30747 wxDateSpan &_result_ref = (arg1)->Neg();
30748 result = (wxDateSpan *) &_result_ref;
30749 }
30750 wxPyEndAllowThreads(__tstate);
30751 if (PyErr_Occurred()) SWIG_fail;
30752 }
30753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30754 return resultobj;
30755 fail:
30756 return NULL;
30757 }
30758
30759
30760 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30761 PyObject *resultobj = 0;
30762 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30763 int arg2 ;
30764 wxDateSpan *result = 0 ;
30765 void *argp1 = 0 ;
30766 int res1 = 0 ;
30767 int val2 ;
30768 int ecode2 = 0 ;
30769 PyObject * obj0 = 0 ;
30770 PyObject * obj1 = 0 ;
30771 char * kwnames[] = {
30772 (char *) "self",(char *) "factor", NULL
30773 };
30774
30775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
30776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30777 if (!SWIG_IsOK(res1)) {
30778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30779 }
30780 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30781 ecode2 = SWIG_AsVal_int(obj1, &val2);
30782 if (!SWIG_IsOK(ecode2)) {
30783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
30784 }
30785 arg2 = static_cast< int >(val2);
30786 {
30787 PyThreadState* __tstate = wxPyBeginAllowThreads();
30788 {
30789 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
30790 result = (wxDateSpan *) &_result_ref;
30791 }
30792 wxPyEndAllowThreads(__tstate);
30793 if (PyErr_Occurred()) SWIG_fail;
30794 }
30795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30796 return resultobj;
30797 fail:
30798 return NULL;
30799 }
30800
30801
30802 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30803 PyObject *resultobj = 0;
30804 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30805 wxDateSpan *arg2 = 0 ;
30806 wxDateSpan *result = 0 ;
30807 void *argp1 = 0 ;
30808 int res1 = 0 ;
30809 void *argp2 = 0 ;
30810 int res2 = 0 ;
30811 PyObject * obj0 = 0 ;
30812 PyObject * obj1 = 0 ;
30813 char * kwnames[] = {
30814 (char *) "self",(char *) "other", NULL
30815 };
30816
30817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
30818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30819 if (!SWIG_IsOK(res1)) {
30820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30821 }
30822 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30823 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30824 if (!SWIG_IsOK(res2)) {
30825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30826 }
30827 if (!argp2) {
30828 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30829 }
30830 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30831 {
30832 PyThreadState* __tstate = wxPyBeginAllowThreads();
30833 {
30834 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
30835 result = (wxDateSpan *) &_result_ref;
30836 }
30837 wxPyEndAllowThreads(__tstate);
30838 if (PyErr_Occurred()) SWIG_fail;
30839 }
30840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30841 return resultobj;
30842 fail:
30843 return NULL;
30844 }
30845
30846
30847 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30848 PyObject *resultobj = 0;
30849 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30850 wxDateSpan *arg2 = 0 ;
30851 wxDateSpan *result = 0 ;
30852 void *argp1 = 0 ;
30853 int res1 = 0 ;
30854 void *argp2 = 0 ;
30855 int res2 = 0 ;
30856 PyObject * obj0 = 0 ;
30857 PyObject * obj1 = 0 ;
30858 char * kwnames[] = {
30859 (char *) "self",(char *) "other", NULL
30860 };
30861
30862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
30863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30864 if (!SWIG_IsOK(res1)) {
30865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30866 }
30867 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30868 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30869 if (!SWIG_IsOK(res2)) {
30870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30871 }
30872 if (!argp2) {
30873 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30874 }
30875 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30876 {
30877 PyThreadState* __tstate = wxPyBeginAllowThreads();
30878 {
30879 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
30880 result = (wxDateSpan *) &_result_ref;
30881 }
30882 wxPyEndAllowThreads(__tstate);
30883 if (PyErr_Occurred()) SWIG_fail;
30884 }
30885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30886 return resultobj;
30887 fail:
30888 return NULL;
30889 }
30890
30891
30892 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30893 PyObject *resultobj = 0;
30894 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30895 wxDateSpan *result = 0 ;
30896 void *argp1 = 0 ;
30897 int res1 = 0 ;
30898 PyObject *swig_obj[1] ;
30899
30900 if (!args) SWIG_fail;
30901 swig_obj[0] = args;
30902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30903 if (!SWIG_IsOK(res1)) {
30904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30905 }
30906 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30907 {
30908 PyThreadState* __tstate = wxPyBeginAllowThreads();
30909 {
30910 wxDateSpan &_result_ref = (arg1)->operator -();
30911 result = (wxDateSpan *) &_result_ref;
30912 }
30913 wxPyEndAllowThreads(__tstate);
30914 if (PyErr_Occurred()) SWIG_fail;
30915 }
30916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30917 return resultobj;
30918 fail:
30919 return NULL;
30920 }
30921
30922
30923 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30924 PyObject *resultobj = 0;
30925 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30926 int arg2 ;
30927 wxDateSpan *result = 0 ;
30928 void *argp1 = 0 ;
30929 int res1 = 0 ;
30930 int val2 ;
30931 int ecode2 = 0 ;
30932 PyObject * obj0 = 0 ;
30933 PyObject * obj1 = 0 ;
30934 char * kwnames[] = {
30935 (char *) "self",(char *) "factor", NULL
30936 };
30937
30938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
30939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30940 if (!SWIG_IsOK(res1)) {
30941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30942 }
30943 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30944 ecode2 = SWIG_AsVal_int(obj1, &val2);
30945 if (!SWIG_IsOK(ecode2)) {
30946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
30947 }
30948 arg2 = static_cast< int >(val2);
30949 {
30950 PyThreadState* __tstate = wxPyBeginAllowThreads();
30951 {
30952 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
30953 result = (wxDateSpan *) &_result_ref;
30954 }
30955 wxPyEndAllowThreads(__tstate);
30956 if (PyErr_Occurred()) SWIG_fail;
30957 }
30958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30959 return resultobj;
30960 fail:
30961 return NULL;
30962 }
30963
30964
30965 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30966 PyObject *resultobj = 0;
30967 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30968 wxDateSpan *arg2 = 0 ;
30969 wxDateSpan result;
30970 void *argp1 = 0 ;
30971 int res1 = 0 ;
30972 void *argp2 = 0 ;
30973 int res2 = 0 ;
30974 PyObject * obj0 = 0 ;
30975 PyObject * obj1 = 0 ;
30976 char * kwnames[] = {
30977 (char *) "self",(char *) "other", NULL
30978 };
30979
30980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
30981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30982 if (!SWIG_IsOK(res1)) {
30983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30984 }
30985 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30986 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30987 if (!SWIG_IsOK(res2)) {
30988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30989 }
30990 if (!argp2) {
30991 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30992 }
30993 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30994 {
30995 PyThreadState* __tstate = wxPyBeginAllowThreads();
30996 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
30997 wxPyEndAllowThreads(__tstate);
30998 if (PyErr_Occurred()) SWIG_fail;
30999 }
31000 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31001 return resultobj;
31002 fail:
31003 return NULL;
31004 }
31005
31006
31007 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31008 PyObject *resultobj = 0;
31009 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31010 wxDateSpan *arg2 = 0 ;
31011 wxDateSpan result;
31012 void *argp1 = 0 ;
31013 int res1 = 0 ;
31014 void *argp2 = 0 ;
31015 int res2 = 0 ;
31016 PyObject * obj0 = 0 ;
31017 PyObject * obj1 = 0 ;
31018 char * kwnames[] = {
31019 (char *) "self",(char *) "other", NULL
31020 };
31021
31022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31024 if (!SWIG_IsOK(res1)) {
31025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31026 }
31027 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31028 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31029 if (!SWIG_IsOK(res2)) {
31030 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31031 }
31032 if (!argp2) {
31033 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31034 }
31035 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31036 {
31037 PyThreadState* __tstate = wxPyBeginAllowThreads();
31038 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31043 return resultobj;
31044 fail:
31045 return NULL;
31046 }
31047
31048
31049 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31050 PyObject *resultobj = 0;
31051 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31052 int arg2 ;
31053 wxDateSpan result;
31054 void *argp1 = 0 ;
31055 int res1 = 0 ;
31056 int val2 ;
31057 int ecode2 = 0 ;
31058 PyObject * obj0 = 0 ;
31059 PyObject * obj1 = 0 ;
31060 char * kwnames[] = {
31061 (char *) "self",(char *) "n", NULL
31062 };
31063
31064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31066 if (!SWIG_IsOK(res1)) {
31067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31068 }
31069 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31070 ecode2 = SWIG_AsVal_int(obj1, &val2);
31071 if (!SWIG_IsOK(ecode2)) {
31072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31073 }
31074 arg2 = static_cast< int >(val2);
31075 {
31076 PyThreadState* __tstate = wxPyBeginAllowThreads();
31077 result = wxDateSpan___mul__(arg1,arg2);
31078 wxPyEndAllowThreads(__tstate);
31079 if (PyErr_Occurred()) SWIG_fail;
31080 }
31081 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31082 return resultobj;
31083 fail:
31084 return NULL;
31085 }
31086
31087
31088 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31089 PyObject *resultobj = 0;
31090 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31091 int arg2 ;
31092 wxDateSpan result;
31093 void *argp1 = 0 ;
31094 int res1 = 0 ;
31095 int val2 ;
31096 int ecode2 = 0 ;
31097 PyObject * obj0 = 0 ;
31098 PyObject * obj1 = 0 ;
31099 char * kwnames[] = {
31100 (char *) "self",(char *) "n", NULL
31101 };
31102
31103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31105 if (!SWIG_IsOK(res1)) {
31106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31107 }
31108 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31109 ecode2 = SWIG_AsVal_int(obj1, &val2);
31110 if (!SWIG_IsOK(ecode2)) {
31111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31112 }
31113 arg2 = static_cast< int >(val2);
31114 {
31115 PyThreadState* __tstate = wxPyBeginAllowThreads();
31116 result = wxDateSpan___rmul__(arg1,arg2);
31117 wxPyEndAllowThreads(__tstate);
31118 if (PyErr_Occurred()) SWIG_fail;
31119 }
31120 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31121 return resultobj;
31122 fail:
31123 return NULL;
31124 }
31125
31126
31127 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31128 PyObject *resultobj = 0;
31129 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31130 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31131 bool result;
31132 void *argp1 = 0 ;
31133 int res1 = 0 ;
31134 void *argp2 = 0 ;
31135 int res2 = 0 ;
31136 PyObject * obj0 = 0 ;
31137 PyObject * obj1 = 0 ;
31138 char * kwnames[] = {
31139 (char *) "self",(char *) "other", NULL
31140 };
31141
31142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31144 if (!SWIG_IsOK(res1)) {
31145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31146 }
31147 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31148 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31149 if (!SWIG_IsOK(res2)) {
31150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31151 }
31152 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31153 {
31154 PyThreadState* __tstate = wxPyBeginAllowThreads();
31155 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31156 wxPyEndAllowThreads(__tstate);
31157 if (PyErr_Occurred()) SWIG_fail;
31158 }
31159 {
31160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31161 }
31162 return resultobj;
31163 fail:
31164 return NULL;
31165 }
31166
31167
31168 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31169 PyObject *resultobj = 0;
31170 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31171 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31172 bool result;
31173 void *argp1 = 0 ;
31174 int res1 = 0 ;
31175 void *argp2 = 0 ;
31176 int res2 = 0 ;
31177 PyObject * obj0 = 0 ;
31178 PyObject * obj1 = 0 ;
31179 char * kwnames[] = {
31180 (char *) "self",(char *) "other", NULL
31181 };
31182
31183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31185 if (!SWIG_IsOK(res1)) {
31186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31187 }
31188 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31189 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31190 if (!SWIG_IsOK(res2)) {
31191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31192 }
31193 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31194 {
31195 PyThreadState* __tstate = wxPyBeginAllowThreads();
31196 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31197 wxPyEndAllowThreads(__tstate);
31198 if (PyErr_Occurred()) SWIG_fail;
31199 }
31200 {
31201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31202 }
31203 return resultobj;
31204 fail:
31205 return NULL;
31206 }
31207
31208
31209 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31210 PyObject *obj;
31211 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31212 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31213 return SWIG_Py_Void();
31214 }
31215
31216 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31217 return SWIG_Python_InitShadowInstance(args);
31218 }
31219
31220 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31221 PyObject *resultobj = 0;
31222 long result;
31223
31224 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31225 {
31226 PyThreadState* __tstate = wxPyBeginAllowThreads();
31227 result = (long)wxGetLocalTime();
31228 wxPyEndAllowThreads(__tstate);
31229 if (PyErr_Occurred()) SWIG_fail;
31230 }
31231 resultobj = SWIG_From_long(static_cast< long >(result));
31232 return resultobj;
31233 fail:
31234 return NULL;
31235 }
31236
31237
31238 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31239 PyObject *resultobj = 0;
31240 long result;
31241
31242 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31243 {
31244 PyThreadState* __tstate = wxPyBeginAllowThreads();
31245 result = (long)wxGetUTCTime();
31246 wxPyEndAllowThreads(__tstate);
31247 if (PyErr_Occurred()) SWIG_fail;
31248 }
31249 resultobj = SWIG_From_long(static_cast< long >(result));
31250 return resultobj;
31251 fail:
31252 return NULL;
31253 }
31254
31255
31256 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31257 PyObject *resultobj = 0;
31258 long result;
31259
31260 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31261 {
31262 PyThreadState* __tstate = wxPyBeginAllowThreads();
31263 result = (long)wxGetCurrentTime();
31264 wxPyEndAllowThreads(__tstate);
31265 if (PyErr_Occurred()) SWIG_fail;
31266 }
31267 resultobj = SWIG_From_long(static_cast< long >(result));
31268 return resultobj;
31269 fail:
31270 return NULL;
31271 }
31272
31273
31274 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31275 PyObject *resultobj = 0;
31276 wxLongLong result;
31277
31278 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31279 {
31280 PyThreadState* __tstate = wxPyBeginAllowThreads();
31281 result = wxGetLocalTimeMillis();
31282 wxPyEndAllowThreads(__tstate);
31283 if (PyErr_Occurred()) SWIG_fail;
31284 }
31285 {
31286 PyObject *hi, *lo, *shifter, *shifted;
31287 hi = PyLong_FromLong( (&result)->GetHi() );
31288 lo = PyLong_FromLong( (&result)->GetLo() );
31289 shifter = PyLong_FromLong(32);
31290 shifted = PyNumber_Lshift(hi, shifter);
31291 resultobj = PyNumber_Or(shifted, lo);
31292 Py_DECREF(hi);
31293 Py_DECREF(lo);
31294 Py_DECREF(shifter);
31295 Py_DECREF(shifted);
31296 }
31297 return resultobj;
31298 fail:
31299 return NULL;
31300 }
31301
31302
31303 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31304 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31305 return 1;
31306 }
31307
31308
31309 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31310 PyObject *pyobj = 0;
31311
31312 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31313 return pyobj;
31314 }
31315
31316
31317 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31318 PyObject *resultobj = 0;
31319 wxDataFormatId arg1 ;
31320 wxDataFormat *result = 0 ;
31321 int val1 ;
31322 int ecode1 = 0 ;
31323 PyObject * obj0 = 0 ;
31324 char * kwnames[] = {
31325 (char *) "type", NULL
31326 };
31327
31328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31329 ecode1 = SWIG_AsVal_int(obj0, &val1);
31330 if (!SWIG_IsOK(ecode1)) {
31331 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31332 }
31333 arg1 = static_cast< wxDataFormatId >(val1);
31334 {
31335 PyThreadState* __tstate = wxPyBeginAllowThreads();
31336 result = (wxDataFormat *)new wxDataFormat(arg1);
31337 wxPyEndAllowThreads(__tstate);
31338 if (PyErr_Occurred()) SWIG_fail;
31339 }
31340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31341 return resultobj;
31342 fail:
31343 return NULL;
31344 }
31345
31346
31347 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31348 PyObject *resultobj = 0;
31349 wxString *arg1 = 0 ;
31350 wxDataFormat *result = 0 ;
31351 bool temp1 = false ;
31352 PyObject * obj0 = 0 ;
31353 char * kwnames[] = {
31354 (char *) "format", NULL
31355 };
31356
31357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31358 {
31359 arg1 = wxString_in_helper(obj0);
31360 if (arg1 == NULL) SWIG_fail;
31361 temp1 = true;
31362 }
31363 {
31364 PyThreadState* __tstate = wxPyBeginAllowThreads();
31365 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31366 wxPyEndAllowThreads(__tstate);
31367 if (PyErr_Occurred()) SWIG_fail;
31368 }
31369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31370 {
31371 if (temp1)
31372 delete arg1;
31373 }
31374 return resultobj;
31375 fail:
31376 {
31377 if (temp1)
31378 delete arg1;
31379 }
31380 return NULL;
31381 }
31382
31383
31384 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31385 PyObject *resultobj = 0;
31386 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31387 void *argp1 = 0 ;
31388 int res1 = 0 ;
31389 PyObject *swig_obj[1] ;
31390
31391 if (!args) SWIG_fail;
31392 swig_obj[0] = args;
31393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31394 if (!SWIG_IsOK(res1)) {
31395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31396 }
31397 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31398 {
31399 PyThreadState* __tstate = wxPyBeginAllowThreads();
31400 delete arg1;
31401
31402 wxPyEndAllowThreads(__tstate);
31403 if (PyErr_Occurred()) SWIG_fail;
31404 }
31405 resultobj = SWIG_Py_Void();
31406 return resultobj;
31407 fail:
31408 return NULL;
31409 }
31410
31411
31412 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31413 PyObject *resultobj = 0;
31414 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31415 wxDataFormatId arg2 ;
31416 bool result;
31417 void *argp1 = 0 ;
31418 int res1 = 0 ;
31419 int val2 ;
31420 int ecode2 = 0 ;
31421
31422 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31424 if (!SWIG_IsOK(res1)) {
31425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31426 }
31427 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31428 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31429 if (!SWIG_IsOK(ecode2)) {
31430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31431 }
31432 arg2 = static_cast< wxDataFormatId >(val2);
31433 {
31434 PyThreadState* __tstate = wxPyBeginAllowThreads();
31435 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31436 wxPyEndAllowThreads(__tstate);
31437 if (PyErr_Occurred()) SWIG_fail;
31438 }
31439 {
31440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31441 }
31442 return resultobj;
31443 fail:
31444 return NULL;
31445 }
31446
31447
31448 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31449 PyObject *resultobj = 0;
31450 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31451 wxDataFormatId arg2 ;
31452 bool result;
31453 void *argp1 = 0 ;
31454 int res1 = 0 ;
31455 int val2 ;
31456 int ecode2 = 0 ;
31457
31458 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31460 if (!SWIG_IsOK(res1)) {
31461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31462 }
31463 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31464 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31465 if (!SWIG_IsOK(ecode2)) {
31466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31467 }
31468 arg2 = static_cast< wxDataFormatId >(val2);
31469 {
31470 PyThreadState* __tstate = wxPyBeginAllowThreads();
31471 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31472 wxPyEndAllowThreads(__tstate);
31473 if (PyErr_Occurred()) SWIG_fail;
31474 }
31475 {
31476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31477 }
31478 return resultobj;
31479 fail:
31480 return NULL;
31481 }
31482
31483
31484 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31485 PyObject *resultobj = 0;
31486 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31487 wxDataFormat *arg2 = 0 ;
31488 bool result;
31489 void *argp1 = 0 ;
31490 int res1 = 0 ;
31491 void *argp2 = 0 ;
31492 int res2 = 0 ;
31493
31494 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31496 if (!SWIG_IsOK(res1)) {
31497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31498 }
31499 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31500 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31501 if (!SWIG_IsOK(res2)) {
31502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31503 }
31504 if (!argp2) {
31505 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31506 }
31507 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31508 {
31509 PyThreadState* __tstate = wxPyBeginAllowThreads();
31510 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31511 wxPyEndAllowThreads(__tstate);
31512 if (PyErr_Occurred()) SWIG_fail;
31513 }
31514 {
31515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31516 }
31517 return resultobj;
31518 fail:
31519 return NULL;
31520 }
31521
31522
31523 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31524 int argc;
31525 PyObject *argv[3];
31526
31527 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31528 --argc;
31529 if (argc == 2) {
31530 int _v = 0;
31531 {
31532 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31533 _v = SWIG_CheckState(res);
31534 }
31535 if (!_v) goto check_1;
31536 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31537 }
31538 check_1:
31539
31540 if (argc == 2) {
31541 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31542 }
31543
31544 fail:
31545 Py_INCREF(Py_NotImplemented);
31546 return Py_NotImplemented;
31547 }
31548
31549
31550 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31551 PyObject *resultobj = 0;
31552 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31553 wxDataFormat *arg2 = 0 ;
31554 bool result;
31555 void *argp1 = 0 ;
31556 int res1 = 0 ;
31557 void *argp2 = 0 ;
31558 int res2 = 0 ;
31559
31560 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31562 if (!SWIG_IsOK(res1)) {
31563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31564 }
31565 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31566 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31567 if (!SWIG_IsOK(res2)) {
31568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31569 }
31570 if (!argp2) {
31571 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31572 }
31573 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31574 {
31575 PyThreadState* __tstate = wxPyBeginAllowThreads();
31576 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31577 wxPyEndAllowThreads(__tstate);
31578 if (PyErr_Occurred()) SWIG_fail;
31579 }
31580 {
31581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31582 }
31583 return resultobj;
31584 fail:
31585 return NULL;
31586 }
31587
31588
31589 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31590 int argc;
31591 PyObject *argv[3];
31592
31593 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31594 --argc;
31595 if (argc == 2) {
31596 int _v = 0;
31597 {
31598 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31599 _v = SWIG_CheckState(res);
31600 }
31601 if (!_v) goto check_1;
31602 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31603 }
31604 check_1:
31605
31606 if (argc == 2) {
31607 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31608 }
31609
31610 fail:
31611 Py_INCREF(Py_NotImplemented);
31612 return Py_NotImplemented;
31613 }
31614
31615
31616 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31617 PyObject *resultobj = 0;
31618 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31619 wxDataFormatId arg2 ;
31620 void *argp1 = 0 ;
31621 int res1 = 0 ;
31622 int val2 ;
31623 int ecode2 = 0 ;
31624 PyObject * obj0 = 0 ;
31625 PyObject * obj1 = 0 ;
31626 char * kwnames[] = {
31627 (char *) "self",(char *) "format", NULL
31628 };
31629
31630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31632 if (!SWIG_IsOK(res1)) {
31633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31634 }
31635 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31636 ecode2 = SWIG_AsVal_int(obj1, &val2);
31637 if (!SWIG_IsOK(ecode2)) {
31638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31639 }
31640 arg2 = static_cast< wxDataFormatId >(val2);
31641 {
31642 PyThreadState* __tstate = wxPyBeginAllowThreads();
31643 (arg1)->SetType(arg2);
31644 wxPyEndAllowThreads(__tstate);
31645 if (PyErr_Occurred()) SWIG_fail;
31646 }
31647 resultobj = SWIG_Py_Void();
31648 return resultobj;
31649 fail:
31650 return NULL;
31651 }
31652
31653
31654 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31655 PyObject *resultobj = 0;
31656 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31657 wxDataFormatId result;
31658 void *argp1 = 0 ;
31659 int res1 = 0 ;
31660 PyObject *swig_obj[1] ;
31661
31662 if (!args) SWIG_fail;
31663 swig_obj[0] = args;
31664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31665 if (!SWIG_IsOK(res1)) {
31666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31667 }
31668 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31669 {
31670 PyThreadState* __tstate = wxPyBeginAllowThreads();
31671 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31672 wxPyEndAllowThreads(__tstate);
31673 if (PyErr_Occurred()) SWIG_fail;
31674 }
31675 resultobj = SWIG_From_int(static_cast< int >(result));
31676 return resultobj;
31677 fail:
31678 return NULL;
31679 }
31680
31681
31682 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31683 PyObject *resultobj = 0;
31684 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31685 wxString result;
31686 void *argp1 = 0 ;
31687 int res1 = 0 ;
31688 PyObject *swig_obj[1] ;
31689
31690 if (!args) SWIG_fail;
31691 swig_obj[0] = args;
31692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31693 if (!SWIG_IsOK(res1)) {
31694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31695 }
31696 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31697 {
31698 PyThreadState* __tstate = wxPyBeginAllowThreads();
31699 result = ((wxDataFormat const *)arg1)->GetId();
31700 wxPyEndAllowThreads(__tstate);
31701 if (PyErr_Occurred()) SWIG_fail;
31702 }
31703 {
31704 #if wxUSE_UNICODE
31705 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31706 #else
31707 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31708 #endif
31709 }
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31717 PyObject *resultobj = 0;
31718 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31719 wxString *arg2 = 0 ;
31720 void *argp1 = 0 ;
31721 int res1 = 0 ;
31722 bool temp2 = false ;
31723 PyObject * obj0 = 0 ;
31724 PyObject * obj1 = 0 ;
31725 char * kwnames[] = {
31726 (char *) "self",(char *) "format", NULL
31727 };
31728
31729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31731 if (!SWIG_IsOK(res1)) {
31732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31733 }
31734 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31735 {
31736 arg2 = wxString_in_helper(obj1);
31737 if (arg2 == NULL) SWIG_fail;
31738 temp2 = true;
31739 }
31740 {
31741 PyThreadState* __tstate = wxPyBeginAllowThreads();
31742 (arg1)->SetId((wxString const &)*arg2);
31743 wxPyEndAllowThreads(__tstate);
31744 if (PyErr_Occurred()) SWIG_fail;
31745 }
31746 resultobj = SWIG_Py_Void();
31747 {
31748 if (temp2)
31749 delete arg2;
31750 }
31751 return resultobj;
31752 fail:
31753 {
31754 if (temp2)
31755 delete arg2;
31756 }
31757 return NULL;
31758 }
31759
31760
31761 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31762 PyObject *obj;
31763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31764 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31765 return SWIG_Py_Void();
31766 }
31767
31768 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31769 return SWIG_Python_InitShadowInstance(args);
31770 }
31771
31772 SWIGINTERN int FormatInvalid_set(PyObject *) {
31773 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31774 return 1;
31775 }
31776
31777
31778 SWIGINTERN PyObject *FormatInvalid_get(void) {
31779 PyObject *pyobj = 0;
31780
31781 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
31782 return pyobj;
31783 }
31784
31785
31786 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31787 PyObject *resultobj = 0;
31788 wxDataObject *arg1 = (wxDataObject *) 0 ;
31789 void *argp1 = 0 ;
31790 int res1 = 0 ;
31791 PyObject *swig_obj[1] ;
31792
31793 if (!args) SWIG_fail;
31794 swig_obj[0] = args;
31795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
31796 if (!SWIG_IsOK(res1)) {
31797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
31798 }
31799 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31800 {
31801 PyThreadState* __tstate = wxPyBeginAllowThreads();
31802 delete arg1;
31803
31804 wxPyEndAllowThreads(__tstate);
31805 if (PyErr_Occurred()) SWIG_fail;
31806 }
31807 resultobj = SWIG_Py_Void();
31808 return resultobj;
31809 fail:
31810 return NULL;
31811 }
31812
31813
31814 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31815 PyObject *resultobj = 0;
31816 wxDataObject *arg1 = (wxDataObject *) 0 ;
31817 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31818 SwigValueWrapper<wxDataFormat > result;
31819 void *argp1 = 0 ;
31820 int res1 = 0 ;
31821 int val2 ;
31822 int ecode2 = 0 ;
31823 PyObject * obj0 = 0 ;
31824 PyObject * obj1 = 0 ;
31825 char * kwnames[] = {
31826 (char *) "self",(char *) "dir", NULL
31827 };
31828
31829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31831 if (!SWIG_IsOK(res1)) {
31832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31833 }
31834 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31835 if (obj1) {
31836 ecode2 = SWIG_AsVal_int(obj1, &val2);
31837 if (!SWIG_IsOK(ecode2)) {
31838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31839 }
31840 arg2 = static_cast< wxDataObject::Direction >(val2);
31841 }
31842 {
31843 PyThreadState* __tstate = wxPyBeginAllowThreads();
31844 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
31845 wxPyEndAllowThreads(__tstate);
31846 if (PyErr_Occurred()) SWIG_fail;
31847 }
31848 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31849 return resultobj;
31850 fail:
31851 return NULL;
31852 }
31853
31854
31855 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31856 PyObject *resultobj = 0;
31857 wxDataObject *arg1 = (wxDataObject *) 0 ;
31858 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31859 size_t result;
31860 void *argp1 = 0 ;
31861 int res1 = 0 ;
31862 int val2 ;
31863 int ecode2 = 0 ;
31864 PyObject * obj0 = 0 ;
31865 PyObject * obj1 = 0 ;
31866 char * kwnames[] = {
31867 (char *) "self",(char *) "dir", NULL
31868 };
31869
31870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
31871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31872 if (!SWIG_IsOK(res1)) {
31873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31874 }
31875 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31876 if (obj1) {
31877 ecode2 = SWIG_AsVal_int(obj1, &val2);
31878 if (!SWIG_IsOK(ecode2)) {
31879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31880 }
31881 arg2 = static_cast< wxDataObject::Direction >(val2);
31882 }
31883 {
31884 PyThreadState* __tstate = wxPyBeginAllowThreads();
31885 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
31886 wxPyEndAllowThreads(__tstate);
31887 if (PyErr_Occurred()) SWIG_fail;
31888 }
31889 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31890 return resultobj;
31891 fail:
31892 return NULL;
31893 }
31894
31895
31896 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31897 PyObject *resultobj = 0;
31898 wxDataObject *arg1 = (wxDataObject *) 0 ;
31899 wxDataFormat *arg2 = 0 ;
31900 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
31901 bool result;
31902 void *argp1 = 0 ;
31903 int res1 = 0 ;
31904 void *argp2 = 0 ;
31905 int res2 = 0 ;
31906 int val3 ;
31907 int ecode3 = 0 ;
31908 PyObject * obj0 = 0 ;
31909 PyObject * obj1 = 0 ;
31910 PyObject * obj2 = 0 ;
31911 char * kwnames[] = {
31912 (char *) "self",(char *) "format",(char *) "dir", NULL
31913 };
31914
31915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31917 if (!SWIG_IsOK(res1)) {
31918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31919 }
31920 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31921 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31922 if (!SWIG_IsOK(res2)) {
31923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31924 }
31925 if (!argp2) {
31926 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31927 }
31928 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31929 if (obj2) {
31930 ecode3 = SWIG_AsVal_int(obj2, &val3);
31931 if (!SWIG_IsOK(ecode3)) {
31932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
31933 }
31934 arg3 = static_cast< wxDataObject::Direction >(val3);
31935 }
31936 {
31937 PyThreadState* __tstate = wxPyBeginAllowThreads();
31938 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
31939 wxPyEndAllowThreads(__tstate);
31940 if (PyErr_Occurred()) SWIG_fail;
31941 }
31942 {
31943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31944 }
31945 return resultobj;
31946 fail:
31947 return NULL;
31948 }
31949
31950
31951 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31952 PyObject *resultobj = 0;
31953 wxDataObject *arg1 = (wxDataObject *) 0 ;
31954 wxDataFormat *arg2 = 0 ;
31955 size_t result;
31956 void *argp1 = 0 ;
31957 int res1 = 0 ;
31958 void *argp2 = 0 ;
31959 int res2 = 0 ;
31960 PyObject * obj0 = 0 ;
31961 PyObject * obj1 = 0 ;
31962 char * kwnames[] = {
31963 (char *) "self",(char *) "format", NULL
31964 };
31965
31966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
31967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31968 if (!SWIG_IsOK(res1)) {
31969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31970 }
31971 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31972 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31973 if (!SWIG_IsOK(res2)) {
31974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31975 }
31976 if (!argp2) {
31977 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31978 }
31979 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31980 {
31981 PyThreadState* __tstate = wxPyBeginAllowThreads();
31982 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
31983 wxPyEndAllowThreads(__tstate);
31984 if (PyErr_Occurred()) SWIG_fail;
31985 }
31986 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31987 return resultobj;
31988 fail:
31989 return NULL;
31990 }
31991
31992
31993 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31994 PyObject *resultobj = 0;
31995 wxDataObject *arg1 = (wxDataObject *) 0 ;
31996 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31997 PyObject *result = 0 ;
31998 void *argp1 = 0 ;
31999 int res1 = 0 ;
32000 int val2 ;
32001 int ecode2 = 0 ;
32002 PyObject * obj0 = 0 ;
32003 PyObject * obj1 = 0 ;
32004 char * kwnames[] = {
32005 (char *) "self",(char *) "dir", NULL
32006 };
32007
32008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32010 if (!SWIG_IsOK(res1)) {
32011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32012 }
32013 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32014 if (obj1) {
32015 ecode2 = SWIG_AsVal_int(obj1, &val2);
32016 if (!SWIG_IsOK(ecode2)) {
32017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32018 }
32019 arg2 = static_cast< wxDataObject::Direction >(val2);
32020 }
32021 {
32022 PyThreadState* __tstate = wxPyBeginAllowThreads();
32023 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32024 wxPyEndAllowThreads(__tstate);
32025 if (PyErr_Occurred()) SWIG_fail;
32026 }
32027 resultobj = result;
32028 return resultobj;
32029 fail:
32030 return NULL;
32031 }
32032
32033
32034 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32035 PyObject *resultobj = 0;
32036 wxDataObject *arg1 = (wxDataObject *) 0 ;
32037 wxDataFormat *arg2 = 0 ;
32038 PyObject *result = 0 ;
32039 void *argp1 = 0 ;
32040 int res1 = 0 ;
32041 void *argp2 = 0 ;
32042 int res2 = 0 ;
32043 PyObject * obj0 = 0 ;
32044 PyObject * obj1 = 0 ;
32045 char * kwnames[] = {
32046 (char *) "self",(char *) "format", NULL
32047 };
32048
32049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32051 if (!SWIG_IsOK(res1)) {
32052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32053 }
32054 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32055 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32056 if (!SWIG_IsOK(res2)) {
32057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32058 }
32059 if (!argp2) {
32060 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32061 }
32062 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32063 {
32064 PyThreadState* __tstate = wxPyBeginAllowThreads();
32065 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32066 wxPyEndAllowThreads(__tstate);
32067 if (PyErr_Occurred()) SWIG_fail;
32068 }
32069 resultobj = result;
32070 return resultobj;
32071 fail:
32072 return NULL;
32073 }
32074
32075
32076 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32077 PyObject *resultobj = 0;
32078 wxDataObject *arg1 = (wxDataObject *) 0 ;
32079 wxDataFormat *arg2 = 0 ;
32080 PyObject *arg3 = (PyObject *) 0 ;
32081 bool result;
32082 void *argp1 = 0 ;
32083 int res1 = 0 ;
32084 void *argp2 = 0 ;
32085 int res2 = 0 ;
32086 PyObject * obj0 = 0 ;
32087 PyObject * obj1 = 0 ;
32088 PyObject * obj2 = 0 ;
32089 char * kwnames[] = {
32090 (char *) "self",(char *) "format",(char *) "data", NULL
32091 };
32092
32093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32095 if (!SWIG_IsOK(res1)) {
32096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32097 }
32098 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32099 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32100 if (!SWIG_IsOK(res2)) {
32101 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32102 }
32103 if (!argp2) {
32104 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32105 }
32106 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32107 arg3 = obj2;
32108 {
32109 PyThreadState* __tstate = wxPyBeginAllowThreads();
32110 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32111 wxPyEndAllowThreads(__tstate);
32112 if (PyErr_Occurred()) SWIG_fail;
32113 }
32114 {
32115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32116 }
32117 return resultobj;
32118 fail:
32119 return NULL;
32120 }
32121
32122
32123 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32124 PyObject *obj;
32125 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32126 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32127 return SWIG_Py_Void();
32128 }
32129
32130 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32131 PyObject *resultobj = 0;
32132 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32133 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32134 wxDataObjectSimple *result = 0 ;
32135 void *argp1 = 0 ;
32136 int res1 = 0 ;
32137 PyObject * obj0 = 0 ;
32138 char * kwnames[] = {
32139 (char *) "format", NULL
32140 };
32141
32142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32143 if (obj0) {
32144 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32145 if (!SWIG_IsOK(res1)) {
32146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32147 }
32148 if (!argp1) {
32149 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32150 }
32151 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32152 }
32153 {
32154 PyThreadState* __tstate = wxPyBeginAllowThreads();
32155 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32156 wxPyEndAllowThreads(__tstate);
32157 if (PyErr_Occurred()) SWIG_fail;
32158 }
32159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32160 return resultobj;
32161 fail:
32162 return NULL;
32163 }
32164
32165
32166 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32167 PyObject *resultobj = 0;
32168 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32169 wxDataFormat *result = 0 ;
32170 void *argp1 = 0 ;
32171 int res1 = 0 ;
32172 PyObject *swig_obj[1] ;
32173
32174 if (!args) SWIG_fail;
32175 swig_obj[0] = args;
32176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32177 if (!SWIG_IsOK(res1)) {
32178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32179 }
32180 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32181 {
32182 PyThreadState* __tstate = wxPyBeginAllowThreads();
32183 {
32184 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32185 result = (wxDataFormat *) &_result_ref;
32186 }
32187 wxPyEndAllowThreads(__tstate);
32188 if (PyErr_Occurred()) SWIG_fail;
32189 }
32190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32191 return resultobj;
32192 fail:
32193 return NULL;
32194 }
32195
32196
32197 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32198 PyObject *resultobj = 0;
32199 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32200 wxDataFormat *arg2 = 0 ;
32201 void *argp1 = 0 ;
32202 int res1 = 0 ;
32203 void *argp2 = 0 ;
32204 int res2 = 0 ;
32205 PyObject * obj0 = 0 ;
32206 PyObject * obj1 = 0 ;
32207 char * kwnames[] = {
32208 (char *) "self",(char *) "format", NULL
32209 };
32210
32211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32213 if (!SWIG_IsOK(res1)) {
32214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32215 }
32216 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32217 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32218 if (!SWIG_IsOK(res2)) {
32219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32220 }
32221 if (!argp2) {
32222 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32223 }
32224 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32225 {
32226 PyThreadState* __tstate = wxPyBeginAllowThreads();
32227 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32228 wxPyEndAllowThreads(__tstate);
32229 if (PyErr_Occurred()) SWIG_fail;
32230 }
32231 resultobj = SWIG_Py_Void();
32232 return resultobj;
32233 fail:
32234 return NULL;
32235 }
32236
32237
32238 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32239 PyObject *resultobj = 0;
32240 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32241 size_t result;
32242 void *argp1 = 0 ;
32243 int res1 = 0 ;
32244 PyObject *swig_obj[1] ;
32245
32246 if (!args) SWIG_fail;
32247 swig_obj[0] = args;
32248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32249 if (!SWIG_IsOK(res1)) {
32250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32251 }
32252 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32253 {
32254 PyThreadState* __tstate = wxPyBeginAllowThreads();
32255 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32256 wxPyEndAllowThreads(__tstate);
32257 if (PyErr_Occurred()) SWIG_fail;
32258 }
32259 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32260 return resultobj;
32261 fail:
32262 return NULL;
32263 }
32264
32265
32266 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32267 PyObject *resultobj = 0;
32268 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32269 PyObject *result = 0 ;
32270 void *argp1 = 0 ;
32271 int res1 = 0 ;
32272 PyObject *swig_obj[1] ;
32273
32274 if (!args) SWIG_fail;
32275 swig_obj[0] = args;
32276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32277 if (!SWIG_IsOK(res1)) {
32278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32279 }
32280 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32281 {
32282 PyThreadState* __tstate = wxPyBeginAllowThreads();
32283 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32284 wxPyEndAllowThreads(__tstate);
32285 if (PyErr_Occurred()) SWIG_fail;
32286 }
32287 resultobj = result;
32288 return resultobj;
32289 fail:
32290 return NULL;
32291 }
32292
32293
32294 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32295 PyObject *resultobj = 0;
32296 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32297 PyObject *arg2 = (PyObject *) 0 ;
32298 bool result;
32299 void *argp1 = 0 ;
32300 int res1 = 0 ;
32301 PyObject * obj0 = 0 ;
32302 PyObject * obj1 = 0 ;
32303 char * kwnames[] = {
32304 (char *) "self",(char *) "data", NULL
32305 };
32306
32307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32309 if (!SWIG_IsOK(res1)) {
32310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32311 }
32312 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32313 arg2 = obj1;
32314 {
32315 PyThreadState* __tstate = wxPyBeginAllowThreads();
32316 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32317 wxPyEndAllowThreads(__tstate);
32318 if (PyErr_Occurred()) SWIG_fail;
32319 }
32320 {
32321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32322 }
32323 return resultobj;
32324 fail:
32325 return NULL;
32326 }
32327
32328
32329 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32330 PyObject *obj;
32331 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32332 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32333 return SWIG_Py_Void();
32334 }
32335
32336 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32337 return SWIG_Python_InitShadowInstance(args);
32338 }
32339
32340 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32341 PyObject *resultobj = 0;
32342 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32343 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32344 wxPyDataObjectSimple *result = 0 ;
32345 void *argp1 = 0 ;
32346 int res1 = 0 ;
32347 PyObject * obj0 = 0 ;
32348 char * kwnames[] = {
32349 (char *) "format", NULL
32350 };
32351
32352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32353 if (obj0) {
32354 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32355 if (!SWIG_IsOK(res1)) {
32356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32357 }
32358 if (!argp1) {
32359 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32360 }
32361 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32362 }
32363 {
32364 PyThreadState* __tstate = wxPyBeginAllowThreads();
32365 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32366 wxPyEndAllowThreads(__tstate);
32367 if (PyErr_Occurred()) SWIG_fail;
32368 }
32369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32370 return resultobj;
32371 fail:
32372 return NULL;
32373 }
32374
32375
32376 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32377 PyObject *resultobj = 0;
32378 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32379 PyObject *arg2 = (PyObject *) 0 ;
32380 PyObject *arg3 = (PyObject *) 0 ;
32381 void *argp1 = 0 ;
32382 int res1 = 0 ;
32383 PyObject * obj0 = 0 ;
32384 PyObject * obj1 = 0 ;
32385 PyObject * obj2 = 0 ;
32386 char * kwnames[] = {
32387 (char *) "self",(char *) "self",(char *) "_class", NULL
32388 };
32389
32390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32392 if (!SWIG_IsOK(res1)) {
32393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32394 }
32395 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32396 arg2 = obj1;
32397 arg3 = obj2;
32398 {
32399 PyThreadState* __tstate = wxPyBeginAllowThreads();
32400 (arg1)->_setCallbackInfo(arg2,arg3);
32401 wxPyEndAllowThreads(__tstate);
32402 if (PyErr_Occurred()) SWIG_fail;
32403 }
32404 resultobj = SWIG_Py_Void();
32405 return resultobj;
32406 fail:
32407 return NULL;
32408 }
32409
32410
32411 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32412 PyObject *obj;
32413 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32414 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32415 return SWIG_Py_Void();
32416 }
32417
32418 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32419 return SWIG_Python_InitShadowInstance(args);
32420 }
32421
32422 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32423 PyObject *resultobj = 0;
32424 wxDataObjectComposite *result = 0 ;
32425
32426 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32427 {
32428 PyThreadState* __tstate = wxPyBeginAllowThreads();
32429 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32430 wxPyEndAllowThreads(__tstate);
32431 if (PyErr_Occurred()) SWIG_fail;
32432 }
32433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32434 return resultobj;
32435 fail:
32436 return NULL;
32437 }
32438
32439
32440 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32441 PyObject *resultobj = 0;
32442 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32443 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32444 bool arg3 = (bool) false ;
32445 void *argp1 = 0 ;
32446 int res1 = 0 ;
32447 int res2 = 0 ;
32448 bool val3 ;
32449 int ecode3 = 0 ;
32450 PyObject * obj0 = 0 ;
32451 PyObject * obj1 = 0 ;
32452 PyObject * obj2 = 0 ;
32453 char * kwnames[] = {
32454 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32455 };
32456
32457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32459 if (!SWIG_IsOK(res1)) {
32460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32461 }
32462 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32463 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32464 if (!SWIG_IsOK(res2)) {
32465 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32466 }
32467 if (obj2) {
32468 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32469 if (!SWIG_IsOK(ecode3)) {
32470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32471 }
32472 arg3 = static_cast< bool >(val3);
32473 }
32474 {
32475 PyThreadState* __tstate = wxPyBeginAllowThreads();
32476 (arg1)->Add(arg2,arg3);
32477 wxPyEndAllowThreads(__tstate);
32478 if (PyErr_Occurred()) SWIG_fail;
32479 }
32480 resultobj = SWIG_Py_Void();
32481 return resultobj;
32482 fail:
32483 return NULL;
32484 }
32485
32486
32487 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32488 PyObject *resultobj = 0;
32489 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32490 SwigValueWrapper<wxDataFormat > result;
32491 void *argp1 = 0 ;
32492 int res1 = 0 ;
32493 PyObject *swig_obj[1] ;
32494
32495 if (!args) SWIG_fail;
32496 swig_obj[0] = args;
32497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32498 if (!SWIG_IsOK(res1)) {
32499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32500 }
32501 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32502 {
32503 PyThreadState* __tstate = wxPyBeginAllowThreads();
32504 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32505 wxPyEndAllowThreads(__tstate);
32506 if (PyErr_Occurred()) SWIG_fail;
32507 }
32508 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32509 return resultobj;
32510 fail:
32511 return NULL;
32512 }
32513
32514
32515 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32516 PyObject *obj;
32517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32518 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32519 return SWIG_Py_Void();
32520 }
32521
32522 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32523 return SWIG_Python_InitShadowInstance(args);
32524 }
32525
32526 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32527 PyObject *resultobj = 0;
32528 wxString const &arg1_defvalue = wxPyEmptyString ;
32529 wxString *arg1 = (wxString *) &arg1_defvalue ;
32530 wxTextDataObject *result = 0 ;
32531 bool temp1 = false ;
32532 PyObject * obj0 = 0 ;
32533 char * kwnames[] = {
32534 (char *) "text", NULL
32535 };
32536
32537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32538 if (obj0) {
32539 {
32540 arg1 = wxString_in_helper(obj0);
32541 if (arg1 == NULL) SWIG_fail;
32542 temp1 = true;
32543 }
32544 }
32545 {
32546 PyThreadState* __tstate = wxPyBeginAllowThreads();
32547 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32548 wxPyEndAllowThreads(__tstate);
32549 if (PyErr_Occurred()) SWIG_fail;
32550 }
32551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32552 {
32553 if (temp1)
32554 delete arg1;
32555 }
32556 return resultobj;
32557 fail:
32558 {
32559 if (temp1)
32560 delete arg1;
32561 }
32562 return NULL;
32563 }
32564
32565
32566 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32567 PyObject *resultobj = 0;
32568 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32569 size_t result;
32570 void *argp1 = 0 ;
32571 int res1 = 0 ;
32572 PyObject *swig_obj[1] ;
32573
32574 if (!args) SWIG_fail;
32575 swig_obj[0] = args;
32576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32577 if (!SWIG_IsOK(res1)) {
32578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32579 }
32580 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32581 {
32582 PyThreadState* __tstate = wxPyBeginAllowThreads();
32583 result = (size_t)(arg1)->GetTextLength();
32584 wxPyEndAllowThreads(__tstate);
32585 if (PyErr_Occurred()) SWIG_fail;
32586 }
32587 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32588 return resultobj;
32589 fail:
32590 return NULL;
32591 }
32592
32593
32594 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32595 PyObject *resultobj = 0;
32596 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32597 wxString result;
32598 void *argp1 = 0 ;
32599 int res1 = 0 ;
32600 PyObject *swig_obj[1] ;
32601
32602 if (!args) SWIG_fail;
32603 swig_obj[0] = args;
32604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32605 if (!SWIG_IsOK(res1)) {
32606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32607 }
32608 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32609 {
32610 PyThreadState* __tstate = wxPyBeginAllowThreads();
32611 result = (arg1)->GetText();
32612 wxPyEndAllowThreads(__tstate);
32613 if (PyErr_Occurred()) SWIG_fail;
32614 }
32615 {
32616 #if wxUSE_UNICODE
32617 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32618 #else
32619 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32620 #endif
32621 }
32622 return resultobj;
32623 fail:
32624 return NULL;
32625 }
32626
32627
32628 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32629 PyObject *resultobj = 0;
32630 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32631 wxString *arg2 = 0 ;
32632 void *argp1 = 0 ;
32633 int res1 = 0 ;
32634 bool temp2 = false ;
32635 PyObject * obj0 = 0 ;
32636 PyObject * obj1 = 0 ;
32637 char * kwnames[] = {
32638 (char *) "self",(char *) "text", NULL
32639 };
32640
32641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32643 if (!SWIG_IsOK(res1)) {
32644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32645 }
32646 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32647 {
32648 arg2 = wxString_in_helper(obj1);
32649 if (arg2 == NULL) SWIG_fail;
32650 temp2 = true;
32651 }
32652 {
32653 PyThreadState* __tstate = wxPyBeginAllowThreads();
32654 (arg1)->SetText((wxString const &)*arg2);
32655 wxPyEndAllowThreads(__tstate);
32656 if (PyErr_Occurred()) SWIG_fail;
32657 }
32658 resultobj = SWIG_Py_Void();
32659 {
32660 if (temp2)
32661 delete arg2;
32662 }
32663 return resultobj;
32664 fail:
32665 {
32666 if (temp2)
32667 delete arg2;
32668 }
32669 return NULL;
32670 }
32671
32672
32673 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32674 PyObject *obj;
32675 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32676 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32677 return SWIG_Py_Void();
32678 }
32679
32680 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32681 return SWIG_Python_InitShadowInstance(args);
32682 }
32683
32684 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32685 PyObject *resultobj = 0;
32686 wxString const &arg1_defvalue = wxPyEmptyString ;
32687 wxString *arg1 = (wxString *) &arg1_defvalue ;
32688 wxPyTextDataObject *result = 0 ;
32689 bool temp1 = false ;
32690 PyObject * obj0 = 0 ;
32691 char * kwnames[] = {
32692 (char *) "text", NULL
32693 };
32694
32695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32696 if (obj0) {
32697 {
32698 arg1 = wxString_in_helper(obj0);
32699 if (arg1 == NULL) SWIG_fail;
32700 temp1 = true;
32701 }
32702 }
32703 {
32704 PyThreadState* __tstate = wxPyBeginAllowThreads();
32705 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32706 wxPyEndAllowThreads(__tstate);
32707 if (PyErr_Occurred()) SWIG_fail;
32708 }
32709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32710 {
32711 if (temp1)
32712 delete arg1;
32713 }
32714 return resultobj;
32715 fail:
32716 {
32717 if (temp1)
32718 delete arg1;
32719 }
32720 return NULL;
32721 }
32722
32723
32724 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32725 PyObject *resultobj = 0;
32726 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32727 PyObject *arg2 = (PyObject *) 0 ;
32728 PyObject *arg3 = (PyObject *) 0 ;
32729 void *argp1 = 0 ;
32730 int res1 = 0 ;
32731 PyObject * obj0 = 0 ;
32732 PyObject * obj1 = 0 ;
32733 PyObject * obj2 = 0 ;
32734 char * kwnames[] = {
32735 (char *) "self",(char *) "self",(char *) "_class", NULL
32736 };
32737
32738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32740 if (!SWIG_IsOK(res1)) {
32741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32742 }
32743 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32744 arg2 = obj1;
32745 arg3 = obj2;
32746 {
32747 PyThreadState* __tstate = wxPyBeginAllowThreads();
32748 (arg1)->_setCallbackInfo(arg2,arg3);
32749 wxPyEndAllowThreads(__tstate);
32750 if (PyErr_Occurred()) SWIG_fail;
32751 }
32752 resultobj = SWIG_Py_Void();
32753 return resultobj;
32754 fail:
32755 return NULL;
32756 }
32757
32758
32759 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32760 PyObject *obj;
32761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32762 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32763 return SWIG_Py_Void();
32764 }
32765
32766 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32767 return SWIG_Python_InitShadowInstance(args);
32768 }
32769
32770 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32771 PyObject *resultobj = 0;
32772 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32773 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32774 wxBitmapDataObject *result = 0 ;
32775 void *argp1 = 0 ;
32776 int res1 = 0 ;
32777 PyObject * obj0 = 0 ;
32778 char * kwnames[] = {
32779 (char *) "bitmap", NULL
32780 };
32781
32782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
32783 if (obj0) {
32784 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32785 if (!SWIG_IsOK(res1)) {
32786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32787 }
32788 if (!argp1) {
32789 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32790 }
32791 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32792 }
32793 {
32794 PyThreadState* __tstate = wxPyBeginAllowThreads();
32795 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
32796 wxPyEndAllowThreads(__tstate);
32797 if (PyErr_Occurred()) SWIG_fail;
32798 }
32799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
32800 return resultobj;
32801 fail:
32802 return NULL;
32803 }
32804
32805
32806 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32807 PyObject *resultobj = 0;
32808 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32809 wxBitmap result;
32810 void *argp1 = 0 ;
32811 int res1 = 0 ;
32812 PyObject *swig_obj[1] ;
32813
32814 if (!args) SWIG_fail;
32815 swig_obj[0] = args;
32816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32817 if (!SWIG_IsOK(res1)) {
32818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
32819 }
32820 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32821 {
32822 PyThreadState* __tstate = wxPyBeginAllowThreads();
32823 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
32824 wxPyEndAllowThreads(__tstate);
32825 if (PyErr_Occurred()) SWIG_fail;
32826 }
32827 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
32828 return resultobj;
32829 fail:
32830 return NULL;
32831 }
32832
32833
32834 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32835 PyObject *resultobj = 0;
32836 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32837 wxBitmap *arg2 = 0 ;
32838 void *argp1 = 0 ;
32839 int res1 = 0 ;
32840 void *argp2 = 0 ;
32841 int res2 = 0 ;
32842 PyObject * obj0 = 0 ;
32843 PyObject * obj1 = 0 ;
32844 char * kwnames[] = {
32845 (char *) "self",(char *) "bitmap", NULL
32846 };
32847
32848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
32849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32850 if (!SWIG_IsOK(res1)) {
32851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
32852 }
32853 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32854 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
32855 if (!SWIG_IsOK(res2)) {
32856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32857 }
32858 if (!argp2) {
32859 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32860 }
32861 arg2 = reinterpret_cast< wxBitmap * >(argp2);
32862 {
32863 PyThreadState* __tstate = wxPyBeginAllowThreads();
32864 (arg1)->SetBitmap((wxBitmap const &)*arg2);
32865 wxPyEndAllowThreads(__tstate);
32866 if (PyErr_Occurred()) SWIG_fail;
32867 }
32868 resultobj = SWIG_Py_Void();
32869 return resultobj;
32870 fail:
32871 return NULL;
32872 }
32873
32874
32875 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32876 PyObject *obj;
32877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32878 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
32879 return SWIG_Py_Void();
32880 }
32881
32882 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32883 return SWIG_Python_InitShadowInstance(args);
32884 }
32885
32886 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32887 PyObject *resultobj = 0;
32888 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32889 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32890 wxPyBitmapDataObject *result = 0 ;
32891 void *argp1 = 0 ;
32892 int res1 = 0 ;
32893 PyObject * obj0 = 0 ;
32894 char * kwnames[] = {
32895 (char *) "bitmap", NULL
32896 };
32897
32898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
32899 if (obj0) {
32900 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32901 if (!SWIG_IsOK(res1)) {
32902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32903 }
32904 if (!argp1) {
32905 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32906 }
32907 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32908 }
32909 {
32910 PyThreadState* __tstate = wxPyBeginAllowThreads();
32911 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
32912 wxPyEndAllowThreads(__tstate);
32913 if (PyErr_Occurred()) SWIG_fail;
32914 }
32915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
32916 return resultobj;
32917 fail:
32918 return NULL;
32919 }
32920
32921
32922 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32923 PyObject *resultobj = 0;
32924 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
32925 PyObject *arg2 = (PyObject *) 0 ;
32926 PyObject *arg3 = (PyObject *) 0 ;
32927 void *argp1 = 0 ;
32928 int res1 = 0 ;
32929 PyObject * obj0 = 0 ;
32930 PyObject * obj1 = 0 ;
32931 PyObject * obj2 = 0 ;
32932 char * kwnames[] = {
32933 (char *) "self",(char *) "self",(char *) "_class", NULL
32934 };
32935
32936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
32938 if (!SWIG_IsOK(res1)) {
32939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
32940 }
32941 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
32942 arg2 = obj1;
32943 arg3 = obj2;
32944 {
32945 PyThreadState* __tstate = wxPyBeginAllowThreads();
32946 (arg1)->_setCallbackInfo(arg2,arg3);
32947 wxPyEndAllowThreads(__tstate);
32948 if (PyErr_Occurred()) SWIG_fail;
32949 }
32950 resultobj = SWIG_Py_Void();
32951 return resultobj;
32952 fail:
32953 return NULL;
32954 }
32955
32956
32957 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32958 PyObject *obj;
32959 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32960 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
32961 return SWIG_Py_Void();
32962 }
32963
32964 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32965 return SWIG_Python_InitShadowInstance(args);
32966 }
32967
32968 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32969 PyObject *resultobj = 0;
32970 wxFileDataObject *result = 0 ;
32971
32972 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
32973 {
32974 PyThreadState* __tstate = wxPyBeginAllowThreads();
32975 result = (wxFileDataObject *)new wxFileDataObject();
32976 wxPyEndAllowThreads(__tstate);
32977 if (PyErr_Occurred()) SWIG_fail;
32978 }
32979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
32980 return resultobj;
32981 fail:
32982 return NULL;
32983 }
32984
32985
32986 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32987 PyObject *resultobj = 0;
32988 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32989 wxArrayString *result = 0 ;
32990 void *argp1 = 0 ;
32991 int res1 = 0 ;
32992 PyObject *swig_obj[1] ;
32993
32994 if (!args) SWIG_fail;
32995 swig_obj[0] = args;
32996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32997 if (!SWIG_IsOK(res1)) {
32998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32999 }
33000 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33001 {
33002 PyThreadState* __tstate = wxPyBeginAllowThreads();
33003 {
33004 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33005 result = (wxArrayString *) &_result_ref;
33006 }
33007 wxPyEndAllowThreads(__tstate);
33008 if (PyErr_Occurred()) SWIG_fail;
33009 }
33010 {
33011 resultobj = wxArrayString2PyList_helper(*result);
33012 }
33013 return resultobj;
33014 fail:
33015 return NULL;
33016 }
33017
33018
33019 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33020 PyObject *resultobj = 0;
33021 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33022 wxString *arg2 = 0 ;
33023 void *argp1 = 0 ;
33024 int res1 = 0 ;
33025 bool temp2 = false ;
33026 PyObject * obj0 = 0 ;
33027 PyObject * obj1 = 0 ;
33028 char * kwnames[] = {
33029 (char *) "self",(char *) "filename", NULL
33030 };
33031
33032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33034 if (!SWIG_IsOK(res1)) {
33035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33036 }
33037 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33038 {
33039 arg2 = wxString_in_helper(obj1);
33040 if (arg2 == NULL) SWIG_fail;
33041 temp2 = true;
33042 }
33043 {
33044 PyThreadState* __tstate = wxPyBeginAllowThreads();
33045 (arg1)->AddFile((wxString const &)*arg2);
33046 wxPyEndAllowThreads(__tstate);
33047 if (PyErr_Occurred()) SWIG_fail;
33048 }
33049 resultobj = SWIG_Py_Void();
33050 {
33051 if (temp2)
33052 delete arg2;
33053 }
33054 return resultobj;
33055 fail:
33056 {
33057 if (temp2)
33058 delete arg2;
33059 }
33060 return NULL;
33061 }
33062
33063
33064 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33065 PyObject *obj;
33066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33067 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33068 return SWIG_Py_Void();
33069 }
33070
33071 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33072 return SWIG_Python_InitShadowInstance(args);
33073 }
33074
33075 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33076 PyObject *resultobj = 0;
33077 wxDataFormat *arg1 = 0 ;
33078 wxCustomDataObject *result = 0 ;
33079 void *argp1 = 0 ;
33080 int res1 = 0 ;
33081
33082 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33084 if (!SWIG_IsOK(res1)) {
33085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33086 }
33087 if (!argp1) {
33088 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33089 }
33090 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33091 {
33092 PyThreadState* __tstate = wxPyBeginAllowThreads();
33093 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33094 wxPyEndAllowThreads(__tstate);
33095 if (PyErr_Occurred()) SWIG_fail;
33096 }
33097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33098 return resultobj;
33099 fail:
33100 return NULL;
33101 }
33102
33103
33104 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33105 PyObject *resultobj = 0;
33106 wxString *arg1 = 0 ;
33107 wxCustomDataObject *result = 0 ;
33108 bool temp1 = false ;
33109
33110 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33111 {
33112 arg1 = wxString_in_helper(swig_obj[0]);
33113 if (arg1 == NULL) SWIG_fail;
33114 temp1 = true;
33115 }
33116 {
33117 PyThreadState* __tstate = wxPyBeginAllowThreads();
33118 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33119 wxPyEndAllowThreads(__tstate);
33120 if (PyErr_Occurred()) SWIG_fail;
33121 }
33122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33123 {
33124 if (temp1)
33125 delete arg1;
33126 }
33127 return resultobj;
33128 fail:
33129 {
33130 if (temp1)
33131 delete arg1;
33132 }
33133 return NULL;
33134 }
33135
33136
33137 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33138 PyObject *resultobj = 0;
33139 wxCustomDataObject *result = 0 ;
33140
33141 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33142 {
33143 PyThreadState* __tstate = wxPyBeginAllowThreads();
33144 result = (wxCustomDataObject *)new wxCustomDataObject();
33145 wxPyEndAllowThreads(__tstate);
33146 if (PyErr_Occurred()) SWIG_fail;
33147 }
33148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33149 return resultobj;
33150 fail:
33151 return NULL;
33152 }
33153
33154
33155 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33156 int argc;
33157 PyObject *argv[2];
33158
33159 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33160 --argc;
33161 if (argc == 0) {
33162 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33163 }
33164 if (argc == 1) {
33165 int _v = 0;
33166 {
33167 {
33168 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33169 }
33170 }
33171 if (!_v) goto check_2;
33172 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33173 }
33174 check_2:
33175
33176 if (argc == 1) {
33177 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33178 }
33179
33180 fail:
33181 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33182 return NULL;
33183 }
33184
33185
33186 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33187 PyObject *resultobj = 0;
33188 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33189 PyObject *arg2 = (PyObject *) 0 ;
33190 bool result;
33191 void *argp1 = 0 ;
33192 int res1 = 0 ;
33193 PyObject * obj0 = 0 ;
33194 PyObject * obj1 = 0 ;
33195 char * kwnames[] = {
33196 (char *) "self",(char *) "data", NULL
33197 };
33198
33199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33201 if (!SWIG_IsOK(res1)) {
33202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33203 }
33204 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33205 arg2 = obj1;
33206 {
33207 PyThreadState* __tstate = wxPyBeginAllowThreads();
33208 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33209 wxPyEndAllowThreads(__tstate);
33210 if (PyErr_Occurred()) SWIG_fail;
33211 }
33212 {
33213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33214 }
33215 return resultobj;
33216 fail:
33217 return NULL;
33218 }
33219
33220
33221 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33222 PyObject *resultobj = 0;
33223 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33224 size_t result;
33225 void *argp1 = 0 ;
33226 int res1 = 0 ;
33227 PyObject *swig_obj[1] ;
33228
33229 if (!args) SWIG_fail;
33230 swig_obj[0] = args;
33231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33232 if (!SWIG_IsOK(res1)) {
33233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33234 }
33235 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33236 {
33237 PyThreadState* __tstate = wxPyBeginAllowThreads();
33238 result = (size_t)(arg1)->GetSize();
33239 wxPyEndAllowThreads(__tstate);
33240 if (PyErr_Occurred()) SWIG_fail;
33241 }
33242 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33243 return resultobj;
33244 fail:
33245 return NULL;
33246 }
33247
33248
33249 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33250 PyObject *resultobj = 0;
33251 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33252 PyObject *result = 0 ;
33253 void *argp1 = 0 ;
33254 int res1 = 0 ;
33255 PyObject *swig_obj[1] ;
33256
33257 if (!args) SWIG_fail;
33258 swig_obj[0] = args;
33259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33260 if (!SWIG_IsOK(res1)) {
33261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33262 }
33263 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33264 {
33265 PyThreadState* __tstate = wxPyBeginAllowThreads();
33266 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33267 wxPyEndAllowThreads(__tstate);
33268 if (PyErr_Occurred()) SWIG_fail;
33269 }
33270 resultobj = result;
33271 return resultobj;
33272 fail:
33273 return NULL;
33274 }
33275
33276
33277 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33278 PyObject *obj;
33279 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33280 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33281 return SWIG_Py_Void();
33282 }
33283
33284 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33285 return SWIG_Python_InitShadowInstance(args);
33286 }
33287
33288 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33289 PyObject *resultobj = 0;
33290 wxString const &arg1_defvalue = wxPyEmptyString ;
33291 wxString *arg1 = (wxString *) &arg1_defvalue ;
33292 wxURLDataObject *result = 0 ;
33293 bool temp1 = false ;
33294 PyObject * obj0 = 0 ;
33295 char * kwnames[] = {
33296 (char *) "url", NULL
33297 };
33298
33299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33300 if (obj0) {
33301 {
33302 arg1 = wxString_in_helper(obj0);
33303 if (arg1 == NULL) SWIG_fail;
33304 temp1 = true;
33305 }
33306 }
33307 {
33308 PyThreadState* __tstate = wxPyBeginAllowThreads();
33309 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33310 wxPyEndAllowThreads(__tstate);
33311 if (PyErr_Occurred()) SWIG_fail;
33312 }
33313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33314 {
33315 if (temp1)
33316 delete arg1;
33317 }
33318 return resultobj;
33319 fail:
33320 {
33321 if (temp1)
33322 delete arg1;
33323 }
33324 return NULL;
33325 }
33326
33327
33328 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33329 PyObject *resultobj = 0;
33330 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33331 wxString result;
33332 void *argp1 = 0 ;
33333 int res1 = 0 ;
33334 PyObject *swig_obj[1] ;
33335
33336 if (!args) SWIG_fail;
33337 swig_obj[0] = args;
33338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33339 if (!SWIG_IsOK(res1)) {
33340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33341 }
33342 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33343 {
33344 PyThreadState* __tstate = wxPyBeginAllowThreads();
33345 result = (arg1)->GetURL();
33346 wxPyEndAllowThreads(__tstate);
33347 if (PyErr_Occurred()) SWIG_fail;
33348 }
33349 {
33350 #if wxUSE_UNICODE
33351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33352 #else
33353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33354 #endif
33355 }
33356 return resultobj;
33357 fail:
33358 return NULL;
33359 }
33360
33361
33362 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33363 PyObject *resultobj = 0;
33364 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33365 wxString *arg2 = 0 ;
33366 void *argp1 = 0 ;
33367 int res1 = 0 ;
33368 bool temp2 = false ;
33369 PyObject * obj0 = 0 ;
33370 PyObject * obj1 = 0 ;
33371 char * kwnames[] = {
33372 (char *) "self",(char *) "url", NULL
33373 };
33374
33375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33377 if (!SWIG_IsOK(res1)) {
33378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33379 }
33380 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33381 {
33382 arg2 = wxString_in_helper(obj1);
33383 if (arg2 == NULL) SWIG_fail;
33384 temp2 = true;
33385 }
33386 {
33387 PyThreadState* __tstate = wxPyBeginAllowThreads();
33388 (arg1)->SetURL((wxString const &)*arg2);
33389 wxPyEndAllowThreads(__tstate);
33390 if (PyErr_Occurred()) SWIG_fail;
33391 }
33392 resultobj = SWIG_Py_Void();
33393 {
33394 if (temp2)
33395 delete arg2;
33396 }
33397 return resultobj;
33398 fail:
33399 {
33400 if (temp2)
33401 delete arg2;
33402 }
33403 return NULL;
33404 }
33405
33406
33407 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33408 PyObject *obj;
33409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33410 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33411 return SWIG_Py_Void();
33412 }
33413
33414 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33415 return SWIG_Python_InitShadowInstance(args);
33416 }
33417
33418 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33419 PyObject *resultobj = 0;
33420 wxMetafileDataObject *result = 0 ;
33421
33422 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33423 {
33424 PyThreadState* __tstate = wxPyBeginAllowThreads();
33425 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33426 wxPyEndAllowThreads(__tstate);
33427 if (PyErr_Occurred()) SWIG_fail;
33428 }
33429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33430 return resultobj;
33431 fail:
33432 return NULL;
33433 }
33434
33435
33436 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33437 PyObject *obj;
33438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33439 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33440 return SWIG_Py_Void();
33441 }
33442
33443 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33444 return SWIG_Python_InitShadowInstance(args);
33445 }
33446
33447 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33448 PyObject *resultobj = 0;
33449 wxDragResult arg1 ;
33450 bool result;
33451 int val1 ;
33452 int ecode1 = 0 ;
33453 PyObject * obj0 = 0 ;
33454 char * kwnames[] = {
33455 (char *) "res", NULL
33456 };
33457
33458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33459 ecode1 = SWIG_AsVal_int(obj0, &val1);
33460 if (!SWIG_IsOK(ecode1)) {
33461 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33462 }
33463 arg1 = static_cast< wxDragResult >(val1);
33464 {
33465 PyThreadState* __tstate = wxPyBeginAllowThreads();
33466 result = (bool)wxIsDragResultOk(arg1);
33467 wxPyEndAllowThreads(__tstate);
33468 if (PyErr_Occurred()) SWIG_fail;
33469 }
33470 {
33471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33472 }
33473 return resultobj;
33474 fail:
33475 return NULL;
33476 }
33477
33478
33479 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33480 PyObject *resultobj = 0;
33481 wxWindow *arg1 = (wxWindow *) 0 ;
33482 wxIcon const &arg2_defvalue = wxNullIcon ;
33483 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
33484 wxIcon const &arg3_defvalue = wxNullIcon ;
33485 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
33486 wxIcon const &arg4_defvalue = wxNullIcon ;
33487 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
33488 wxPyDropSource *result = 0 ;
33489 void *argp1 = 0 ;
33490 int res1 = 0 ;
33491 void *argp2 = 0 ;
33492 int res2 = 0 ;
33493 void *argp3 = 0 ;
33494 int res3 = 0 ;
33495 void *argp4 = 0 ;
33496 int res4 = 0 ;
33497 PyObject * obj0 = 0 ;
33498 PyObject * obj1 = 0 ;
33499 PyObject * obj2 = 0 ;
33500 PyObject * obj3 = 0 ;
33501 char * kwnames[] = {
33502 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33503 };
33504
33505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33507 if (!SWIG_IsOK(res1)) {
33508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33509 }
33510 arg1 = reinterpret_cast< wxWindow * >(argp1);
33511 if (obj1) {
33512 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
33513 if (!SWIG_IsOK(res2)) {
33514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33515 }
33516 if (!argp2) {
33517 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33518 }
33519 arg2 = reinterpret_cast< wxIcon * >(argp2);
33520 }
33521 if (obj2) {
33522 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
33523 if (!SWIG_IsOK(res3)) {
33524 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33525 }
33526 if (!argp3) {
33527 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33528 }
33529 arg3 = reinterpret_cast< wxIcon * >(argp3);
33530 }
33531 if (obj3) {
33532 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
33533 if (!SWIG_IsOK(res4)) {
33534 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33535 }
33536 if (!argp4) {
33537 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33538 }
33539 arg4 = reinterpret_cast< wxIcon * >(argp4);
33540 }
33541 {
33542 PyThreadState* __tstate = wxPyBeginAllowThreads();
33543 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
33544 wxPyEndAllowThreads(__tstate);
33545 if (PyErr_Occurred()) SWIG_fail;
33546 }
33547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33548 return resultobj;
33549 fail:
33550 return NULL;
33551 }
33552
33553
33554 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33555 PyObject *resultobj = 0;
33556 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33557 PyObject *arg2 = (PyObject *) 0 ;
33558 PyObject *arg3 = (PyObject *) 0 ;
33559 int arg4 ;
33560 void *argp1 = 0 ;
33561 int res1 = 0 ;
33562 int val4 ;
33563 int ecode4 = 0 ;
33564 PyObject * obj0 = 0 ;
33565 PyObject * obj1 = 0 ;
33566 PyObject * obj2 = 0 ;
33567 PyObject * obj3 = 0 ;
33568 char * kwnames[] = {
33569 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33570 };
33571
33572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33574 if (!SWIG_IsOK(res1)) {
33575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33576 }
33577 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33578 arg2 = obj1;
33579 arg3 = obj2;
33580 ecode4 = SWIG_AsVal_int(obj3, &val4);
33581 if (!SWIG_IsOK(ecode4)) {
33582 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33583 }
33584 arg4 = static_cast< int >(val4);
33585 {
33586 PyThreadState* __tstate = wxPyBeginAllowThreads();
33587 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33588 wxPyEndAllowThreads(__tstate);
33589 if (PyErr_Occurred()) SWIG_fail;
33590 }
33591 resultobj = SWIG_Py_Void();
33592 return resultobj;
33593 fail:
33594 return NULL;
33595 }
33596
33597
33598 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33599 PyObject *resultobj = 0;
33600 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33601 void *argp1 = 0 ;
33602 int res1 = 0 ;
33603 PyObject *swig_obj[1] ;
33604
33605 if (!args) SWIG_fail;
33606 swig_obj[0] = args;
33607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33608 if (!SWIG_IsOK(res1)) {
33609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33610 }
33611 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33612 {
33613 PyThreadState* __tstate = wxPyBeginAllowThreads();
33614 delete arg1;
33615
33616 wxPyEndAllowThreads(__tstate);
33617 if (PyErr_Occurred()) SWIG_fail;
33618 }
33619 resultobj = SWIG_Py_Void();
33620 return resultobj;
33621 fail:
33622 return NULL;
33623 }
33624
33625
33626 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33627 PyObject *resultobj = 0;
33628 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33629 wxDataObject *arg2 = 0 ;
33630 void *argp1 = 0 ;
33631 int res1 = 0 ;
33632 void *argp2 = 0 ;
33633 int res2 = 0 ;
33634 PyObject * obj0 = 0 ;
33635 PyObject * obj1 = 0 ;
33636 char * kwnames[] = {
33637 (char *) "self",(char *) "data", NULL
33638 };
33639
33640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33642 if (!SWIG_IsOK(res1)) {
33643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33644 }
33645 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33646 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33647 if (!SWIG_IsOK(res2)) {
33648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33649 }
33650 if (!argp2) {
33651 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33652 }
33653 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33654 {
33655 PyThreadState* __tstate = wxPyBeginAllowThreads();
33656 (arg1)->SetData(*arg2);
33657 wxPyEndAllowThreads(__tstate);
33658 if (PyErr_Occurred()) SWIG_fail;
33659 }
33660 resultobj = SWIG_Py_Void();
33661 return resultobj;
33662 fail:
33663 return NULL;
33664 }
33665
33666
33667 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33668 PyObject *resultobj = 0;
33669 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33670 wxDataObject *result = 0 ;
33671 void *argp1 = 0 ;
33672 int res1 = 0 ;
33673 PyObject *swig_obj[1] ;
33674
33675 if (!args) SWIG_fail;
33676 swig_obj[0] = args;
33677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33678 if (!SWIG_IsOK(res1)) {
33679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33680 }
33681 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33682 {
33683 PyThreadState* __tstate = wxPyBeginAllowThreads();
33684 result = (wxDataObject *)(arg1)->GetDataObject();
33685 wxPyEndAllowThreads(__tstate);
33686 if (PyErr_Occurred()) SWIG_fail;
33687 }
33688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33689 return resultobj;
33690 fail:
33691 return NULL;
33692 }
33693
33694
33695 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33696 PyObject *resultobj = 0;
33697 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33698 wxDragResult arg2 ;
33699 wxCursor *arg3 = 0 ;
33700 void *argp1 = 0 ;
33701 int res1 = 0 ;
33702 int val2 ;
33703 int ecode2 = 0 ;
33704 void *argp3 = 0 ;
33705 int res3 = 0 ;
33706 PyObject * obj0 = 0 ;
33707 PyObject * obj1 = 0 ;
33708 PyObject * obj2 = 0 ;
33709 char * kwnames[] = {
33710 (char *) "self",(char *) "res",(char *) "cursor", NULL
33711 };
33712
33713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33715 if (!SWIG_IsOK(res1)) {
33716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33717 }
33718 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33719 ecode2 = SWIG_AsVal_int(obj1, &val2);
33720 if (!SWIG_IsOK(ecode2)) {
33721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33722 }
33723 arg2 = static_cast< wxDragResult >(val2);
33724 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33725 if (!SWIG_IsOK(res3)) {
33726 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33727 }
33728 if (!argp3) {
33729 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33730 }
33731 arg3 = reinterpret_cast< wxCursor * >(argp3);
33732 {
33733 PyThreadState* __tstate = wxPyBeginAllowThreads();
33734 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33735 wxPyEndAllowThreads(__tstate);
33736 if (PyErr_Occurred()) SWIG_fail;
33737 }
33738 resultobj = SWIG_Py_Void();
33739 return resultobj;
33740 fail:
33741 return NULL;
33742 }
33743
33744
33745 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33746 PyObject *resultobj = 0;
33747 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33748 int arg2 = (int) wxDrag_CopyOnly ;
33749 wxDragResult result;
33750 void *argp1 = 0 ;
33751 int res1 = 0 ;
33752 int val2 ;
33753 int ecode2 = 0 ;
33754 PyObject * obj0 = 0 ;
33755 PyObject * obj1 = 0 ;
33756 char * kwnames[] = {
33757 (char *) "self",(char *) "flags", NULL
33758 };
33759
33760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
33761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33762 if (!SWIG_IsOK(res1)) {
33763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33764 }
33765 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33766 if (obj1) {
33767 ecode2 = SWIG_AsVal_int(obj1, &val2);
33768 if (!SWIG_IsOK(ecode2)) {
33769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
33770 }
33771 arg2 = static_cast< int >(val2);
33772 }
33773 {
33774 PyThreadState* __tstate = wxPyBeginAllowThreads();
33775 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
33776 wxPyEndAllowThreads(__tstate);
33777 if (PyErr_Occurred()) SWIG_fail;
33778 }
33779 resultobj = SWIG_From_int(static_cast< int >(result));
33780 return resultobj;
33781 fail:
33782 return NULL;
33783 }
33784
33785
33786 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33787 PyObject *resultobj = 0;
33788 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33789 wxDragResult arg2 ;
33790 bool result;
33791 void *argp1 = 0 ;
33792 int res1 = 0 ;
33793 int val2 ;
33794 int ecode2 = 0 ;
33795 PyObject * obj0 = 0 ;
33796 PyObject * obj1 = 0 ;
33797 char * kwnames[] = {
33798 (char *) "self",(char *) "effect", NULL
33799 };
33800
33801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
33802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33803 if (!SWIG_IsOK(res1)) {
33804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33805 }
33806 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33807 ecode2 = SWIG_AsVal_int(obj1, &val2);
33808 if (!SWIG_IsOK(ecode2)) {
33809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
33810 }
33811 arg2 = static_cast< wxDragResult >(val2);
33812 {
33813 PyThreadState* __tstate = wxPyBeginAllowThreads();
33814 result = (bool)(arg1)->GiveFeedback(arg2);
33815 wxPyEndAllowThreads(__tstate);
33816 if (PyErr_Occurred()) SWIG_fail;
33817 }
33818 {
33819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33820 }
33821 return resultobj;
33822 fail:
33823 return NULL;
33824 }
33825
33826
33827 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33828 PyObject *obj;
33829 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33830 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
33831 return SWIG_Py_Void();
33832 }
33833
33834 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33835 return SWIG_Python_InitShadowInstance(args);
33836 }
33837
33838 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33839 PyObject *resultobj = 0;
33840 wxDataObject *arg1 = (wxDataObject *) NULL ;
33841 wxPyDropTarget *result = 0 ;
33842 int res1 = 0 ;
33843 PyObject * obj0 = 0 ;
33844 char * kwnames[] = {
33845 (char *) "dataObject", NULL
33846 };
33847
33848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
33849 if (obj0) {
33850 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
33851 if (!SWIG_IsOK(res1)) {
33852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
33853 }
33854 }
33855 {
33856 PyThreadState* __tstate = wxPyBeginAllowThreads();
33857 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
33858 wxPyEndAllowThreads(__tstate);
33859 if (PyErr_Occurred()) SWIG_fail;
33860 }
33861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
33862 return resultobj;
33863 fail:
33864 return NULL;
33865 }
33866
33867
33868 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33869 PyObject *resultobj = 0;
33870 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33871 PyObject *arg2 = (PyObject *) 0 ;
33872 PyObject *arg3 = (PyObject *) 0 ;
33873 void *argp1 = 0 ;
33874 int res1 = 0 ;
33875 PyObject * obj0 = 0 ;
33876 PyObject * obj1 = 0 ;
33877 PyObject * obj2 = 0 ;
33878 char * kwnames[] = {
33879 (char *) "self",(char *) "self",(char *) "_class", NULL
33880 };
33881
33882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33884 if (!SWIG_IsOK(res1)) {
33885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33886 }
33887 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33888 arg2 = obj1;
33889 arg3 = obj2;
33890 {
33891 PyThreadState* __tstate = wxPyBeginAllowThreads();
33892 (arg1)->_setCallbackInfo(arg2,arg3);
33893 wxPyEndAllowThreads(__tstate);
33894 if (PyErr_Occurred()) SWIG_fail;
33895 }
33896 resultobj = SWIG_Py_Void();
33897 return resultobj;
33898 fail:
33899 return NULL;
33900 }
33901
33902
33903 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33904 PyObject *resultobj = 0;
33905 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33906 void *argp1 = 0 ;
33907 int res1 = 0 ;
33908 PyObject *swig_obj[1] ;
33909
33910 if (!args) SWIG_fail;
33911 swig_obj[0] = args;
33912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
33913 if (!SWIG_IsOK(res1)) {
33914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33915 }
33916 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33917 {
33918 PyThreadState* __tstate = wxPyBeginAllowThreads();
33919 delete arg1;
33920
33921 wxPyEndAllowThreads(__tstate);
33922 if (PyErr_Occurred()) SWIG_fail;
33923 }
33924 resultobj = SWIG_Py_Void();
33925 return resultobj;
33926 fail:
33927 return NULL;
33928 }
33929
33930
33931 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33932 PyObject *resultobj = 0;
33933 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33934 wxDataObject *result = 0 ;
33935 void *argp1 = 0 ;
33936 int res1 = 0 ;
33937 PyObject *swig_obj[1] ;
33938
33939 if (!args) SWIG_fail;
33940 swig_obj[0] = args;
33941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33942 if (!SWIG_IsOK(res1)) {
33943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33944 }
33945 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33946 {
33947 PyThreadState* __tstate = wxPyBeginAllowThreads();
33948 result = (wxDataObject *)(arg1)->GetDataObject();
33949 wxPyEndAllowThreads(__tstate);
33950 if (PyErr_Occurred()) SWIG_fail;
33951 }
33952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33953 return resultobj;
33954 fail:
33955 return NULL;
33956 }
33957
33958
33959 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33960 PyObject *resultobj = 0;
33961 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33962 wxDataObject *arg2 = (wxDataObject *) 0 ;
33963 void *argp1 = 0 ;
33964 int res1 = 0 ;
33965 int res2 = 0 ;
33966 PyObject * obj0 = 0 ;
33967 PyObject * obj1 = 0 ;
33968 char * kwnames[] = {
33969 (char *) "self",(char *) "dataObject", NULL
33970 };
33971
33972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
33973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33974 if (!SWIG_IsOK(res1)) {
33975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33976 }
33977 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33978 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
33979 if (!SWIG_IsOK(res2)) {
33980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
33981 }
33982 {
33983 PyThreadState* __tstate = wxPyBeginAllowThreads();
33984 (arg1)->SetDataObject(arg2);
33985 wxPyEndAllowThreads(__tstate);
33986 if (PyErr_Occurred()) SWIG_fail;
33987 }
33988 resultobj = SWIG_Py_Void();
33989 return resultobj;
33990 fail:
33991 return NULL;
33992 }
33993
33994
33995 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33996 PyObject *resultobj = 0;
33997 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33998 int arg2 ;
33999 int arg3 ;
34000 wxDragResult arg4 ;
34001 wxDragResult result;
34002 void *argp1 = 0 ;
34003 int res1 = 0 ;
34004 int val2 ;
34005 int ecode2 = 0 ;
34006 int val3 ;
34007 int ecode3 = 0 ;
34008 int val4 ;
34009 int ecode4 = 0 ;
34010 PyObject * obj0 = 0 ;
34011 PyObject * obj1 = 0 ;
34012 PyObject * obj2 = 0 ;
34013 PyObject * obj3 = 0 ;
34014 char * kwnames[] = {
34015 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34016 };
34017
34018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34020 if (!SWIG_IsOK(res1)) {
34021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34022 }
34023 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34024 ecode2 = SWIG_AsVal_int(obj1, &val2);
34025 if (!SWIG_IsOK(ecode2)) {
34026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34027 }
34028 arg2 = static_cast< int >(val2);
34029 ecode3 = SWIG_AsVal_int(obj2, &val3);
34030 if (!SWIG_IsOK(ecode3)) {
34031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34032 }
34033 arg3 = static_cast< int >(val3);
34034 ecode4 = SWIG_AsVal_int(obj3, &val4);
34035 if (!SWIG_IsOK(ecode4)) {
34036 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34037 }
34038 arg4 = static_cast< wxDragResult >(val4);
34039 {
34040 PyThreadState* __tstate = wxPyBeginAllowThreads();
34041 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34042 wxPyEndAllowThreads(__tstate);
34043 if (PyErr_Occurred()) SWIG_fail;
34044 }
34045 resultobj = SWIG_From_int(static_cast< int >(result));
34046 return resultobj;
34047 fail:
34048 return NULL;
34049 }
34050
34051
34052 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34053 PyObject *resultobj = 0;
34054 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34055 int arg2 ;
34056 int arg3 ;
34057 wxDragResult arg4 ;
34058 wxDragResult result;
34059 void *argp1 = 0 ;
34060 int res1 = 0 ;
34061 int val2 ;
34062 int ecode2 = 0 ;
34063 int val3 ;
34064 int ecode3 = 0 ;
34065 int val4 ;
34066 int ecode4 = 0 ;
34067 PyObject * obj0 = 0 ;
34068 PyObject * obj1 = 0 ;
34069 PyObject * obj2 = 0 ;
34070 PyObject * obj3 = 0 ;
34071 char * kwnames[] = {
34072 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34073 };
34074
34075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34077 if (!SWIG_IsOK(res1)) {
34078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34079 }
34080 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34081 ecode2 = SWIG_AsVal_int(obj1, &val2);
34082 if (!SWIG_IsOK(ecode2)) {
34083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34084 }
34085 arg2 = static_cast< int >(val2);
34086 ecode3 = SWIG_AsVal_int(obj2, &val3);
34087 if (!SWIG_IsOK(ecode3)) {
34088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34089 }
34090 arg3 = static_cast< int >(val3);
34091 ecode4 = SWIG_AsVal_int(obj3, &val4);
34092 if (!SWIG_IsOK(ecode4)) {
34093 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34094 }
34095 arg4 = static_cast< wxDragResult >(val4);
34096 {
34097 PyThreadState* __tstate = wxPyBeginAllowThreads();
34098 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34099 wxPyEndAllowThreads(__tstate);
34100 if (PyErr_Occurred()) SWIG_fail;
34101 }
34102 resultobj = SWIG_From_int(static_cast< int >(result));
34103 return resultobj;
34104 fail:
34105 return NULL;
34106 }
34107
34108
34109 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34110 PyObject *resultobj = 0;
34111 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34112 void *argp1 = 0 ;
34113 int res1 = 0 ;
34114 PyObject *swig_obj[1] ;
34115
34116 if (!args) SWIG_fail;
34117 swig_obj[0] = args;
34118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34119 if (!SWIG_IsOK(res1)) {
34120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34121 }
34122 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34123 {
34124 PyThreadState* __tstate = wxPyBeginAllowThreads();
34125 (arg1)->OnLeave();
34126 wxPyEndAllowThreads(__tstate);
34127 if (PyErr_Occurred()) SWIG_fail;
34128 }
34129 resultobj = SWIG_Py_Void();
34130 return resultobj;
34131 fail:
34132 return NULL;
34133 }
34134
34135
34136 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34137 PyObject *resultobj = 0;
34138 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34139 int arg2 ;
34140 int arg3 ;
34141 bool result;
34142 void *argp1 = 0 ;
34143 int res1 = 0 ;
34144 int val2 ;
34145 int ecode2 = 0 ;
34146 int val3 ;
34147 int ecode3 = 0 ;
34148 PyObject * obj0 = 0 ;
34149 PyObject * obj1 = 0 ;
34150 PyObject * obj2 = 0 ;
34151 char * kwnames[] = {
34152 (char *) "self",(char *) "x",(char *) "y", NULL
34153 };
34154
34155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34157 if (!SWIG_IsOK(res1)) {
34158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34159 }
34160 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34161 ecode2 = SWIG_AsVal_int(obj1, &val2);
34162 if (!SWIG_IsOK(ecode2)) {
34163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34164 }
34165 arg2 = static_cast< int >(val2);
34166 ecode3 = SWIG_AsVal_int(obj2, &val3);
34167 if (!SWIG_IsOK(ecode3)) {
34168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34169 }
34170 arg3 = static_cast< int >(val3);
34171 {
34172 PyThreadState* __tstate = wxPyBeginAllowThreads();
34173 result = (bool)(arg1)->OnDrop(arg2,arg3);
34174 wxPyEndAllowThreads(__tstate);
34175 if (PyErr_Occurred()) SWIG_fail;
34176 }
34177 {
34178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34179 }
34180 return resultobj;
34181 fail:
34182 return NULL;
34183 }
34184
34185
34186 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34187 PyObject *resultobj = 0;
34188 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34189 bool result;
34190 void *argp1 = 0 ;
34191 int res1 = 0 ;
34192 PyObject *swig_obj[1] ;
34193
34194 if (!args) SWIG_fail;
34195 swig_obj[0] = args;
34196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34197 if (!SWIG_IsOK(res1)) {
34198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34199 }
34200 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34201 {
34202 PyThreadState* __tstate = wxPyBeginAllowThreads();
34203 result = (bool)(arg1)->GetData();
34204 wxPyEndAllowThreads(__tstate);
34205 if (PyErr_Occurred()) SWIG_fail;
34206 }
34207 {
34208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34209 }
34210 return resultobj;
34211 fail:
34212 return NULL;
34213 }
34214
34215
34216 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34217 PyObject *resultobj = 0;
34218 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34219 wxDragResult arg2 ;
34220 void *argp1 = 0 ;
34221 int res1 = 0 ;
34222 int val2 ;
34223 int ecode2 = 0 ;
34224 PyObject * obj0 = 0 ;
34225 PyObject * obj1 = 0 ;
34226 char * kwnames[] = {
34227 (char *) "self",(char *) "action", NULL
34228 };
34229
34230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34232 if (!SWIG_IsOK(res1)) {
34233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34234 }
34235 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34236 ecode2 = SWIG_AsVal_int(obj1, &val2);
34237 if (!SWIG_IsOK(ecode2)) {
34238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34239 }
34240 arg2 = static_cast< wxDragResult >(val2);
34241 {
34242 PyThreadState* __tstate = wxPyBeginAllowThreads();
34243 (arg1)->SetDefaultAction(arg2);
34244 wxPyEndAllowThreads(__tstate);
34245 if (PyErr_Occurred()) SWIG_fail;
34246 }
34247 resultobj = SWIG_Py_Void();
34248 return resultobj;
34249 fail:
34250 return NULL;
34251 }
34252
34253
34254 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34255 PyObject *resultobj = 0;
34256 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34257 wxDragResult result;
34258 void *argp1 = 0 ;
34259 int res1 = 0 ;
34260 PyObject *swig_obj[1] ;
34261
34262 if (!args) SWIG_fail;
34263 swig_obj[0] = args;
34264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34265 if (!SWIG_IsOK(res1)) {
34266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34267 }
34268 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34269 {
34270 PyThreadState* __tstate = wxPyBeginAllowThreads();
34271 result = (wxDragResult)(arg1)->GetDefaultAction();
34272 wxPyEndAllowThreads(__tstate);
34273 if (PyErr_Occurred()) SWIG_fail;
34274 }
34275 resultobj = SWIG_From_int(static_cast< int >(result));
34276 return resultobj;
34277 fail:
34278 return NULL;
34279 }
34280
34281
34282 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34283 PyObject *obj;
34284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34285 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34286 return SWIG_Py_Void();
34287 }
34288
34289 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34290 return SWIG_Python_InitShadowInstance(args);
34291 }
34292
34293 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34294 PyObject *resultobj = 0;
34295 wxPyTextDropTarget *result = 0 ;
34296
34297 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34298 {
34299 PyThreadState* __tstate = wxPyBeginAllowThreads();
34300 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34301 wxPyEndAllowThreads(__tstate);
34302 if (PyErr_Occurred()) SWIG_fail;
34303 }
34304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34305 return resultobj;
34306 fail:
34307 return NULL;
34308 }
34309
34310
34311 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34312 PyObject *resultobj = 0;
34313 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34314 PyObject *arg2 = (PyObject *) 0 ;
34315 PyObject *arg3 = (PyObject *) 0 ;
34316 void *argp1 = 0 ;
34317 int res1 = 0 ;
34318 PyObject * obj0 = 0 ;
34319 PyObject * obj1 = 0 ;
34320 PyObject * obj2 = 0 ;
34321 char * kwnames[] = {
34322 (char *) "self",(char *) "self",(char *) "_class", NULL
34323 };
34324
34325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34327 if (!SWIG_IsOK(res1)) {
34328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34329 }
34330 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34331 arg2 = obj1;
34332 arg3 = obj2;
34333 {
34334 PyThreadState* __tstate = wxPyBeginAllowThreads();
34335 (arg1)->_setCallbackInfo(arg2,arg3);
34336 wxPyEndAllowThreads(__tstate);
34337 if (PyErr_Occurred()) SWIG_fail;
34338 }
34339 resultobj = SWIG_Py_Void();
34340 return resultobj;
34341 fail:
34342 return NULL;
34343 }
34344
34345
34346 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34347 PyObject *resultobj = 0;
34348 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34349 int arg2 ;
34350 int arg3 ;
34351 wxString *arg4 = 0 ;
34352 bool result;
34353 void *argp1 = 0 ;
34354 int res1 = 0 ;
34355 int val2 ;
34356 int ecode2 = 0 ;
34357 int val3 ;
34358 int ecode3 = 0 ;
34359 bool temp4 = false ;
34360 PyObject * obj0 = 0 ;
34361 PyObject * obj1 = 0 ;
34362 PyObject * obj2 = 0 ;
34363 PyObject * obj3 = 0 ;
34364 char * kwnames[] = {
34365 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34366 };
34367
34368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34370 if (!SWIG_IsOK(res1)) {
34371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34372 }
34373 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34374 ecode2 = SWIG_AsVal_int(obj1, &val2);
34375 if (!SWIG_IsOK(ecode2)) {
34376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34377 }
34378 arg2 = static_cast< int >(val2);
34379 ecode3 = SWIG_AsVal_int(obj2, &val3);
34380 if (!SWIG_IsOK(ecode3)) {
34381 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34382 }
34383 arg3 = static_cast< int >(val3);
34384 {
34385 arg4 = wxString_in_helper(obj3);
34386 if (arg4 == NULL) SWIG_fail;
34387 temp4 = true;
34388 }
34389 {
34390 PyThreadState* __tstate = wxPyBeginAllowThreads();
34391 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34392 wxPyEndAllowThreads(__tstate);
34393 if (PyErr_Occurred()) SWIG_fail;
34394 }
34395 {
34396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34397 }
34398 {
34399 if (temp4)
34400 delete arg4;
34401 }
34402 return resultobj;
34403 fail:
34404 {
34405 if (temp4)
34406 delete arg4;
34407 }
34408 return NULL;
34409 }
34410
34411
34412 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34413 PyObject *resultobj = 0;
34414 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34415 int arg2 ;
34416 int arg3 ;
34417 wxDragResult arg4 ;
34418 wxDragResult result;
34419 void *argp1 = 0 ;
34420 int res1 = 0 ;
34421 int val2 ;
34422 int ecode2 = 0 ;
34423 int val3 ;
34424 int ecode3 = 0 ;
34425 int val4 ;
34426 int ecode4 = 0 ;
34427 PyObject * obj0 = 0 ;
34428 PyObject * obj1 = 0 ;
34429 PyObject * obj2 = 0 ;
34430 PyObject * obj3 = 0 ;
34431 char * kwnames[] = {
34432 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34433 };
34434
34435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34437 if (!SWIG_IsOK(res1)) {
34438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34439 }
34440 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34441 ecode2 = SWIG_AsVal_int(obj1, &val2);
34442 if (!SWIG_IsOK(ecode2)) {
34443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34444 }
34445 arg2 = static_cast< int >(val2);
34446 ecode3 = SWIG_AsVal_int(obj2, &val3);
34447 if (!SWIG_IsOK(ecode3)) {
34448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34449 }
34450 arg3 = static_cast< int >(val3);
34451 ecode4 = SWIG_AsVal_int(obj3, &val4);
34452 if (!SWIG_IsOK(ecode4)) {
34453 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34454 }
34455 arg4 = static_cast< wxDragResult >(val4);
34456 {
34457 PyThreadState* __tstate = wxPyBeginAllowThreads();
34458 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34459 wxPyEndAllowThreads(__tstate);
34460 if (PyErr_Occurred()) SWIG_fail;
34461 }
34462 resultobj = SWIG_From_int(static_cast< int >(result));
34463 return resultobj;
34464 fail:
34465 return NULL;
34466 }
34467
34468
34469 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34470 PyObject *resultobj = 0;
34471 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34472 int arg2 ;
34473 int arg3 ;
34474 wxDragResult arg4 ;
34475 wxDragResult result;
34476 void *argp1 = 0 ;
34477 int res1 = 0 ;
34478 int val2 ;
34479 int ecode2 = 0 ;
34480 int val3 ;
34481 int ecode3 = 0 ;
34482 int val4 ;
34483 int ecode4 = 0 ;
34484 PyObject * obj0 = 0 ;
34485 PyObject * obj1 = 0 ;
34486 PyObject * obj2 = 0 ;
34487 PyObject * obj3 = 0 ;
34488 char * kwnames[] = {
34489 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34490 };
34491
34492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34494 if (!SWIG_IsOK(res1)) {
34495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34496 }
34497 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34498 ecode2 = SWIG_AsVal_int(obj1, &val2);
34499 if (!SWIG_IsOK(ecode2)) {
34500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34501 }
34502 arg2 = static_cast< int >(val2);
34503 ecode3 = SWIG_AsVal_int(obj2, &val3);
34504 if (!SWIG_IsOK(ecode3)) {
34505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34506 }
34507 arg3 = static_cast< int >(val3);
34508 ecode4 = SWIG_AsVal_int(obj3, &val4);
34509 if (!SWIG_IsOK(ecode4)) {
34510 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34511 }
34512 arg4 = static_cast< wxDragResult >(val4);
34513 {
34514 PyThreadState* __tstate = wxPyBeginAllowThreads();
34515 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34516 wxPyEndAllowThreads(__tstate);
34517 if (PyErr_Occurred()) SWIG_fail;
34518 }
34519 resultobj = SWIG_From_int(static_cast< int >(result));
34520 return resultobj;
34521 fail:
34522 return NULL;
34523 }
34524
34525
34526 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34527 PyObject *resultobj = 0;
34528 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34529 void *argp1 = 0 ;
34530 int res1 = 0 ;
34531 PyObject *swig_obj[1] ;
34532
34533 if (!args) SWIG_fail;
34534 swig_obj[0] = args;
34535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34536 if (!SWIG_IsOK(res1)) {
34537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34538 }
34539 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34540 {
34541 PyThreadState* __tstate = wxPyBeginAllowThreads();
34542 (arg1)->OnLeave();
34543 wxPyEndAllowThreads(__tstate);
34544 if (PyErr_Occurred()) SWIG_fail;
34545 }
34546 resultobj = SWIG_Py_Void();
34547 return resultobj;
34548 fail:
34549 return NULL;
34550 }
34551
34552
34553 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34554 PyObject *resultobj = 0;
34555 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34556 int arg2 ;
34557 int arg3 ;
34558 bool result;
34559 void *argp1 = 0 ;
34560 int res1 = 0 ;
34561 int val2 ;
34562 int ecode2 = 0 ;
34563 int val3 ;
34564 int ecode3 = 0 ;
34565 PyObject * obj0 = 0 ;
34566 PyObject * obj1 = 0 ;
34567 PyObject * obj2 = 0 ;
34568 char * kwnames[] = {
34569 (char *) "self",(char *) "x",(char *) "y", NULL
34570 };
34571
34572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34574 if (!SWIG_IsOK(res1)) {
34575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34576 }
34577 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34578 ecode2 = SWIG_AsVal_int(obj1, &val2);
34579 if (!SWIG_IsOK(ecode2)) {
34580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34581 }
34582 arg2 = static_cast< int >(val2);
34583 ecode3 = SWIG_AsVal_int(obj2, &val3);
34584 if (!SWIG_IsOK(ecode3)) {
34585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34586 }
34587 arg3 = static_cast< int >(val3);
34588 {
34589 PyThreadState* __tstate = wxPyBeginAllowThreads();
34590 result = (bool)(arg1)->OnDrop(arg2,arg3);
34591 wxPyEndAllowThreads(__tstate);
34592 if (PyErr_Occurred()) SWIG_fail;
34593 }
34594 {
34595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34596 }
34597 return resultobj;
34598 fail:
34599 return NULL;
34600 }
34601
34602
34603 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34604 PyObject *resultobj = 0;
34605 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34606 int arg2 ;
34607 int arg3 ;
34608 wxDragResult arg4 ;
34609 wxDragResult result;
34610 void *argp1 = 0 ;
34611 int res1 = 0 ;
34612 int val2 ;
34613 int ecode2 = 0 ;
34614 int val3 ;
34615 int ecode3 = 0 ;
34616 int val4 ;
34617 int ecode4 = 0 ;
34618 PyObject * obj0 = 0 ;
34619 PyObject * obj1 = 0 ;
34620 PyObject * obj2 = 0 ;
34621 PyObject * obj3 = 0 ;
34622 char * kwnames[] = {
34623 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34624 };
34625
34626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34628 if (!SWIG_IsOK(res1)) {
34629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34630 }
34631 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34632 ecode2 = SWIG_AsVal_int(obj1, &val2);
34633 if (!SWIG_IsOK(ecode2)) {
34634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34635 }
34636 arg2 = static_cast< int >(val2);
34637 ecode3 = SWIG_AsVal_int(obj2, &val3);
34638 if (!SWIG_IsOK(ecode3)) {
34639 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34640 }
34641 arg3 = static_cast< int >(val3);
34642 ecode4 = SWIG_AsVal_int(obj3, &val4);
34643 if (!SWIG_IsOK(ecode4)) {
34644 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34645 }
34646 arg4 = static_cast< wxDragResult >(val4);
34647 {
34648 PyThreadState* __tstate = wxPyBeginAllowThreads();
34649 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34650 wxPyEndAllowThreads(__tstate);
34651 if (PyErr_Occurred()) SWIG_fail;
34652 }
34653 resultobj = SWIG_From_int(static_cast< int >(result));
34654 return resultobj;
34655 fail:
34656 return NULL;
34657 }
34658
34659
34660 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34661 PyObject *obj;
34662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34663 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34664 return SWIG_Py_Void();
34665 }
34666
34667 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34668 return SWIG_Python_InitShadowInstance(args);
34669 }
34670
34671 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34672 PyObject *resultobj = 0;
34673 wxPyFileDropTarget *result = 0 ;
34674
34675 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34676 {
34677 PyThreadState* __tstate = wxPyBeginAllowThreads();
34678 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34679 wxPyEndAllowThreads(__tstate);
34680 if (PyErr_Occurred()) SWIG_fail;
34681 }
34682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34683 return resultobj;
34684 fail:
34685 return NULL;
34686 }
34687
34688
34689 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34690 PyObject *resultobj = 0;
34691 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34692 PyObject *arg2 = (PyObject *) 0 ;
34693 PyObject *arg3 = (PyObject *) 0 ;
34694 void *argp1 = 0 ;
34695 int res1 = 0 ;
34696 PyObject * obj0 = 0 ;
34697 PyObject * obj1 = 0 ;
34698 PyObject * obj2 = 0 ;
34699 char * kwnames[] = {
34700 (char *) "self",(char *) "self",(char *) "_class", NULL
34701 };
34702
34703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34705 if (!SWIG_IsOK(res1)) {
34706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34707 }
34708 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34709 arg2 = obj1;
34710 arg3 = obj2;
34711 {
34712 PyThreadState* __tstate = wxPyBeginAllowThreads();
34713 (arg1)->_setCallbackInfo(arg2,arg3);
34714 wxPyEndAllowThreads(__tstate);
34715 if (PyErr_Occurred()) SWIG_fail;
34716 }
34717 resultobj = SWIG_Py_Void();
34718 return resultobj;
34719 fail:
34720 return NULL;
34721 }
34722
34723
34724 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34725 PyObject *resultobj = 0;
34726 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34727 int arg2 ;
34728 int arg3 ;
34729 wxArrayString *arg4 = 0 ;
34730 bool result;
34731 void *argp1 = 0 ;
34732 int res1 = 0 ;
34733 int val2 ;
34734 int ecode2 = 0 ;
34735 int val3 ;
34736 int ecode3 = 0 ;
34737 bool temp4 = false ;
34738 PyObject * obj0 = 0 ;
34739 PyObject * obj1 = 0 ;
34740 PyObject * obj2 = 0 ;
34741 PyObject * obj3 = 0 ;
34742 char * kwnames[] = {
34743 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
34744 };
34745
34746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34748 if (!SWIG_IsOK(res1)) {
34749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34750 }
34751 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34752 ecode2 = SWIG_AsVal_int(obj1, &val2);
34753 if (!SWIG_IsOK(ecode2)) {
34754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
34755 }
34756 arg2 = static_cast< int >(val2);
34757 ecode3 = SWIG_AsVal_int(obj2, &val3);
34758 if (!SWIG_IsOK(ecode3)) {
34759 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
34760 }
34761 arg3 = static_cast< int >(val3);
34762 {
34763 if (! PySequence_Check(obj3)) {
34764 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
34765 SWIG_fail;
34766 }
34767 arg4 = new wxArrayString;
34768 temp4 = true;
34769 int i, len=PySequence_Length(obj3);
34770 for (i=0; i<len; i++) {
34771 PyObject* item = PySequence_GetItem(obj3, i);
34772 wxString* s = wxString_in_helper(item);
34773 if (PyErr_Occurred()) SWIG_fail;
34774 arg4->Add(*s);
34775 delete s;
34776 Py_DECREF(item);
34777 }
34778 }
34779 {
34780 PyThreadState* __tstate = wxPyBeginAllowThreads();
34781 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
34782 wxPyEndAllowThreads(__tstate);
34783 if (PyErr_Occurred()) SWIG_fail;
34784 }
34785 {
34786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34787 }
34788 {
34789 if (temp4) delete arg4;
34790 }
34791 return resultobj;
34792 fail:
34793 {
34794 if (temp4) delete arg4;
34795 }
34796 return NULL;
34797 }
34798
34799
34800 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34801 PyObject *resultobj = 0;
34802 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34803 int arg2 ;
34804 int arg3 ;
34805 wxDragResult arg4 ;
34806 wxDragResult result;
34807 void *argp1 = 0 ;
34808 int res1 = 0 ;
34809 int val2 ;
34810 int ecode2 = 0 ;
34811 int val3 ;
34812 int ecode3 = 0 ;
34813 int val4 ;
34814 int ecode4 = 0 ;
34815 PyObject * obj0 = 0 ;
34816 PyObject * obj1 = 0 ;
34817 PyObject * obj2 = 0 ;
34818 PyObject * obj3 = 0 ;
34819 char * kwnames[] = {
34820 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34821 };
34822
34823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34825 if (!SWIG_IsOK(res1)) {
34826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34827 }
34828 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34829 ecode2 = SWIG_AsVal_int(obj1, &val2);
34830 if (!SWIG_IsOK(ecode2)) {
34831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34832 }
34833 arg2 = static_cast< int >(val2);
34834 ecode3 = SWIG_AsVal_int(obj2, &val3);
34835 if (!SWIG_IsOK(ecode3)) {
34836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34837 }
34838 arg3 = static_cast< int >(val3);
34839 ecode4 = SWIG_AsVal_int(obj3, &val4);
34840 if (!SWIG_IsOK(ecode4)) {
34841 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34842 }
34843 arg4 = static_cast< wxDragResult >(val4);
34844 {
34845 PyThreadState* __tstate = wxPyBeginAllowThreads();
34846 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34847 wxPyEndAllowThreads(__tstate);
34848 if (PyErr_Occurred()) SWIG_fail;
34849 }
34850 resultobj = SWIG_From_int(static_cast< int >(result));
34851 return resultobj;
34852 fail:
34853 return NULL;
34854 }
34855
34856
34857 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34858 PyObject *resultobj = 0;
34859 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34860 int arg2 ;
34861 int arg3 ;
34862 wxDragResult arg4 ;
34863 wxDragResult result;
34864 void *argp1 = 0 ;
34865 int res1 = 0 ;
34866 int val2 ;
34867 int ecode2 = 0 ;
34868 int val3 ;
34869 int ecode3 = 0 ;
34870 int val4 ;
34871 int ecode4 = 0 ;
34872 PyObject * obj0 = 0 ;
34873 PyObject * obj1 = 0 ;
34874 PyObject * obj2 = 0 ;
34875 PyObject * obj3 = 0 ;
34876 char * kwnames[] = {
34877 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34878 };
34879
34880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34882 if (!SWIG_IsOK(res1)) {
34883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34884 }
34885 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34886 ecode2 = SWIG_AsVal_int(obj1, &val2);
34887 if (!SWIG_IsOK(ecode2)) {
34888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34889 }
34890 arg2 = static_cast< int >(val2);
34891 ecode3 = SWIG_AsVal_int(obj2, &val3);
34892 if (!SWIG_IsOK(ecode3)) {
34893 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34894 }
34895 arg3 = static_cast< int >(val3);
34896 ecode4 = SWIG_AsVal_int(obj3, &val4);
34897 if (!SWIG_IsOK(ecode4)) {
34898 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34899 }
34900 arg4 = static_cast< wxDragResult >(val4);
34901 {
34902 PyThreadState* __tstate = wxPyBeginAllowThreads();
34903 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34904 wxPyEndAllowThreads(__tstate);
34905 if (PyErr_Occurred()) SWIG_fail;
34906 }
34907 resultobj = SWIG_From_int(static_cast< int >(result));
34908 return resultobj;
34909 fail:
34910 return NULL;
34911 }
34912
34913
34914 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34915 PyObject *resultobj = 0;
34916 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34917 void *argp1 = 0 ;
34918 int res1 = 0 ;
34919 PyObject *swig_obj[1] ;
34920
34921 if (!args) SWIG_fail;
34922 swig_obj[0] = args;
34923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34924 if (!SWIG_IsOK(res1)) {
34925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34926 }
34927 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34928 {
34929 PyThreadState* __tstate = wxPyBeginAllowThreads();
34930 (arg1)->OnLeave();
34931 wxPyEndAllowThreads(__tstate);
34932 if (PyErr_Occurred()) SWIG_fail;
34933 }
34934 resultobj = SWIG_Py_Void();
34935 return resultobj;
34936 fail:
34937 return NULL;
34938 }
34939
34940
34941 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34942 PyObject *resultobj = 0;
34943 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34944 int arg2 ;
34945 int arg3 ;
34946 bool result;
34947 void *argp1 = 0 ;
34948 int res1 = 0 ;
34949 int val2 ;
34950 int ecode2 = 0 ;
34951 int val3 ;
34952 int ecode3 = 0 ;
34953 PyObject * obj0 = 0 ;
34954 PyObject * obj1 = 0 ;
34955 PyObject * obj2 = 0 ;
34956 char * kwnames[] = {
34957 (char *) "self",(char *) "x",(char *) "y", NULL
34958 };
34959
34960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34962 if (!SWIG_IsOK(res1)) {
34963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34964 }
34965 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34966 ecode2 = SWIG_AsVal_int(obj1, &val2);
34967 if (!SWIG_IsOK(ecode2)) {
34968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34969 }
34970 arg2 = static_cast< int >(val2);
34971 ecode3 = SWIG_AsVal_int(obj2, &val3);
34972 if (!SWIG_IsOK(ecode3)) {
34973 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34974 }
34975 arg3 = static_cast< int >(val3);
34976 {
34977 PyThreadState* __tstate = wxPyBeginAllowThreads();
34978 result = (bool)(arg1)->OnDrop(arg2,arg3);
34979 wxPyEndAllowThreads(__tstate);
34980 if (PyErr_Occurred()) SWIG_fail;
34981 }
34982 {
34983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34984 }
34985 return resultobj;
34986 fail:
34987 return NULL;
34988 }
34989
34990
34991 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34992 PyObject *resultobj = 0;
34993 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34994 int arg2 ;
34995 int arg3 ;
34996 wxDragResult arg4 ;
34997 wxDragResult result;
34998 void *argp1 = 0 ;
34999 int res1 = 0 ;
35000 int val2 ;
35001 int ecode2 = 0 ;
35002 int val3 ;
35003 int ecode3 = 0 ;
35004 int val4 ;
35005 int ecode4 = 0 ;
35006 PyObject * obj0 = 0 ;
35007 PyObject * obj1 = 0 ;
35008 PyObject * obj2 = 0 ;
35009 PyObject * obj3 = 0 ;
35010 char * kwnames[] = {
35011 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35012 };
35013
35014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35016 if (!SWIG_IsOK(res1)) {
35017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35018 }
35019 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35020 ecode2 = SWIG_AsVal_int(obj1, &val2);
35021 if (!SWIG_IsOK(ecode2)) {
35022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35023 }
35024 arg2 = static_cast< int >(val2);
35025 ecode3 = SWIG_AsVal_int(obj2, &val3);
35026 if (!SWIG_IsOK(ecode3)) {
35027 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35028 }
35029 arg3 = static_cast< int >(val3);
35030 ecode4 = SWIG_AsVal_int(obj3, &val4);
35031 if (!SWIG_IsOK(ecode4)) {
35032 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35033 }
35034 arg4 = static_cast< wxDragResult >(val4);
35035 {
35036 PyThreadState* __tstate = wxPyBeginAllowThreads();
35037 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35038 wxPyEndAllowThreads(__tstate);
35039 if (PyErr_Occurred()) SWIG_fail;
35040 }
35041 resultobj = SWIG_From_int(static_cast< int >(result));
35042 return resultobj;
35043 fail:
35044 return NULL;
35045 }
35046
35047
35048 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35049 PyObject *obj;
35050 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35051 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35052 return SWIG_Py_Void();
35053 }
35054
35055 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35056 return SWIG_Python_InitShadowInstance(args);
35057 }
35058
35059 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35060 PyObject *resultobj = 0;
35061 wxClipboard *result = 0 ;
35062
35063 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35064 {
35065 PyThreadState* __tstate = wxPyBeginAllowThreads();
35066 result = (wxClipboard *)new wxClipboard();
35067 wxPyEndAllowThreads(__tstate);
35068 if (PyErr_Occurred()) SWIG_fail;
35069 }
35070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35071 return resultobj;
35072 fail:
35073 return NULL;
35074 }
35075
35076
35077 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35078 PyObject *resultobj = 0;
35079 wxClipboard *arg1 = (wxClipboard *) 0 ;
35080 void *argp1 = 0 ;
35081 int res1 = 0 ;
35082 PyObject *swig_obj[1] ;
35083
35084 if (!args) SWIG_fail;
35085 swig_obj[0] = args;
35086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35087 if (!SWIG_IsOK(res1)) {
35088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35089 }
35090 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35091 {
35092 PyThreadState* __tstate = wxPyBeginAllowThreads();
35093 delete arg1;
35094
35095 wxPyEndAllowThreads(__tstate);
35096 if (PyErr_Occurred()) SWIG_fail;
35097 }
35098 resultobj = SWIG_Py_Void();
35099 return resultobj;
35100 fail:
35101 return NULL;
35102 }
35103
35104
35105 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35106 PyObject *resultobj = 0;
35107 wxClipboard *arg1 = (wxClipboard *) 0 ;
35108 bool result;
35109 void *argp1 = 0 ;
35110 int res1 = 0 ;
35111 PyObject *swig_obj[1] ;
35112
35113 if (!args) SWIG_fail;
35114 swig_obj[0] = args;
35115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35116 if (!SWIG_IsOK(res1)) {
35117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35118 }
35119 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35120 {
35121 PyThreadState* __tstate = wxPyBeginAllowThreads();
35122 result = (bool)(arg1)->Open();
35123 wxPyEndAllowThreads(__tstate);
35124 if (PyErr_Occurred()) SWIG_fail;
35125 }
35126 {
35127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35128 }
35129 return resultobj;
35130 fail:
35131 return NULL;
35132 }
35133
35134
35135 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35136 PyObject *resultobj = 0;
35137 wxClipboard *arg1 = (wxClipboard *) 0 ;
35138 void *argp1 = 0 ;
35139 int res1 = 0 ;
35140 PyObject *swig_obj[1] ;
35141
35142 if (!args) SWIG_fail;
35143 swig_obj[0] = args;
35144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35145 if (!SWIG_IsOK(res1)) {
35146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35147 }
35148 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35149 {
35150 PyThreadState* __tstate = wxPyBeginAllowThreads();
35151 (arg1)->Close();
35152 wxPyEndAllowThreads(__tstate);
35153 if (PyErr_Occurred()) SWIG_fail;
35154 }
35155 resultobj = SWIG_Py_Void();
35156 return resultobj;
35157 fail:
35158 return NULL;
35159 }
35160
35161
35162 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35163 PyObject *resultobj = 0;
35164 wxClipboard *arg1 = (wxClipboard *) 0 ;
35165 bool result;
35166 void *argp1 = 0 ;
35167 int res1 = 0 ;
35168 PyObject *swig_obj[1] ;
35169
35170 if (!args) SWIG_fail;
35171 swig_obj[0] = args;
35172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35173 if (!SWIG_IsOK(res1)) {
35174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35175 }
35176 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35177 {
35178 PyThreadState* __tstate = wxPyBeginAllowThreads();
35179 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35180 wxPyEndAllowThreads(__tstate);
35181 if (PyErr_Occurred()) SWIG_fail;
35182 }
35183 {
35184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35185 }
35186 return resultobj;
35187 fail:
35188 return NULL;
35189 }
35190
35191
35192 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35193 PyObject *resultobj = 0;
35194 wxClipboard *arg1 = (wxClipboard *) 0 ;
35195 wxDataObject *arg2 = (wxDataObject *) 0 ;
35196 bool result;
35197 void *argp1 = 0 ;
35198 int res1 = 0 ;
35199 int res2 = 0 ;
35200 PyObject * obj0 = 0 ;
35201 PyObject * obj1 = 0 ;
35202 char * kwnames[] = {
35203 (char *) "self",(char *) "data", NULL
35204 };
35205
35206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35208 if (!SWIG_IsOK(res1)) {
35209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35210 }
35211 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35212 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35213 if (!SWIG_IsOK(res2)) {
35214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35215 }
35216 {
35217 PyThreadState* __tstate = wxPyBeginAllowThreads();
35218 result = (bool)(arg1)->AddData(arg2);
35219 wxPyEndAllowThreads(__tstate);
35220 if (PyErr_Occurred()) SWIG_fail;
35221 }
35222 {
35223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35224 }
35225 return resultobj;
35226 fail:
35227 return NULL;
35228 }
35229
35230
35231 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35232 PyObject *resultobj = 0;
35233 wxClipboard *arg1 = (wxClipboard *) 0 ;
35234 wxDataObject *arg2 = (wxDataObject *) 0 ;
35235 bool result;
35236 void *argp1 = 0 ;
35237 int res1 = 0 ;
35238 int res2 = 0 ;
35239 PyObject * obj0 = 0 ;
35240 PyObject * obj1 = 0 ;
35241 char * kwnames[] = {
35242 (char *) "self",(char *) "data", NULL
35243 };
35244
35245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35247 if (!SWIG_IsOK(res1)) {
35248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35249 }
35250 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35251 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35252 if (!SWIG_IsOK(res2)) {
35253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35254 }
35255 {
35256 PyThreadState* __tstate = wxPyBeginAllowThreads();
35257 result = (bool)(arg1)->SetData(arg2);
35258 wxPyEndAllowThreads(__tstate);
35259 if (PyErr_Occurred()) SWIG_fail;
35260 }
35261 {
35262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35263 }
35264 return resultobj;
35265 fail:
35266 return NULL;
35267 }
35268
35269
35270 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35271 PyObject *resultobj = 0;
35272 wxClipboard *arg1 = (wxClipboard *) 0 ;
35273 wxDataFormat *arg2 = 0 ;
35274 bool result;
35275 void *argp1 = 0 ;
35276 int res1 = 0 ;
35277 void *argp2 = 0 ;
35278 int res2 = 0 ;
35279 PyObject * obj0 = 0 ;
35280 PyObject * obj1 = 0 ;
35281 char * kwnames[] = {
35282 (char *) "self",(char *) "format", NULL
35283 };
35284
35285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35287 if (!SWIG_IsOK(res1)) {
35288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35289 }
35290 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35291 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35292 if (!SWIG_IsOK(res2)) {
35293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35294 }
35295 if (!argp2) {
35296 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35297 }
35298 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35299 {
35300 PyThreadState* __tstate = wxPyBeginAllowThreads();
35301 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35302 wxPyEndAllowThreads(__tstate);
35303 if (PyErr_Occurred()) SWIG_fail;
35304 }
35305 {
35306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35307 }
35308 return resultobj;
35309 fail:
35310 return NULL;
35311 }
35312
35313
35314 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35315 PyObject *resultobj = 0;
35316 wxClipboard *arg1 = (wxClipboard *) 0 ;
35317 wxDataObject *arg2 = 0 ;
35318 bool result;
35319 void *argp1 = 0 ;
35320 int res1 = 0 ;
35321 void *argp2 = 0 ;
35322 int res2 = 0 ;
35323 PyObject * obj0 = 0 ;
35324 PyObject * obj1 = 0 ;
35325 char * kwnames[] = {
35326 (char *) "self",(char *) "data", NULL
35327 };
35328
35329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35331 if (!SWIG_IsOK(res1)) {
35332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35333 }
35334 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35335 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35336 if (!SWIG_IsOK(res2)) {
35337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35338 }
35339 if (!argp2) {
35340 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35341 }
35342 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35343 {
35344 PyThreadState* __tstate = wxPyBeginAllowThreads();
35345 result = (bool)(arg1)->GetData(*arg2);
35346 wxPyEndAllowThreads(__tstate);
35347 if (PyErr_Occurred()) SWIG_fail;
35348 }
35349 {
35350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35351 }
35352 return resultobj;
35353 fail:
35354 return NULL;
35355 }
35356
35357
35358 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35359 PyObject *resultobj = 0;
35360 wxClipboard *arg1 = (wxClipboard *) 0 ;
35361 void *argp1 = 0 ;
35362 int res1 = 0 ;
35363 PyObject *swig_obj[1] ;
35364
35365 if (!args) SWIG_fail;
35366 swig_obj[0] = args;
35367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35368 if (!SWIG_IsOK(res1)) {
35369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35370 }
35371 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35372 {
35373 PyThreadState* __tstate = wxPyBeginAllowThreads();
35374 (arg1)->Clear();
35375 wxPyEndAllowThreads(__tstate);
35376 if (PyErr_Occurred()) SWIG_fail;
35377 }
35378 resultobj = SWIG_Py_Void();
35379 return resultobj;
35380 fail:
35381 return NULL;
35382 }
35383
35384
35385 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35386 PyObject *resultobj = 0;
35387 wxClipboard *arg1 = (wxClipboard *) 0 ;
35388 bool result;
35389 void *argp1 = 0 ;
35390 int res1 = 0 ;
35391 PyObject *swig_obj[1] ;
35392
35393 if (!args) SWIG_fail;
35394 swig_obj[0] = args;
35395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35396 if (!SWIG_IsOK(res1)) {
35397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35398 }
35399 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35400 {
35401 PyThreadState* __tstate = wxPyBeginAllowThreads();
35402 result = (bool)(arg1)->Flush();
35403 wxPyEndAllowThreads(__tstate);
35404 if (PyErr_Occurred()) SWIG_fail;
35405 }
35406 {
35407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35408 }
35409 return resultobj;
35410 fail:
35411 return NULL;
35412 }
35413
35414
35415 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35416 PyObject *resultobj = 0;
35417 wxClipboard *arg1 = (wxClipboard *) 0 ;
35418 bool arg2 = (bool) true ;
35419 void *argp1 = 0 ;
35420 int res1 = 0 ;
35421 bool val2 ;
35422 int ecode2 = 0 ;
35423 PyObject * obj0 = 0 ;
35424 PyObject * obj1 = 0 ;
35425 char * kwnames[] = {
35426 (char *) "self",(char *) "primary", NULL
35427 };
35428
35429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35431 if (!SWIG_IsOK(res1)) {
35432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35433 }
35434 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35435 if (obj1) {
35436 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35437 if (!SWIG_IsOK(ecode2)) {
35438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35439 }
35440 arg2 = static_cast< bool >(val2);
35441 }
35442 {
35443 PyThreadState* __tstate = wxPyBeginAllowThreads();
35444 (arg1)->UsePrimarySelection(arg2);
35445 wxPyEndAllowThreads(__tstate);
35446 if (PyErr_Occurred()) SWIG_fail;
35447 }
35448 resultobj = SWIG_Py_Void();
35449 return resultobj;
35450 fail:
35451 return NULL;
35452 }
35453
35454
35455 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35456 PyObject *resultobj = 0;
35457 wxClipboard *result = 0 ;
35458
35459 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35460 {
35461 PyThreadState* __tstate = wxPyBeginAllowThreads();
35462 result = (wxClipboard *)wxClipboard::Get();
35463 wxPyEndAllowThreads(__tstate);
35464 if (PyErr_Occurred()) SWIG_fail;
35465 }
35466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35467 return resultobj;
35468 fail:
35469 return NULL;
35470 }
35471
35472
35473 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35474 PyObject *obj;
35475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35476 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35477 return SWIG_Py_Void();
35478 }
35479
35480 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35481 return SWIG_Python_InitShadowInstance(args);
35482 }
35483
35484 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35485 PyObject *resultobj = 0;
35486 wxClipboard *arg1 = (wxClipboard *) NULL ;
35487 wxClipboardLocker *result = 0 ;
35488 void *argp1 = 0 ;
35489 int res1 = 0 ;
35490 PyObject * obj0 = 0 ;
35491 char * kwnames[] = {
35492 (char *) "clipboard", NULL
35493 };
35494
35495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35496 if (obj0) {
35497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35498 if (!SWIG_IsOK(res1)) {
35499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35500 }
35501 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35502 }
35503 {
35504 PyThreadState* __tstate = wxPyBeginAllowThreads();
35505 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35506 wxPyEndAllowThreads(__tstate);
35507 if (PyErr_Occurred()) SWIG_fail;
35508 }
35509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35510 return resultobj;
35511 fail:
35512 return NULL;
35513 }
35514
35515
35516 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35517 PyObject *resultobj = 0;
35518 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35519 void *argp1 = 0 ;
35520 int res1 = 0 ;
35521 PyObject *swig_obj[1] ;
35522
35523 if (!args) SWIG_fail;
35524 swig_obj[0] = args;
35525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35526 if (!SWIG_IsOK(res1)) {
35527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35528 }
35529 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35530 {
35531 PyThreadState* __tstate = wxPyBeginAllowThreads();
35532 delete arg1;
35533
35534 wxPyEndAllowThreads(__tstate);
35535 if (PyErr_Occurred()) SWIG_fail;
35536 }
35537 resultobj = SWIG_Py_Void();
35538 return resultobj;
35539 fail:
35540 return NULL;
35541 }
35542
35543
35544 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35545 PyObject *resultobj = 0;
35546 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35547 bool result;
35548 void *argp1 = 0 ;
35549 int res1 = 0 ;
35550 PyObject *swig_obj[1] ;
35551
35552 if (!args) SWIG_fail;
35553 swig_obj[0] = args;
35554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35555 if (!SWIG_IsOK(res1)) {
35556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35557 }
35558 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35559 {
35560 PyThreadState* __tstate = wxPyBeginAllowThreads();
35561 result = (bool)wxClipboardLocker___nonzero__(arg1);
35562 wxPyEndAllowThreads(__tstate);
35563 if (PyErr_Occurred()) SWIG_fail;
35564 }
35565 {
35566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35567 }
35568 return resultobj;
35569 fail:
35570 return NULL;
35571 }
35572
35573
35574 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35575 PyObject *obj;
35576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35577 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35578 return SWIG_Py_Void();
35579 }
35580
35581 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35582 return SWIG_Python_InitShadowInstance(args);
35583 }
35584
35585 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35586 PyObject *resultobj = 0;
35587 int arg1 = (int) 0 ;
35588 int arg2 = (int) 0 ;
35589 int arg3 = (int) 0 ;
35590 int arg4 = (int) 0 ;
35591 wxVideoMode *result = 0 ;
35592 int val1 ;
35593 int ecode1 = 0 ;
35594 int val2 ;
35595 int ecode2 = 0 ;
35596 int val3 ;
35597 int ecode3 = 0 ;
35598 int val4 ;
35599 int ecode4 = 0 ;
35600 PyObject * obj0 = 0 ;
35601 PyObject * obj1 = 0 ;
35602 PyObject * obj2 = 0 ;
35603 PyObject * obj3 = 0 ;
35604 char * kwnames[] = {
35605 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35606 };
35607
35608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35609 if (obj0) {
35610 ecode1 = SWIG_AsVal_int(obj0, &val1);
35611 if (!SWIG_IsOK(ecode1)) {
35612 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35613 }
35614 arg1 = static_cast< int >(val1);
35615 }
35616 if (obj1) {
35617 ecode2 = SWIG_AsVal_int(obj1, &val2);
35618 if (!SWIG_IsOK(ecode2)) {
35619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35620 }
35621 arg2 = static_cast< int >(val2);
35622 }
35623 if (obj2) {
35624 ecode3 = SWIG_AsVal_int(obj2, &val3);
35625 if (!SWIG_IsOK(ecode3)) {
35626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35627 }
35628 arg3 = static_cast< int >(val3);
35629 }
35630 if (obj3) {
35631 ecode4 = SWIG_AsVal_int(obj3, &val4);
35632 if (!SWIG_IsOK(ecode4)) {
35633 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35634 }
35635 arg4 = static_cast< int >(val4);
35636 }
35637 {
35638 PyThreadState* __tstate = wxPyBeginAllowThreads();
35639 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35640 wxPyEndAllowThreads(__tstate);
35641 if (PyErr_Occurred()) SWIG_fail;
35642 }
35643 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35644 return resultobj;
35645 fail:
35646 return NULL;
35647 }
35648
35649
35650 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35651 PyObject *resultobj = 0;
35652 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35653 void *argp1 = 0 ;
35654 int res1 = 0 ;
35655 PyObject *swig_obj[1] ;
35656
35657 if (!args) SWIG_fail;
35658 swig_obj[0] = args;
35659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35660 if (!SWIG_IsOK(res1)) {
35661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35662 }
35663 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35664 {
35665 PyThreadState* __tstate = wxPyBeginAllowThreads();
35666 delete arg1;
35667
35668 wxPyEndAllowThreads(__tstate);
35669 if (PyErr_Occurred()) SWIG_fail;
35670 }
35671 resultobj = SWIG_Py_Void();
35672 return resultobj;
35673 fail:
35674 return NULL;
35675 }
35676
35677
35678 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35679 PyObject *resultobj = 0;
35680 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35681 wxVideoMode *arg2 = 0 ;
35682 bool result;
35683 void *argp1 = 0 ;
35684 int res1 = 0 ;
35685 void *argp2 = 0 ;
35686 int res2 = 0 ;
35687 PyObject * obj0 = 0 ;
35688 PyObject * obj1 = 0 ;
35689 char * kwnames[] = {
35690 (char *) "self",(char *) "other", NULL
35691 };
35692
35693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35695 if (!SWIG_IsOK(res1)) {
35696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35697 }
35698 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35699 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35700 if (!SWIG_IsOK(res2)) {
35701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35702 }
35703 if (!argp2) {
35704 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35705 }
35706 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35707 {
35708 PyThreadState* __tstate = wxPyBeginAllowThreads();
35709 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35710 wxPyEndAllowThreads(__tstate);
35711 if (PyErr_Occurred()) SWIG_fail;
35712 }
35713 {
35714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35715 }
35716 return resultobj;
35717 fail:
35718 return NULL;
35719 }
35720
35721
35722 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35723 PyObject *resultobj = 0;
35724 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35725 int result;
35726 void *argp1 = 0 ;
35727 int res1 = 0 ;
35728 PyObject *swig_obj[1] ;
35729
35730 if (!args) SWIG_fail;
35731 swig_obj[0] = args;
35732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35733 if (!SWIG_IsOK(res1)) {
35734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35735 }
35736 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35737 {
35738 PyThreadState* __tstate = wxPyBeginAllowThreads();
35739 result = (int)((wxVideoMode const *)arg1)->GetWidth();
35740 wxPyEndAllowThreads(__tstate);
35741 if (PyErr_Occurred()) SWIG_fail;
35742 }
35743 resultobj = SWIG_From_int(static_cast< int >(result));
35744 return resultobj;
35745 fail:
35746 return NULL;
35747 }
35748
35749
35750 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35751 PyObject *resultobj = 0;
35752 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35753 int result;
35754 void *argp1 = 0 ;
35755 int res1 = 0 ;
35756 PyObject *swig_obj[1] ;
35757
35758 if (!args) SWIG_fail;
35759 swig_obj[0] = args;
35760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35761 if (!SWIG_IsOK(res1)) {
35762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35763 }
35764 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35765 {
35766 PyThreadState* __tstate = wxPyBeginAllowThreads();
35767 result = (int)((wxVideoMode const *)arg1)->GetHeight();
35768 wxPyEndAllowThreads(__tstate);
35769 if (PyErr_Occurred()) SWIG_fail;
35770 }
35771 resultobj = SWIG_From_int(static_cast< int >(result));
35772 return resultobj;
35773 fail:
35774 return NULL;
35775 }
35776
35777
35778 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35779 PyObject *resultobj = 0;
35780 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35781 int result;
35782 void *argp1 = 0 ;
35783 int res1 = 0 ;
35784 PyObject *swig_obj[1] ;
35785
35786 if (!args) SWIG_fail;
35787 swig_obj[0] = args;
35788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35789 if (!SWIG_IsOK(res1)) {
35790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35791 }
35792 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35793 {
35794 PyThreadState* __tstate = wxPyBeginAllowThreads();
35795 result = (int)((wxVideoMode const *)arg1)->GetDepth();
35796 wxPyEndAllowThreads(__tstate);
35797 if (PyErr_Occurred()) SWIG_fail;
35798 }
35799 resultobj = SWIG_From_int(static_cast< int >(result));
35800 return resultobj;
35801 fail:
35802 return NULL;
35803 }
35804
35805
35806 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35807 PyObject *resultobj = 0;
35808 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35809 bool result;
35810 void *argp1 = 0 ;
35811 int res1 = 0 ;
35812 PyObject *swig_obj[1] ;
35813
35814 if (!args) SWIG_fail;
35815 swig_obj[0] = args;
35816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35817 if (!SWIG_IsOK(res1)) {
35818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35819 }
35820 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35821 {
35822 PyThreadState* __tstate = wxPyBeginAllowThreads();
35823 result = (bool)((wxVideoMode const *)arg1)->IsOk();
35824 wxPyEndAllowThreads(__tstate);
35825 if (PyErr_Occurred()) SWIG_fail;
35826 }
35827 {
35828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35829 }
35830 return resultobj;
35831 fail:
35832 return NULL;
35833 }
35834
35835
35836 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35837 PyObject *resultobj = 0;
35838 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35839 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
35840 bool result;
35841 void *argp1 = 0 ;
35842 int res1 = 0 ;
35843 void *argp2 = 0 ;
35844 int res2 = 0 ;
35845 PyObject * obj0 = 0 ;
35846 PyObject * obj1 = 0 ;
35847 char * kwnames[] = {
35848 (char *) "self",(char *) "other", NULL
35849 };
35850
35851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
35852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35853 if (!SWIG_IsOK(res1)) {
35854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35855 }
35856 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35857 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35858 if (!SWIG_IsOK(res2)) {
35859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
35860 }
35861 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35862 {
35863 PyThreadState* __tstate = wxPyBeginAllowThreads();
35864 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
35865 wxPyEndAllowThreads(__tstate);
35866 if (PyErr_Occurred()) SWIG_fail;
35867 }
35868 {
35869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35870 }
35871 return resultobj;
35872 fail:
35873 return NULL;
35874 }
35875
35876
35877 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35878 PyObject *resultobj = 0;
35879 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35880 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
35881 bool result;
35882 void *argp1 = 0 ;
35883 int res1 = 0 ;
35884 void *argp2 = 0 ;
35885 int res2 = 0 ;
35886 PyObject * obj0 = 0 ;
35887 PyObject * obj1 = 0 ;
35888 char * kwnames[] = {
35889 (char *) "self",(char *) "other", NULL
35890 };
35891
35892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
35893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35894 if (!SWIG_IsOK(res1)) {
35895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35896 }
35897 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35898 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35899 if (!SWIG_IsOK(res2)) {
35900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
35901 }
35902 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35903 {
35904 PyThreadState* __tstate = wxPyBeginAllowThreads();
35905 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
35906 wxPyEndAllowThreads(__tstate);
35907 if (PyErr_Occurred()) SWIG_fail;
35908 }
35909 {
35910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35911 }
35912 return resultobj;
35913 fail:
35914 return NULL;
35915 }
35916
35917
35918 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35919 PyObject *resultobj = 0;
35920 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35921 int arg2 ;
35922 void *argp1 = 0 ;
35923 int res1 = 0 ;
35924 int val2 ;
35925 int ecode2 = 0 ;
35926 PyObject *swig_obj[2] ;
35927
35928 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
35929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35930 if (!SWIG_IsOK(res1)) {
35931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35932 }
35933 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35934 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35935 if (!SWIG_IsOK(ecode2)) {
35936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
35937 }
35938 arg2 = static_cast< int >(val2);
35939 if (arg1) (arg1)->w = arg2;
35940
35941 resultobj = SWIG_Py_Void();
35942 return resultobj;
35943 fail:
35944 return NULL;
35945 }
35946
35947
35948 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35949 PyObject *resultobj = 0;
35950 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35951 int result;
35952 void *argp1 = 0 ;
35953 int res1 = 0 ;
35954 PyObject *swig_obj[1] ;
35955
35956 if (!args) SWIG_fail;
35957 swig_obj[0] = args;
35958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35959 if (!SWIG_IsOK(res1)) {
35960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35961 }
35962 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35963 result = (int) ((arg1)->w);
35964 resultobj = SWIG_From_int(static_cast< int >(result));
35965 return resultobj;
35966 fail:
35967 return NULL;
35968 }
35969
35970
35971 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35972 PyObject *resultobj = 0;
35973 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35974 int arg2 ;
35975 void *argp1 = 0 ;
35976 int res1 = 0 ;
35977 int val2 ;
35978 int ecode2 = 0 ;
35979 PyObject *swig_obj[2] ;
35980
35981 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
35982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35983 if (!SWIG_IsOK(res1)) {
35984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35985 }
35986 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35987 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35988 if (!SWIG_IsOK(ecode2)) {
35989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
35990 }
35991 arg2 = static_cast< int >(val2);
35992 if (arg1) (arg1)->h = arg2;
35993
35994 resultobj = SWIG_Py_Void();
35995 return resultobj;
35996 fail:
35997 return NULL;
35998 }
35999
36000
36001 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36002 PyObject *resultobj = 0;
36003 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36004 int result;
36005 void *argp1 = 0 ;
36006 int res1 = 0 ;
36007 PyObject *swig_obj[1] ;
36008
36009 if (!args) SWIG_fail;
36010 swig_obj[0] = args;
36011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36012 if (!SWIG_IsOK(res1)) {
36013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36014 }
36015 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36016 result = (int) ((arg1)->h);
36017 resultobj = SWIG_From_int(static_cast< int >(result));
36018 return resultobj;
36019 fail:
36020 return NULL;
36021 }
36022
36023
36024 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36025 PyObject *resultobj = 0;
36026 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36027 int arg2 ;
36028 void *argp1 = 0 ;
36029 int res1 = 0 ;
36030 int val2 ;
36031 int ecode2 = 0 ;
36032 PyObject *swig_obj[2] ;
36033
36034 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36036 if (!SWIG_IsOK(res1)) {
36037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36038 }
36039 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36040 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36041 if (!SWIG_IsOK(ecode2)) {
36042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36043 }
36044 arg2 = static_cast< int >(val2);
36045 if (arg1) (arg1)->bpp = arg2;
36046
36047 resultobj = SWIG_Py_Void();
36048 return resultobj;
36049 fail:
36050 return NULL;
36051 }
36052
36053
36054 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36055 PyObject *resultobj = 0;
36056 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36057 int result;
36058 void *argp1 = 0 ;
36059 int res1 = 0 ;
36060 PyObject *swig_obj[1] ;
36061
36062 if (!args) SWIG_fail;
36063 swig_obj[0] = args;
36064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36065 if (!SWIG_IsOK(res1)) {
36066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36067 }
36068 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36069 result = (int) ((arg1)->bpp);
36070 resultobj = SWIG_From_int(static_cast< int >(result));
36071 return resultobj;
36072 fail:
36073 return NULL;
36074 }
36075
36076
36077 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36078 PyObject *resultobj = 0;
36079 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36080 int arg2 ;
36081 void *argp1 = 0 ;
36082 int res1 = 0 ;
36083 int val2 ;
36084 int ecode2 = 0 ;
36085 PyObject *swig_obj[2] ;
36086
36087 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36089 if (!SWIG_IsOK(res1)) {
36090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36091 }
36092 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36093 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36094 if (!SWIG_IsOK(ecode2)) {
36095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36096 }
36097 arg2 = static_cast< int >(val2);
36098 if (arg1) (arg1)->refresh = arg2;
36099
36100 resultobj = SWIG_Py_Void();
36101 return resultobj;
36102 fail:
36103 return NULL;
36104 }
36105
36106
36107 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36108 PyObject *resultobj = 0;
36109 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36110 int result;
36111 void *argp1 = 0 ;
36112 int res1 = 0 ;
36113 PyObject *swig_obj[1] ;
36114
36115 if (!args) SWIG_fail;
36116 swig_obj[0] = args;
36117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36118 if (!SWIG_IsOK(res1)) {
36119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36120 }
36121 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36122 result = (int) ((arg1)->refresh);
36123 resultobj = SWIG_From_int(static_cast< int >(result));
36124 return resultobj;
36125 fail:
36126 return NULL;
36127 }
36128
36129
36130 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36131 PyObject *obj;
36132 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36133 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36134 return SWIG_Py_Void();
36135 }
36136
36137 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36138 return SWIG_Python_InitShadowInstance(args);
36139 }
36140
36141 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36142 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36143 return 1;
36144 }
36145
36146
36147 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36148 PyObject *pyobj = 0;
36149
36150 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36151 return pyobj;
36152 }
36153
36154
36155 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36156 PyObject *resultobj = 0;
36157 size_t arg1 = (size_t) 0 ;
36158 wxDisplay *result = 0 ;
36159 size_t val1 ;
36160 int ecode1 = 0 ;
36161 PyObject * obj0 = 0 ;
36162 char * kwnames[] = {
36163 (char *) "index", NULL
36164 };
36165
36166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36167 if (obj0) {
36168 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
36169 if (!SWIG_IsOK(ecode1)) {
36170 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
36171 }
36172 arg1 = static_cast< size_t >(val1);
36173 }
36174 {
36175 PyThreadState* __tstate = wxPyBeginAllowThreads();
36176 result = (wxDisplay *)new wxDisplay(arg1);
36177 wxPyEndAllowThreads(__tstate);
36178 if (PyErr_Occurred()) SWIG_fail;
36179 }
36180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36181 return resultobj;
36182 fail:
36183 return NULL;
36184 }
36185
36186
36187 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36188 PyObject *resultobj = 0;
36189 wxDisplay *arg1 = (wxDisplay *) 0 ;
36190 void *argp1 = 0 ;
36191 int res1 = 0 ;
36192 PyObject *swig_obj[1] ;
36193
36194 if (!args) SWIG_fail;
36195 swig_obj[0] = args;
36196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36197 if (!SWIG_IsOK(res1)) {
36198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36199 }
36200 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36201 {
36202 PyThreadState* __tstate = wxPyBeginAllowThreads();
36203 delete arg1;
36204
36205 wxPyEndAllowThreads(__tstate);
36206 if (PyErr_Occurred()) SWIG_fail;
36207 }
36208 resultobj = SWIG_Py_Void();
36209 return resultobj;
36210 fail:
36211 return NULL;
36212 }
36213
36214
36215 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36216 PyObject *resultobj = 0;
36217 size_t result;
36218
36219 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36220 {
36221 PyThreadState* __tstate = wxPyBeginAllowThreads();
36222 result = (size_t)wxDisplay::GetCount();
36223 wxPyEndAllowThreads(__tstate);
36224 if (PyErr_Occurred()) SWIG_fail;
36225 }
36226 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
36227 return resultobj;
36228 fail:
36229 return NULL;
36230 }
36231
36232
36233 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36234 PyObject *resultobj = 0;
36235 wxPoint *arg1 = 0 ;
36236 int result;
36237 wxPoint temp1 ;
36238 PyObject * obj0 = 0 ;
36239 char * kwnames[] = {
36240 (char *) "pt", NULL
36241 };
36242
36243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36244 {
36245 arg1 = &temp1;
36246 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36247 }
36248 {
36249 PyThreadState* __tstate = wxPyBeginAllowThreads();
36250 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36251 wxPyEndAllowThreads(__tstate);
36252 if (PyErr_Occurred()) SWIG_fail;
36253 }
36254 resultobj = SWIG_From_int(static_cast< int >(result));
36255 return resultobj;
36256 fail:
36257 return NULL;
36258 }
36259
36260
36261 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36262 PyObject *resultobj = 0;
36263 wxWindow *arg1 = (wxWindow *) 0 ;
36264 int result;
36265 void *argp1 = 0 ;
36266 int res1 = 0 ;
36267 PyObject * obj0 = 0 ;
36268 char * kwnames[] = {
36269 (char *) "window", NULL
36270 };
36271
36272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36274 if (!SWIG_IsOK(res1)) {
36275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36276 }
36277 arg1 = reinterpret_cast< wxWindow * >(argp1);
36278 {
36279 PyThreadState* __tstate = wxPyBeginAllowThreads();
36280 result = (int)wxDisplay::GetFromWindow(arg1);
36281 wxPyEndAllowThreads(__tstate);
36282 if (PyErr_Occurred()) SWIG_fail;
36283 }
36284 resultobj = SWIG_From_int(static_cast< int >(result));
36285 return resultobj;
36286 fail:
36287 return NULL;
36288 }
36289
36290
36291 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36292 PyObject *resultobj = 0;
36293 wxDisplay *arg1 = (wxDisplay *) 0 ;
36294 bool result;
36295 void *argp1 = 0 ;
36296 int res1 = 0 ;
36297 PyObject *swig_obj[1] ;
36298
36299 if (!args) SWIG_fail;
36300 swig_obj[0] = args;
36301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36302 if (!SWIG_IsOK(res1)) {
36303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36304 }
36305 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36306 {
36307 PyThreadState* __tstate = wxPyBeginAllowThreads();
36308 result = (bool)((wxDisplay const *)arg1)->IsOk();
36309 wxPyEndAllowThreads(__tstate);
36310 if (PyErr_Occurred()) SWIG_fail;
36311 }
36312 {
36313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36314 }
36315 return resultobj;
36316 fail:
36317 return NULL;
36318 }
36319
36320
36321 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36322 PyObject *resultobj = 0;
36323 wxDisplay *arg1 = (wxDisplay *) 0 ;
36324 wxRect result;
36325 void *argp1 = 0 ;
36326 int res1 = 0 ;
36327 PyObject *swig_obj[1] ;
36328
36329 if (!args) SWIG_fail;
36330 swig_obj[0] = args;
36331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36332 if (!SWIG_IsOK(res1)) {
36333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36334 }
36335 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36336 {
36337 PyThreadState* __tstate = wxPyBeginAllowThreads();
36338 result = ((wxDisplay const *)arg1)->GetGeometry();
36339 wxPyEndAllowThreads(__tstate);
36340 if (PyErr_Occurred()) SWIG_fail;
36341 }
36342 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36343 return resultobj;
36344 fail:
36345 return NULL;
36346 }
36347
36348
36349 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36350 PyObject *resultobj = 0;
36351 wxDisplay *arg1 = (wxDisplay *) 0 ;
36352 wxRect result;
36353 void *argp1 = 0 ;
36354 int res1 = 0 ;
36355 PyObject *swig_obj[1] ;
36356
36357 if (!args) SWIG_fail;
36358 swig_obj[0] = args;
36359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36360 if (!SWIG_IsOK(res1)) {
36361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36362 }
36363 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36364 {
36365 PyThreadState* __tstate = wxPyBeginAllowThreads();
36366 result = ((wxDisplay const *)arg1)->GetClientArea();
36367 wxPyEndAllowThreads(__tstate);
36368 if (PyErr_Occurred()) SWIG_fail;
36369 }
36370 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36371 return resultobj;
36372 fail:
36373 return NULL;
36374 }
36375
36376
36377 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36378 PyObject *resultobj = 0;
36379 wxDisplay *arg1 = (wxDisplay *) 0 ;
36380 wxString result;
36381 void *argp1 = 0 ;
36382 int res1 = 0 ;
36383 PyObject *swig_obj[1] ;
36384
36385 if (!args) SWIG_fail;
36386 swig_obj[0] = args;
36387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36388 if (!SWIG_IsOK(res1)) {
36389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36390 }
36391 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36392 {
36393 PyThreadState* __tstate = wxPyBeginAllowThreads();
36394 result = ((wxDisplay const *)arg1)->GetName();
36395 wxPyEndAllowThreads(__tstate);
36396 if (PyErr_Occurred()) SWIG_fail;
36397 }
36398 {
36399 #if wxUSE_UNICODE
36400 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36401 #else
36402 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36403 #endif
36404 }
36405 return resultobj;
36406 fail:
36407 return NULL;
36408 }
36409
36410
36411 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36412 PyObject *resultobj = 0;
36413 wxDisplay *arg1 = (wxDisplay *) 0 ;
36414 bool result;
36415 void *argp1 = 0 ;
36416 int res1 = 0 ;
36417 PyObject *swig_obj[1] ;
36418
36419 if (!args) SWIG_fail;
36420 swig_obj[0] = args;
36421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36422 if (!SWIG_IsOK(res1)) {
36423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36424 }
36425 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36426 {
36427 PyThreadState* __tstate = wxPyBeginAllowThreads();
36428 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36429 wxPyEndAllowThreads(__tstate);
36430 if (PyErr_Occurred()) SWIG_fail;
36431 }
36432 {
36433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36434 }
36435 return resultobj;
36436 fail:
36437 return NULL;
36438 }
36439
36440
36441 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36442 PyObject *resultobj = 0;
36443 wxDisplay *arg1 = (wxDisplay *) 0 ;
36444 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36445 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36446 PyObject *result = 0 ;
36447 void *argp1 = 0 ;
36448 int res1 = 0 ;
36449 void *argp2 = 0 ;
36450 int res2 = 0 ;
36451 PyObject * obj0 = 0 ;
36452 PyObject * obj1 = 0 ;
36453 char * kwnames[] = {
36454 (char *) "self",(char *) "mode", NULL
36455 };
36456
36457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36459 if (!SWIG_IsOK(res1)) {
36460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36461 }
36462 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36463 if (obj1) {
36464 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36465 if (!SWIG_IsOK(res2)) {
36466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36467 }
36468 if (!argp2) {
36469 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36470 }
36471 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36472 }
36473 {
36474 PyThreadState* __tstate = wxPyBeginAllowThreads();
36475 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36476 wxPyEndAllowThreads(__tstate);
36477 if (PyErr_Occurred()) SWIG_fail;
36478 }
36479 resultobj = result;
36480 return resultobj;
36481 fail:
36482 return NULL;
36483 }
36484
36485
36486 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36487 PyObject *resultobj = 0;
36488 wxDisplay *arg1 = (wxDisplay *) 0 ;
36489 wxVideoMode result;
36490 void *argp1 = 0 ;
36491 int res1 = 0 ;
36492 PyObject *swig_obj[1] ;
36493
36494 if (!args) SWIG_fail;
36495 swig_obj[0] = args;
36496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36497 if (!SWIG_IsOK(res1)) {
36498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36499 }
36500 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36501 {
36502 PyThreadState* __tstate = wxPyBeginAllowThreads();
36503 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36504 wxPyEndAllowThreads(__tstate);
36505 if (PyErr_Occurred()) SWIG_fail;
36506 }
36507 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36508 return resultobj;
36509 fail:
36510 return NULL;
36511 }
36512
36513
36514 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36515 PyObject *resultobj = 0;
36516 wxDisplay *arg1 = (wxDisplay *) 0 ;
36517 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36518 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36519 bool result;
36520 void *argp1 = 0 ;
36521 int res1 = 0 ;
36522 void *argp2 = 0 ;
36523 int res2 = 0 ;
36524 PyObject * obj0 = 0 ;
36525 PyObject * obj1 = 0 ;
36526 char * kwnames[] = {
36527 (char *) "self",(char *) "mode", NULL
36528 };
36529
36530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36532 if (!SWIG_IsOK(res1)) {
36533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36534 }
36535 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36536 if (obj1) {
36537 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36538 if (!SWIG_IsOK(res2)) {
36539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36540 }
36541 if (!argp2) {
36542 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36543 }
36544 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36545 }
36546 {
36547 PyThreadState* __tstate = wxPyBeginAllowThreads();
36548 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36549 wxPyEndAllowThreads(__tstate);
36550 if (PyErr_Occurred()) SWIG_fail;
36551 }
36552 {
36553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36554 }
36555 return resultobj;
36556 fail:
36557 return NULL;
36558 }
36559
36560
36561 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36562 PyObject *resultobj = 0;
36563 wxDisplay *arg1 = (wxDisplay *) 0 ;
36564 void *argp1 = 0 ;
36565 int res1 = 0 ;
36566 PyObject *swig_obj[1] ;
36567
36568 if (!args) SWIG_fail;
36569 swig_obj[0] = args;
36570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36571 if (!SWIG_IsOK(res1)) {
36572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36573 }
36574 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36575 {
36576 PyThreadState* __tstate = wxPyBeginAllowThreads();
36577 wxDisplay_ResetMode(arg1);
36578 wxPyEndAllowThreads(__tstate);
36579 if (PyErr_Occurred()) SWIG_fail;
36580 }
36581 resultobj = SWIG_Py_Void();
36582 return resultobj;
36583 fail:
36584 return NULL;
36585 }
36586
36587
36588 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36589 PyObject *obj;
36590 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36591 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36592 return SWIG_Py_Void();
36593 }
36594
36595 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36596 return SWIG_Python_InitShadowInstance(args);
36597 }
36598
36599 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36600 PyObject *resultobj = 0;
36601 wxStandardPaths *result = 0 ;
36602
36603 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36604 {
36605 PyThreadState* __tstate = wxPyBeginAllowThreads();
36606 result = (wxStandardPaths *)wxStandardPaths_Get();
36607 wxPyEndAllowThreads(__tstate);
36608 if (PyErr_Occurred()) SWIG_fail;
36609 }
36610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36611 return resultobj;
36612 fail:
36613 return NULL;
36614 }
36615
36616
36617 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36618 PyObject *resultobj = 0;
36619 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36620 wxString result;
36621 void *argp1 = 0 ;
36622 int res1 = 0 ;
36623 PyObject *swig_obj[1] ;
36624
36625 if (!args) SWIG_fail;
36626 swig_obj[0] = args;
36627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36628 if (!SWIG_IsOK(res1)) {
36629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36630 }
36631 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36632 {
36633 PyThreadState* __tstate = wxPyBeginAllowThreads();
36634 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36635 wxPyEndAllowThreads(__tstate);
36636 if (PyErr_Occurred()) SWIG_fail;
36637 }
36638 {
36639 #if wxUSE_UNICODE
36640 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36641 #else
36642 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36643 #endif
36644 }
36645 return resultobj;
36646 fail:
36647 return NULL;
36648 }
36649
36650
36651 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36652 PyObject *resultobj = 0;
36653 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36654 wxString result;
36655 void *argp1 = 0 ;
36656 int res1 = 0 ;
36657 PyObject *swig_obj[1] ;
36658
36659 if (!args) SWIG_fail;
36660 swig_obj[0] = args;
36661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36662 if (!SWIG_IsOK(res1)) {
36663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36664 }
36665 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36666 {
36667 PyThreadState* __tstate = wxPyBeginAllowThreads();
36668 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36669 wxPyEndAllowThreads(__tstate);
36670 if (PyErr_Occurred()) SWIG_fail;
36671 }
36672 {
36673 #if wxUSE_UNICODE
36674 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36675 #else
36676 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36677 #endif
36678 }
36679 return resultobj;
36680 fail:
36681 return NULL;
36682 }
36683
36684
36685 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36686 PyObject *resultobj = 0;
36687 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36688 wxString result;
36689 void *argp1 = 0 ;
36690 int res1 = 0 ;
36691 PyObject *swig_obj[1] ;
36692
36693 if (!args) SWIG_fail;
36694 swig_obj[0] = args;
36695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36696 if (!SWIG_IsOK(res1)) {
36697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36698 }
36699 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36700 {
36701 PyThreadState* __tstate = wxPyBeginAllowThreads();
36702 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36703 wxPyEndAllowThreads(__tstate);
36704 if (PyErr_Occurred()) SWIG_fail;
36705 }
36706 {
36707 #if wxUSE_UNICODE
36708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36709 #else
36710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36711 #endif
36712 }
36713 return resultobj;
36714 fail:
36715 return NULL;
36716 }
36717
36718
36719 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36720 PyObject *resultobj = 0;
36721 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36722 wxString result;
36723 void *argp1 = 0 ;
36724 int res1 = 0 ;
36725 PyObject *swig_obj[1] ;
36726
36727 if (!args) SWIG_fail;
36728 swig_obj[0] = args;
36729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36730 if (!SWIG_IsOK(res1)) {
36731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36732 }
36733 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36734 {
36735 PyThreadState* __tstate = wxPyBeginAllowThreads();
36736 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
36737 wxPyEndAllowThreads(__tstate);
36738 if (PyErr_Occurred()) SWIG_fail;
36739 }
36740 {
36741 #if wxUSE_UNICODE
36742 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36743 #else
36744 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36745 #endif
36746 }
36747 return resultobj;
36748 fail:
36749 return NULL;
36750 }
36751
36752
36753 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36754 PyObject *resultobj = 0;
36755 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36756 wxString result;
36757 void *argp1 = 0 ;
36758 int res1 = 0 ;
36759 PyObject *swig_obj[1] ;
36760
36761 if (!args) SWIG_fail;
36762 swig_obj[0] = args;
36763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36764 if (!SWIG_IsOK(res1)) {
36765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36766 }
36767 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36768 {
36769 PyThreadState* __tstate = wxPyBeginAllowThreads();
36770 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
36771 wxPyEndAllowThreads(__tstate);
36772 if (PyErr_Occurred()) SWIG_fail;
36773 }
36774 {
36775 #if wxUSE_UNICODE
36776 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36777 #else
36778 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36779 #endif
36780 }
36781 return resultobj;
36782 fail:
36783 return NULL;
36784 }
36785
36786
36787 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36788 PyObject *resultobj = 0;
36789 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36790 wxString result;
36791 void *argp1 = 0 ;
36792 int res1 = 0 ;
36793 PyObject *swig_obj[1] ;
36794
36795 if (!args) SWIG_fail;
36796 swig_obj[0] = args;
36797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36798 if (!SWIG_IsOK(res1)) {
36799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36800 }
36801 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36802 {
36803 PyThreadState* __tstate = wxPyBeginAllowThreads();
36804 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
36805 wxPyEndAllowThreads(__tstate);
36806 if (PyErr_Occurred()) SWIG_fail;
36807 }
36808 {
36809 #if wxUSE_UNICODE
36810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36811 #else
36812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36813 #endif
36814 }
36815 return resultobj;
36816 fail:
36817 return NULL;
36818 }
36819
36820
36821 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36822 PyObject *resultobj = 0;
36823 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36824 wxString result;
36825 void *argp1 = 0 ;
36826 int res1 = 0 ;
36827 PyObject *swig_obj[1] ;
36828
36829 if (!args) SWIG_fail;
36830 swig_obj[0] = args;
36831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36832 if (!SWIG_IsOK(res1)) {
36833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36834 }
36835 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36836 {
36837 PyThreadState* __tstate = wxPyBeginAllowThreads();
36838 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
36839 wxPyEndAllowThreads(__tstate);
36840 if (PyErr_Occurred()) SWIG_fail;
36841 }
36842 {
36843 #if wxUSE_UNICODE
36844 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36845 #else
36846 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36847 #endif
36848 }
36849 return resultobj;
36850 fail:
36851 return NULL;
36852 }
36853
36854
36855 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36856 PyObject *resultobj = 0;
36857 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36858 wxString result;
36859 void *argp1 = 0 ;
36860 int res1 = 0 ;
36861 PyObject *swig_obj[1] ;
36862
36863 if (!args) SWIG_fail;
36864 swig_obj[0] = args;
36865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36866 if (!SWIG_IsOK(res1)) {
36867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36868 }
36869 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36870 {
36871 PyThreadState* __tstate = wxPyBeginAllowThreads();
36872 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
36873 wxPyEndAllowThreads(__tstate);
36874 if (PyErr_Occurred()) SWIG_fail;
36875 }
36876 {
36877 #if wxUSE_UNICODE
36878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36879 #else
36880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36881 #endif
36882 }
36883 return resultobj;
36884 fail:
36885 return NULL;
36886 }
36887
36888
36889 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36890 PyObject *resultobj = 0;
36891 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36892 wxString *arg2 = 0 ;
36893 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
36894 wxString result;
36895 void *argp1 = 0 ;
36896 int res1 = 0 ;
36897 bool temp2 = false ;
36898 int val3 ;
36899 int ecode3 = 0 ;
36900 PyObject * obj0 = 0 ;
36901 PyObject * obj1 = 0 ;
36902 PyObject * obj2 = 0 ;
36903 char * kwnames[] = {
36904 (char *) "self",(char *) "lang",(char *) "category", NULL
36905 };
36906
36907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36909 if (!SWIG_IsOK(res1)) {
36910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36911 }
36912 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36913 {
36914 arg2 = wxString_in_helper(obj1);
36915 if (arg2 == NULL) SWIG_fail;
36916 temp2 = true;
36917 }
36918 if (obj2) {
36919 ecode3 = SWIG_AsVal_int(obj2, &val3);
36920 if (!SWIG_IsOK(ecode3)) {
36921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
36922 }
36923 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
36924 }
36925 {
36926 PyThreadState* __tstate = wxPyBeginAllowThreads();
36927 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
36928 wxPyEndAllowThreads(__tstate);
36929 if (PyErr_Occurred()) SWIG_fail;
36930 }
36931 {
36932 #if wxUSE_UNICODE
36933 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36934 #else
36935 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36936 #endif
36937 }
36938 {
36939 if (temp2)
36940 delete arg2;
36941 }
36942 return resultobj;
36943 fail:
36944 {
36945 if (temp2)
36946 delete arg2;
36947 }
36948 return NULL;
36949 }
36950
36951
36952 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36953 PyObject *resultobj = 0;
36954 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36955 wxString result;
36956 void *argp1 = 0 ;
36957 int res1 = 0 ;
36958 PyObject *swig_obj[1] ;
36959
36960 if (!args) SWIG_fail;
36961 swig_obj[0] = args;
36962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36963 if (!SWIG_IsOK(res1)) {
36964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36965 }
36966 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36967 {
36968 PyThreadState* __tstate = wxPyBeginAllowThreads();
36969 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
36970 wxPyEndAllowThreads(__tstate);
36971 if (PyErr_Occurred()) SWIG_fail;
36972 }
36973 {
36974 #if wxUSE_UNICODE
36975 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36976 #else
36977 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36978 #endif
36979 }
36980 return resultobj;
36981 fail:
36982 return NULL;
36983 }
36984
36985
36986 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36987 PyObject *resultobj = 0;
36988 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36989 wxString *arg2 = 0 ;
36990 void *argp1 = 0 ;
36991 int res1 = 0 ;
36992 bool temp2 = false ;
36993 PyObject * obj0 = 0 ;
36994 PyObject * obj1 = 0 ;
36995 char * kwnames[] = {
36996 (char *) "self",(char *) "prefix", NULL
36997 };
36998
36999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37001 if (!SWIG_IsOK(res1)) {
37002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37003 }
37004 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37005 {
37006 arg2 = wxString_in_helper(obj1);
37007 if (arg2 == NULL) SWIG_fail;
37008 temp2 = true;
37009 }
37010 {
37011 PyThreadState* __tstate = wxPyBeginAllowThreads();
37012 (arg1)->SetInstallPrefix((wxString const &)*arg2);
37013 wxPyEndAllowThreads(__tstate);
37014 if (PyErr_Occurred()) SWIG_fail;
37015 }
37016 resultobj = SWIG_Py_Void();
37017 {
37018 if (temp2)
37019 delete arg2;
37020 }
37021 return resultobj;
37022 fail:
37023 {
37024 if (temp2)
37025 delete arg2;
37026 }
37027 return NULL;
37028 }
37029
37030
37031 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37032 PyObject *resultobj = 0;
37033 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37034 wxString result;
37035 void *argp1 = 0 ;
37036 int res1 = 0 ;
37037 PyObject *swig_obj[1] ;
37038
37039 if (!args) SWIG_fail;
37040 swig_obj[0] = args;
37041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37042 if (!SWIG_IsOK(res1)) {
37043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37044 }
37045 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37046 {
37047 PyThreadState* __tstate = wxPyBeginAllowThreads();
37048 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
37049 wxPyEndAllowThreads(__tstate);
37050 if (PyErr_Occurred()) SWIG_fail;
37051 }
37052 {
37053 #if wxUSE_UNICODE
37054 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37055 #else
37056 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37057 #endif
37058 }
37059 return resultobj;
37060 fail:
37061 return NULL;
37062 }
37063
37064
37065 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37066 PyObject *obj;
37067 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37068 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37069 return SWIG_Py_Void();
37070 }
37071
37072 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37073 PyObject *resultobj = 0;
37074 wxEventType arg1 ;
37075 wxPowerEvent *result = 0 ;
37076 int val1 ;
37077 int ecode1 = 0 ;
37078 PyObject * obj0 = 0 ;
37079 char * kwnames[] = {
37080 (char *) "evtType", NULL
37081 };
37082
37083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37084 ecode1 = SWIG_AsVal_int(obj0, &val1);
37085 if (!SWIG_IsOK(ecode1)) {
37086 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37087 }
37088 arg1 = static_cast< wxEventType >(val1);
37089 {
37090 PyThreadState* __tstate = wxPyBeginAllowThreads();
37091 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37092 wxPyEndAllowThreads(__tstate);
37093 if (PyErr_Occurred()) SWIG_fail;
37094 }
37095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37096 return resultobj;
37097 fail:
37098 return NULL;
37099 }
37100
37101
37102 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37103 PyObject *resultobj = 0;
37104 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37105 void *argp1 = 0 ;
37106 int res1 = 0 ;
37107 PyObject *swig_obj[1] ;
37108
37109 if (!args) SWIG_fail;
37110 swig_obj[0] = args;
37111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37112 if (!SWIG_IsOK(res1)) {
37113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37114 }
37115 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37116 {
37117 PyThreadState* __tstate = wxPyBeginAllowThreads();
37118 (arg1)->Veto();
37119 wxPyEndAllowThreads(__tstate);
37120 if (PyErr_Occurred()) SWIG_fail;
37121 }
37122 resultobj = SWIG_Py_Void();
37123 return resultobj;
37124 fail:
37125 return NULL;
37126 }
37127
37128
37129 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37130 PyObject *resultobj = 0;
37131 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37132 bool result;
37133 void *argp1 = 0 ;
37134 int res1 = 0 ;
37135 PyObject *swig_obj[1] ;
37136
37137 if (!args) SWIG_fail;
37138 swig_obj[0] = args;
37139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37140 if (!SWIG_IsOK(res1)) {
37141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37142 }
37143 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37144 {
37145 PyThreadState* __tstate = wxPyBeginAllowThreads();
37146 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37147 wxPyEndAllowThreads(__tstate);
37148 if (PyErr_Occurred()) SWIG_fail;
37149 }
37150 {
37151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37152 }
37153 return resultobj;
37154 fail:
37155 return NULL;
37156 }
37157
37158
37159 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37160 PyObject *obj;
37161 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37162 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37163 return SWIG_Py_Void();
37164 }
37165
37166 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37167 return SWIG_Python_InitShadowInstance(args);
37168 }
37169
37170 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37171 PyObject *resultobj = 0;
37172 wxPowerType result;
37173
37174 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37175 {
37176 PyThreadState* __tstate = wxPyBeginAllowThreads();
37177 result = (wxPowerType)wxGetPowerType();
37178 wxPyEndAllowThreads(__tstate);
37179 if (PyErr_Occurred()) SWIG_fail;
37180 }
37181 resultobj = SWIG_From_int(static_cast< int >(result));
37182 return resultobj;
37183 fail:
37184 return NULL;
37185 }
37186
37187
37188 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37189 PyObject *resultobj = 0;
37190 wxBatteryState result;
37191
37192 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37193 {
37194 PyThreadState* __tstate = wxPyBeginAllowThreads();
37195 result = (wxBatteryState)wxGetBatteryState();
37196 wxPyEndAllowThreads(__tstate);
37197 if (PyErr_Occurred()) SWIG_fail;
37198 }
37199 resultobj = SWIG_From_int(static_cast< int >(result));
37200 return resultobj;
37201 fail:
37202 return NULL;
37203 }
37204
37205
37206 static PyMethodDef SwigMethods[] = {
37207 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
37208 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
37209 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
37210 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
37211 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
37212 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
37213 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
37214 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
37215 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
37216 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
37217 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
37218 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
37219 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
37220 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
37221 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
37222 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
37223 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
37224 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
37225 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
37226 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
37227 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
37228 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
37229 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
37230 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
37231 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
37232 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
37233 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
37234 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
37235 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
37236 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
37237 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
37238 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
37239 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
37240 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
37241 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
37242 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
37243 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
37244 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
37245 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
37246 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
37247 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
37248 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
37249 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
37250 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
37251 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
37252 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
37253 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
37254 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
37255 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
37256 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37257 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37258 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37259 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37260 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37261 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37262 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
37263 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
37264 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
37265 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37266 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
37267 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
37268 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
37269 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
37270 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
37271 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
37272 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
37273 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
37274 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
37275 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37276 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
37277 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37278 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
37279 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
37280 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
37281 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37282 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37283 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
37284 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
37285 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
37286 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
37287 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
37288 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
37289 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
37290 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
37291 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
37292 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
37293 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
37294 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
37295 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
37296 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
37297 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
37298 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
37299 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
37300 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
37301 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
37302 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
37303 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
37304 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
37305 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
37306 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
37307 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
37308 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
37309 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
37310 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
37311 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
37312 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
37313 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
37314 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
37315 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
37316 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
37317 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
37318 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
37319 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
37320 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
37321 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
37322 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
37323 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
37324 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
37325 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
37326 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
37327 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
37328 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
37329 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
37330 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
37331 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
37332 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
37333 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
37334 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
37335 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
37336 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
37337 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
37338 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
37339 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
37340 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
37341 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
37342 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
37343 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
37344 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
37345 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
37346 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
37347 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37348 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
37349 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
37350 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
37351 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
37352 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
37353 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
37354 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
37355 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37356 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
37357 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
37358 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
37359 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
37360 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37361 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
37362 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
37363 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
37364 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
37365 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
37366 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37367 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
37368 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37369 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37370 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
37371 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37372 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37373 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
37374 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
37375 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
37376 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37377 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
37378 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
37379 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
37380 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
37381 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
37382 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
37383 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
37384 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
37385 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
37386 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
37387 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
37388 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
37389 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37390 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37391 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
37392 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
37393 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
37394 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
37395 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
37396 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
37397 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
37398 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
37399 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
37400 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
37401 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
37402 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
37403 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
37404 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
37405 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
37406 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37407 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37408 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
37409 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
37410 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
37411 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
37412 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
37413 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
37414 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
37415 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
37416 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
37417 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
37418 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
37419 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
37420 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
37421 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37422 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37423 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
37424 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
37425 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
37426 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37427 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
37428 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
37429 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37430 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
37431 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
37432 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37433 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
37434 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
37435 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
37436 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
37437 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
37438 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
37439 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
37440 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
37441 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37442 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
37443 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
37444 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
37445 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
37446 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
37447 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37448 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
37449 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
37450 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
37451 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
37452 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
37453 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
37454 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
37455 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
37456 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
37457 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
37458 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
37459 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
37460 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
37461 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
37462 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
37463 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
37464 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
37465 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
37466 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37467 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37468 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37469 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
37470 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
37471 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
37472 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
37473 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
37474 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37475 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
37476 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
37477 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
37478 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
37479 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
37480 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
37481 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
37482 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
37483 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
37484 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
37485 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
37486 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
37487 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
37488 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
37489 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
37490 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37491 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
37492 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
37493 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
37494 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
37495 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
37496 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
37497 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
37498 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
37499 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
37500 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
37501 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
37502 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
37503 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
37504 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
37505 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
37506 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
37507 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
37508 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
37509 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
37510 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
37511 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
37512 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
37513 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
37514 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
37515 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37516 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
37517 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
37518 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
37519 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
37520 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
37521 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
37522 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
37523 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
37524 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
37525 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
37526 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
37527 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
37528 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
37529 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37530 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
37531 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
37532 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
37533 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
37534 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
37535 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
37536 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37537 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
37538 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
37539 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
37540 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
37541 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
37542 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
37543 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
37544 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
37545 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
37546 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
37547 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
37548 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
37549 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
37550 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37551 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
37552 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
37553 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
37554 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
37555 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
37556 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
37557 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
37558 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
37559 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
37560 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
37561 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
37562 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
37563 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
37564 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
37565 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
37566 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
37567 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
37568 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
37569 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
37570 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
37571 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
37572 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
37573 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
37574 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
37575 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
37576 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
37577 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
37578 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
37579 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
37580 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
37581 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
37582 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
37583 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
37584 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
37585 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
37586 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
37587 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
37588 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
37589 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
37590 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
37591 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
37592 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
37593 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
37594 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
37595 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
37596 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
37597 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
37598 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
37599 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
37600 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
37601 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
37602 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
37603 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
37604 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
37605 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
37606 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
37607 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37608 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
37609 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
37610 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
37611 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
37612 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
37613 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
37614 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
37615 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
37616 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
37617 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
37618 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
37619 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
37620 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
37621 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
37622 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
37623 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
37624 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
37625 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
37626 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
37627 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
37628 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
37629 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
37630 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
37631 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
37632 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
37633 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
37634 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
37635 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
37636 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
37637 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37638 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
37639 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
37640 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
37641 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37642 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
37643 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
37644 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
37645 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
37646 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
37647 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
37648 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
37649 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
37650 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
37651 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
37652 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
37653 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
37654 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
37655 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
37656 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
37657 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
37658 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
37659 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
37660 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
37661 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
37662 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37663 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37664 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
37665 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37666 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37667 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
37668 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37669 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
37670 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
37671 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
37672 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
37673 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
37674 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
37675 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
37676 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
37677 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
37678 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
37679 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
37680 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
37681 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
37682 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
37683 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
37684 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
37685 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
37686 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
37687 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
37688 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37689 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37690 { (char *)"ArtProvider_InsertProvider", (PyCFunction) _wrap_ArtProvider_InsertProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37691 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
37692 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37693 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
37694 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37695 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
37696 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
37697 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
37698 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
37699 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
37700 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
37701 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
37702 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
37703 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
37704 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
37705 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
37706 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
37707 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37708 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
37709 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37710 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
37711 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
37712 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37713 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37714 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
37715 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
37716 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
37717 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
37718 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
37719 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
37720 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
37721 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
37722 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
37723 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
37724 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
37725 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37726 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37727 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37728 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37729 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
37730 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37731 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
37732 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
37733 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
37734 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37735 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
37736 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
37737 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
37738 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
37739 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
37740 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
37741 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
37742 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
37743 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
37744 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
37745 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
37746 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
37747 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
37748 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
37749 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
37750 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
37751 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
37752 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
37753 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
37754 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
37755 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37756 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
37757 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
37758 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
37759 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
37760 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
37761 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37762 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
37763 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
37764 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
37765 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37766 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
37767 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
37768 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
37769 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
37770 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
37771 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
37772 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
37773 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
37774 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
37775 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
37776 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
37777 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
37778 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
37779 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
37780 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
37781 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
37782 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
37783 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
37784 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
37785 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
37786 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
37787 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
37788 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
37789 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37790 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
37791 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
37792 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
37793 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
37794 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
37795 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37796 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37797 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37798 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37799 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37800 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37801 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37802 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37803 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37804 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37805 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37806 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37807 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
37808 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
37809 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
37810 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
37811 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
37812 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
37813 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
37814 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
37815 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
37816 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37817 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37818 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37819 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37820 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37821 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37822 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
37823 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
37824 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37825 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37826 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
37827 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
37828 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
37829 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
37830 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37831 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
37832 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37833 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
37834 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
37835 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
37836 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
37837 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37838 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37839 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37840 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
37841 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
37842 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
37843 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
37844 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
37845 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
37846 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
37847 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
37848 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
37849 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
37850 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
37851 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
37852 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
37853 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37854 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
37855 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
37856 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
37857 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
37858 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
37859 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
37860 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
37861 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
37862 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37863 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37864 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
37865 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37866 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
37867 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
37868 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
37869 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
37870 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
37871 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
37872 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
37873 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
37874 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
37875 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
37876 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
37877 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
37878 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
37879 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
37880 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
37881 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
37882 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
37883 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
37884 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
37885 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
37886 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
37887 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
37888 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
37889 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
37890 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37891 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37892 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
37893 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
37894 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
37895 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
37896 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
37897 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
37898 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
37899 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
37900 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
37901 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
37902 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
37903 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
37904 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
37905 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
37906 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
37907 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37908 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37909 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
37910 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
37911 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
37912 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
37913 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
37914 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
37915 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
37916 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
37917 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
37918 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
37919 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
37920 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
37921 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
37922 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
37923 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
37924 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
37925 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
37926 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
37927 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
37928 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
37929 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
37930 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
37931 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
37932 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
37933 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
37934 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
37935 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
37936 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
37937 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
37938 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
37939 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
37940 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
37941 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
37942 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
37943 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37944 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37945 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
37946 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
37947 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
37948 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
37949 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
37950 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
37951 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
37952 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
37953 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
37954 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
37955 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37956 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37957 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
37958 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
37959 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
37960 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
37961 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
37962 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
37963 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37964 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37965 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
37966 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
37967 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
37968 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
37969 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
37970 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
37971 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
37972 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
37973 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
37974 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
37975 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37976 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
37977 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
37978 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
37979 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
37980 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
37981 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37982 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
37983 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
37984 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
37985 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37986 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
37987 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
37988 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37989 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
37990 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
37991 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
37992 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37993 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
37994 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
37995 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
37996 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37997 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
37998 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
37999 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
38000 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38001 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
38002 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
38003 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
38004 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
38005 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
38006 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38007 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38008 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
38009 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
38010 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38011 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
38012 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
38013 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
38014 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
38015 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38016 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38017 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
38018 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
38019 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
38020 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
38021 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
38022 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
38023 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
38024 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
38025 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38026 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
38027 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
38028 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
38029 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
38030 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38031 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
38032 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
38033 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
38034 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
38035 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
38036 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
38037 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
38038 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
38039 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
38040 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38041 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
38042 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38043 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
38044 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
38045 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38046 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
38047 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
38048 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
38049 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
38050 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38051 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
38052 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
38053 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38054 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38055 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38056 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
38057 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38058 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
38059 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
38060 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
38061 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
38062 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
38063 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
38064 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38065 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
38066 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38067 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38068 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
38069 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38070 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
38071 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
38072 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
38073 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
38074 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38075 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
38076 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38077 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38078 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
38079 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38080 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
38081 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
38082 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
38083 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
38084 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
38085 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
38086 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
38087 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
38088 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
38089 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38090 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
38091 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
38092 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
38093 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
38094 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
38095 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
38096 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
38097 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
38098 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
38099 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
38100 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
38101 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
38102 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
38103 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
38104 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
38105 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
38106 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
38107 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
38108 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
38109 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
38110 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
38111 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
38112 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
38113 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
38114 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
38115 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
38116 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
38117 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
38118 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
38119 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
38120 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
38121 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
38122 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
38123 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
38124 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
38125 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
38126 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
38127 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
38128 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
38129 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
38130 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
38131 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
38132 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
38133 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
38134 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
38135 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
38136 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
38137 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
38138 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
38139 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
38140 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
38141 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
38142 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
38143 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
38144 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
38145 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
38146 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
38147 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
38148 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
38149 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
38150 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
38151 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
38152 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
38153 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
38154 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
38155 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
38156 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
38157 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
38158 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
38159 { NULL, NULL, 0, NULL }
38160 };
38161
38162
38163 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
38164
38165 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
38166 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
38167 }
38168 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
38169 return (void *)((wxEvent *) ((wxMenuEvent *) x));
38170 }
38171 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
38172 return (void *)((wxEvent *) ((wxCloseEvent *) x));
38173 }
38174 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
38175 return (void *)((wxEvent *) ((wxMouseEvent *) x));
38176 }
38177 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
38178 return (void *)((wxEvent *) ((wxEraseEvent *) x));
38179 }
38180 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
38181 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
38182 }
38183 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
38184 return (void *)((wxEvent *) ((wxTimerEvent *) x));
38185 }
38186 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
38187 return (void *)((wxEvent *) ((wxPowerEvent *) x));
38188 }
38189 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
38190 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
38191 }
38192 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
38193 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
38194 }
38195 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
38196 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
38197 }
38198 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
38199 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
38200 }
38201 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
38202 return (void *)((wxEvent *) ((wxPyEvent *) x));
38203 }
38204 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
38205 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
38206 }
38207 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
38208 return (void *)((wxEvent *) ((wxIdleEvent *) x));
38209 }
38210 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
38211 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
38212 }
38213 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
38214 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
38215 }
38216 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
38217 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
38218 }
38219 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
38220 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
38221 }
38222 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
38223 return (void *)((wxEvent *) ((wxActivateEvent *) x));
38224 }
38225 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
38226 return (void *)((wxEvent *) ((wxSizeEvent *) x));
38227 }
38228 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
38229 return (void *)((wxEvent *) ((wxMoveEvent *) x));
38230 }
38231 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
38232 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
38233 }
38234 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
38235 return (void *)((wxEvent *) ((wxPaintEvent *) x));
38236 }
38237 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
38238 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
38239 }
38240 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
38241 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
38242 }
38243 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
38244 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
38245 }
38246 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
38247 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
38248 }
38249 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
38250 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
38251 }
38252 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
38253 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
38254 }
38255 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
38256 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
38257 }
38258 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
38259 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
38260 }
38261 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
38262 return (void *)((wxEvent *) ((wxFocusEvent *) x));
38263 }
38264 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
38265 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
38266 }
38267 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
38268 return (void *)((wxEvent *) ((wxProcessEvent *) x));
38269 }
38270 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
38271 return (void *)((wxEvent *) ((wxShowEvent *) x));
38272 }
38273 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
38274 return (void *)((wxEvent *) ((wxCommandEvent *) x));
38275 }
38276 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
38277 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
38278 }
38279 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
38280 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
38281 }
38282 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
38283 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
38284 }
38285 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
38286 return (void *)((wxEvent *) ((wxKeyEvent *) x));
38287 }
38288 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
38289 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
38290 }
38291 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
38292 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
38293 }
38294 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
38295 return (void *)((wxConfigBase *) ((wxConfig *) x));
38296 }
38297 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
38298 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38299 }
38300 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
38301 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
38302 }
38303 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
38304 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
38305 }
38306 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
38307 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
38308 }
38309 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
38310 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
38311 }
38312 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
38313 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
38314 }
38315 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
38316 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
38317 }
38318 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
38319 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
38320 }
38321 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
38322 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38323 }
38324 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
38325 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
38326 }
38327 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
38328 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
38329 }
38330 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
38331 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
38332 }
38333 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
38334 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
38335 }
38336 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
38337 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
38338 }
38339 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
38340 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
38341 }
38342 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
38343 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
38344 }
38345 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
38346 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
38347 }
38348 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
38349 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38350 }
38351 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
38352 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
38353 }
38354 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
38355 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
38356 }
38357 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
38358 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
38359 }
38360 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
38361 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
38362 }
38363 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
38364 return (void *)((wxEvtHandler *) ((wxWindow *) x));
38365 }
38366 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
38367 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
38368 }
38369 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
38370 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
38371 }
38372 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
38373 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
38374 }
38375 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
38376 return (void *)((wxEvtHandler *) ((wxValidator *) x));
38377 }
38378 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
38379 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
38380 }
38381 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
38382 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
38383 }
38384 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
38385 return (void *)((wxEvtHandler *) ((wxMenu *) x));
38386 }
38387 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
38388 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
38389 }
38390 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
38391 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
38392 }
38393 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
38394 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
38395 }
38396 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
38397 return (void *)((wxObject *) ((wxSizerItem *) x));
38398 }
38399 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
38400 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
38401 }
38402 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
38403 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
38404 }
38405 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
38406 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
38407 }
38408 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
38409 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
38410 }
38411 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
38412 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
38413 }
38414 static void *_p_wxSizerTo_p_wxObject(void *x) {
38415 return (void *)((wxObject *) ((wxSizer *) x));
38416 }
38417 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
38418 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
38419 }
38420 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
38421 return (void *)((wxObject *) ((wxFileHistory *) x));
38422 }
38423 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
38424 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
38425 }
38426 static void *_p_wxEventTo_p_wxObject(void *x) {
38427 return (void *)((wxObject *) ((wxEvent *) x));
38428 }
38429 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
38430 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
38431 }
38432 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
38433 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
38434 }
38435 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
38436 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
38437 }
38438 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
38439 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
38440 }
38441 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
38442 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
38443 }
38444 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
38445 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
38446 }
38447 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
38448 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
38449 }
38450 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
38451 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
38452 }
38453 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
38454 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
38455 }
38456 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
38457 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
38458 }
38459 static void *_p_wxControlTo_p_wxObject(void *x) {
38460 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
38461 }
38462 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
38463 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
38464 }
38465 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
38466 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
38467 }
38468 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
38469 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
38470 }
38471 static void *_p_wxFSFileTo_p_wxObject(void *x) {
38472 return (void *)((wxObject *) ((wxFSFile *) x));
38473 }
38474 static void *_p_wxClipboardTo_p_wxObject(void *x) {
38475 return (void *)((wxObject *) ((wxClipboard *) x));
38476 }
38477 static void *_p_wxPySizerTo_p_wxObject(void *x) {
38478 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
38479 }
38480 static void *_p_wxPyEventTo_p_wxObject(void *x) {
38481 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
38482 }
38483 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
38484 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
38485 }
38486 static void *_p_wxShowEventTo_p_wxObject(void *x) {
38487 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
38488 }
38489 static void *_p_wxToolTipTo_p_wxObject(void *x) {
38490 return (void *)((wxObject *) ((wxToolTip *) x));
38491 }
38492 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
38493 return (void *)((wxObject *) ((wxMenuItem *) x));
38494 }
38495 static void *_p_wxDateEventTo_p_wxObject(void *x) {
38496 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
38497 }
38498 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
38499 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
38500 }
38501 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
38502 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
38503 }
38504 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
38505 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
38506 }
38507 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
38508 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
38509 }
38510 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
38511 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
38512 }
38513 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
38514 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
38515 }
38516 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
38517 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
38518 }
38519 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
38520 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
38521 }
38522 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
38523 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
38524 }
38525 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
38526 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
38527 }
38528 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
38529 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
38530 }
38531 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
38532 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
38533 }
38534 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
38535 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
38536 }
38537 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
38538 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
38539 }
38540 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
38541 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
38542 }
38543 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
38544 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
38545 }
38546 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
38547 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
38548 }
38549 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
38550 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
38551 }
38552 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
38553 return (void *)((wxObject *) ((wxImageHandler *) x));
38554 }
38555 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
38556 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
38557 }
38558 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
38559 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
38560 }
38561 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
38562 return (void *)((wxObject *) ((wxEvtHandler *) x));
38563 }
38564 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
38565 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
38566 }
38567 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
38568 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
38569 }
38570 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
38571 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
38572 }
38573 static void *_p_wxImageTo_p_wxObject(void *x) {
38574 return (void *)((wxObject *) ((wxImage *) x));
38575 }
38576 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
38577 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
38578 }
38579 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
38580 return (void *)((wxObject *) ((wxSystemOptions *) x));
38581 }
38582 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
38583 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
38584 }
38585 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
38586 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
38587 }
38588 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
38589 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
38590 }
38591 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
38592 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
38593 }
38594 static void *_p_wxWindowTo_p_wxObject(void *x) {
38595 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
38596 }
38597 static void *_p_wxMenuTo_p_wxObject(void *x) {
38598 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
38599 }
38600 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
38601 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
38602 }
38603 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
38604 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
38605 }
38606 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
38607 return (void *)((wxObject *) ((wxFileSystem *) x));
38608 }
38609 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
38610 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
38611 }
38612 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
38613 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
38614 }
38615 static void *_p_wxPyAppTo_p_wxObject(void *x) {
38616 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
38617 }
38618 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
38619 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
38620 }
38621 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
38622 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
38623 }
38624 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
38625 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
38626 }
38627 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
38628 return (void *)((wxObject *) ((wxBusyInfo *) x));
38629 }
38630 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
38631 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
38632 }
38633 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
38634 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
38635 }
38636 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
38637 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
38638 }
38639 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
38640 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
38641 }
38642 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
38643 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
38644 }
38645 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
38646 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
38647 }
38648 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
38649 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
38650 }
38651 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
38652 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
38653 }
38654 static void *_p_wxValidatorTo_p_wxObject(void *x) {
38655 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
38656 }
38657 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
38658 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
38659 }
38660 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
38661 return (void *)((wxLog *) ((wxLogBuffer *) x));
38662 }
38663 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
38664 return (void *)((wxLog *) ((wxLogStderr *) x));
38665 }
38666 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
38667 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
38668 }
38669 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
38670 return (void *)((wxLog *) ((wxLogWindow *) x));
38671 }
38672 static void *_p_wxLogChainTo_p_wxLog(void *x) {
38673 return (void *)((wxLog *) ((wxLogChain *) x));
38674 }
38675 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
38676 return (void *)((wxLog *) ((wxLogGui *) x));
38677 }
38678 static void *_p_wxPyLogTo_p_wxLog(void *x) {
38679 return (void *)((wxLog *) ((wxPyLog *) x));
38680 }
38681 static void *_p_wxControlTo_p_wxWindow(void *x) {
38682 return (void *)((wxWindow *) ((wxControl *) x));
38683 }
38684 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
38685 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
38686 }
38687 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
38688 return (void *)((wxWindow *) ((wxMenuBar *) x));
38689 }
38690 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
38691 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
38692 }
38693 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
38694 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
38695 }
38696 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
38697 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};
38698 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
38699 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
38700 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
38701 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
38702 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
38703 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
38704 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
38705 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
38706 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
38707 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
38708 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
38709 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
38710 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
38711 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
38712 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
38713 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
38714 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
38715 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
38716 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
38717 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
38718 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
38719 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
38720 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
38721 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
38722 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
38723 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
38724 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
38725 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
38726 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
38727 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
38728 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
38729 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
38730 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
38731 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
38732 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
38733 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
38734 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
38735 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
38736 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
38737 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
38738 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
38739 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
38740 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
38741 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
38742 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
38743 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
38744 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
38745 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
38746 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
38747 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
38748 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
38749 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
38750 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
38751 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
38752 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
38753 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
38754 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
38755 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
38756 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
38757 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
38758 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
38759 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
38760 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
38761 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
38762 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
38763 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
38764 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
38765 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
38766 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
38767 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
38768 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
38769 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
38770 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
38771 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
38772 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
38773 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
38774 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
38775 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
38776 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
38777 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
38778 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
38779 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
38780 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
38781 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
38782 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
38783 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
38784 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
38785 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
38786 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
38787 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
38788 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
38789 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
38790 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
38791 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
38792 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
38793 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
38794 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
38795 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
38796 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
38797 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
38798 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
38799 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
38800 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
38801 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
38802 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
38803 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
38804 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
38805 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
38806 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
38807 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
38808 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
38809 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
38810 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
38811 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
38812 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
38813 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
38814 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
38815 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
38816 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
38817 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
38818 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
38819 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
38820 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
38821 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
38822 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
38823 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
38824 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
38825 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
38826 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
38827 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
38828 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
38829 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
38830 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
38831 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
38832 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
38833 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
38834 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
38835 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
38836 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
38837 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
38838 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
38839 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
38840 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
38841 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
38842 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
38843 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
38844 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
38845 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
38846 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
38847 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
38848 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
38849 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
38850 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
38851 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
38852 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
38853 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
38854 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
38855 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
38856 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
38857 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
38858 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
38859 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
38860 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
38861 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
38862 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
38863 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
38864 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
38865 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
38866 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
38867 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
38868
38869 static swig_type_info *swig_type_initial[] = {
38870 &_swigt__p_char,
38871 &_swigt__p_form_ops_t,
38872 &_swigt__p_int,
38873 &_swigt__p_unsigned_char,
38874 &_swigt__p_unsigned_int,
38875 &_swigt__p_unsigned_long,
38876 &_swigt__p_void,
38877 &_swigt__p_wxANIHandler,
38878 &_swigt__p_wxAcceleratorTable,
38879 &_swigt__p_wxActivateEvent,
38880 &_swigt__p_wxArrayString,
38881 &_swigt__p_wxBMPHandler,
38882 &_swigt__p_wxBitmap,
38883 &_swigt__p_wxBitmapDataObject,
38884 &_swigt__p_wxBoxSizer,
38885 &_swigt__p_wxBusyCursor,
38886 &_swigt__p_wxBusyInfo,
38887 &_swigt__p_wxCURHandler,
38888 &_swigt__p_wxCaret,
38889 &_swigt__p_wxChar,
38890 &_swigt__p_wxChildFocusEvent,
38891 &_swigt__p_wxClipboard,
38892 &_swigt__p_wxClipboardLocker,
38893 &_swigt__p_wxClipboardTextEvent,
38894 &_swigt__p_wxCloseEvent,
38895 &_swigt__p_wxColour,
38896 &_swigt__p_wxCommandEvent,
38897 &_swigt__p_wxConfig,
38898 &_swigt__p_wxConfigBase,
38899 &_swigt__p_wxConfigPathChanger,
38900 &_swigt__p_wxContextMenuEvent,
38901 &_swigt__p_wxControl,
38902 &_swigt__p_wxControlWithItems,
38903 &_swigt__p_wxCursor,
38904 &_swigt__p_wxCustomDataObject,
38905 &_swigt__p_wxDC,
38906 &_swigt__p_wxDataFormat,
38907 &_swigt__p_wxDataObject,
38908 &_swigt__p_wxDataObjectComposite,
38909 &_swigt__p_wxDataObjectSimple,
38910 &_swigt__p_wxDateEvent,
38911 &_swigt__p_wxDateSpan,
38912 &_swigt__p_wxDateTime,
38913 &_swigt__p_wxDateTime__TimeZone,
38914 &_swigt__p_wxDisplay,
38915 &_swigt__p_wxDisplayChangedEvent,
38916 &_swigt__p_wxDropFilesEvent,
38917 &_swigt__p_wxDuplexMode,
38918 &_swigt__p_wxEraseEvent,
38919 &_swigt__p_wxEvent,
38920 &_swigt__p_wxEvtHandler,
38921 &_swigt__p_wxFSFile,
38922 &_swigt__p_wxFileConfig,
38923 &_swigt__p_wxFileDataObject,
38924 &_swigt__p_wxFileHistory,
38925 &_swigt__p_wxFileSystem,
38926 &_swigt__p_wxFileType,
38927 &_swigt__p_wxFileTypeInfo,
38928 &_swigt__p_wxFlexGridSizer,
38929 &_swigt__p_wxFocusEvent,
38930 &_swigt__p_wxFont,
38931 &_swigt__p_wxFrame,
38932 &_swigt__p_wxGBSizerItem,
38933 &_swigt__p_wxGIFHandler,
38934 &_swigt__p_wxGridBagSizer,
38935 &_swigt__p_wxGridSizer,
38936 &_swigt__p_wxICOHandler,
38937 &_swigt__p_wxIcon,
38938 &_swigt__p_wxIconizeEvent,
38939 &_swigt__p_wxIdleEvent,
38940 &_swigt__p_wxImage,
38941 &_swigt__p_wxImageHandler,
38942 &_swigt__p_wxIndividualLayoutConstraint,
38943 &_swigt__p_wxInitDialogEvent,
38944 &_swigt__p_wxJPEGHandler,
38945 &_swigt__p_wxJoystick,
38946 &_swigt__p_wxJoystickEvent,
38947 &_swigt__p_wxKeyEvent,
38948 &_swigt__p_wxKillError,
38949 &_swigt__p_wxLayoutConstraints,
38950 &_swigt__p_wxLog,
38951 &_swigt__p_wxLogBuffer,
38952 &_swigt__p_wxLogChain,
38953 &_swigt__p_wxLogGui,
38954 &_swigt__p_wxLogNull,
38955 &_swigt__p_wxLogStderr,
38956 &_swigt__p_wxLogTextCtrl,
38957 &_swigt__p_wxLogWindow,
38958 &_swigt__p_wxMaximizeEvent,
38959 &_swigt__p_wxMenu,
38960 &_swigt__p_wxMenuBar,
38961 &_swigt__p_wxMenuEvent,
38962 &_swigt__p_wxMenuItem,
38963 &_swigt__p_wxMetafileDataObject,
38964 &_swigt__p_wxMimeTypesManager,
38965 &_swigt__p_wxMouseCaptureChangedEvent,
38966 &_swigt__p_wxMouseCaptureLostEvent,
38967 &_swigt__p_wxMouseEvent,
38968 &_swigt__p_wxMouseState,
38969 &_swigt__p_wxMoveEvent,
38970 &_swigt__p_wxMutexGuiLocker,
38971 &_swigt__p_wxNavigationKeyEvent,
38972 &_swigt__p_wxNcPaintEvent,
38973 &_swigt__p_wxNotifyEvent,
38974 &_swigt__p_wxObject,
38975 &_swigt__p_wxOutputStream,
38976 &_swigt__p_wxPCXHandler,
38977 &_swigt__p_wxPNGHandler,
38978 &_swigt__p_wxPNMHandler,
38979 &_swigt__p_wxPaintEvent,
38980 &_swigt__p_wxPaletteChangedEvent,
38981 &_swigt__p_wxPaperSize,
38982 &_swigt__p_wxPlatformInfo,
38983 &_swigt__p_wxPoint,
38984 &_swigt__p_wxPowerEvent,
38985 &_swigt__p_wxProcessEvent,
38986 &_swigt__p_wxPyApp,
38987 &_swigt__p_wxPyArtProvider,
38988 &_swigt__p_wxPyBitmapDataObject,
38989 &_swigt__p_wxPyCommandEvent,
38990 &_swigt__p_wxPyDataObjectSimple,
38991 &_swigt__p_wxPyDropSource,
38992 &_swigt__p_wxPyDropTarget,
38993 &_swigt__p_wxPyEvent,
38994 &_swigt__p_wxPyFileDropTarget,
38995 &_swigt__p_wxPyImageHandler,
38996 &_swigt__p_wxPyLog,
38997 &_swigt__p_wxPyProcess,
38998 &_swigt__p_wxPySizer,
38999 &_swigt__p_wxPyTextDataObject,
39000 &_swigt__p_wxPyTextDropTarget,
39001 &_swigt__p_wxPyTimer,
39002 &_swigt__p_wxPyTipProvider,
39003 &_swigt__p_wxPyValidator,
39004 &_swigt__p_wxQueryNewPaletteEvent,
39005 &_swigt__p_wxRect,
39006 &_swigt__p_wxScrollEvent,
39007 &_swigt__p_wxScrollWinEvent,
39008 &_swigt__p_wxSetCursorEvent,
39009 &_swigt__p_wxShowEvent,
39010 &_swigt__p_wxSingleInstanceChecker,
39011 &_swigt__p_wxSize,
39012 &_swigt__p_wxSizeEvent,
39013 &_swigt__p_wxSizer,
39014 &_swigt__p_wxSizerItem,
39015 &_swigt__p_wxSound,
39016 &_swigt__p_wxStandardPaths,
39017 &_swigt__p_wxStaticBoxSizer,
39018 &_swigt__p_wxStdDialogButtonSizer,
39019 &_swigt__p_wxStopWatch,
39020 &_swigt__p_wxString,
39021 &_swigt__p_wxSysColourChangedEvent,
39022 &_swigt__p_wxSystemOptions,
39023 &_swigt__p_wxSystemSettings,
39024 &_swigt__p_wxTIFFHandler,
39025 &_swigt__p_wxTextCtrl,
39026 &_swigt__p_wxTextDataObject,
39027 &_swigt__p_wxTimeSpan,
39028 &_swigt__p_wxTimer,
39029 &_swigt__p_wxTimerEvent,
39030 &_swigt__p_wxTimerRunner,
39031 &_swigt__p_wxTipProvider,
39032 &_swigt__p_wxToolTip,
39033 &_swigt__p_wxURLDataObject,
39034 &_swigt__p_wxUpdateUIEvent,
39035 &_swigt__p_wxValidator,
39036 &_swigt__p_wxVideoMode,
39037 &_swigt__p_wxWindow,
39038 &_swigt__p_wxWindowCreateEvent,
39039 &_swigt__p_wxWindowDestroyEvent,
39040 &_swigt__p_wxWindowDisabler,
39041 &_swigt__p_wxXPMHandler,
39042 };
39043
39044 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
39045 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
39046 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
39047 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
39048 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
39049 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
39050 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
39051 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
39052 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
39053 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}};
39054 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
39055 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
39056 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
39057 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
39058 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
39059 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
39060 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
39061 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
39062 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}};
39063 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
39064 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
39065 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
39066 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
39067 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
39068 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}};
39069 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
39070 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}};
39071 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
39072 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
39073 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
39074 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
39075 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
39076 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
39077 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
39078 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
39079 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
39080 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
39081 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
39082 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
39083 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
39084 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
39085 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
39086 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
39087 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
39088 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
39089 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
39090 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39091 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39092 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
39093 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39094 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
39095 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
39096 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
39097 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
39098 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
39099 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
39100 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39101 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39102 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39103 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39104 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
39105 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
39106 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
39107 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
39108 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
39109 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
39110 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
39111 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
39112 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
39113 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
39114 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}};
39115 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
39116 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
39117 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
39118 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
39119 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
39120 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
39121 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}};
39122 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
39123 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
39124 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
39125 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
39126 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
39127 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
39128 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
39129 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
39130 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
39131 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
39132 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
39133 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}};
39134 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
39135 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
39136 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
39137 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
39138 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
39139 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
39140 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
39141 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
39142 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
39143 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
39144 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
39145 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
39146 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
39147 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
39148 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
39149 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
39150 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
39151 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
39152 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
39153 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
39154 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
39155 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
39156 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
39157 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
39158 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
39159 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
39160 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
39161 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
39162 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
39163 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
39164 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
39165 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
39166 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
39167 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
39168 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
39169 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
39170 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
39171 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
39172 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
39173 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
39174 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
39175 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
39176 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}};
39177 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
39178 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
39179 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
39180 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
39181 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
39182 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
39183 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
39184 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
39185 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
39186 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
39187 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}};
39188 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
39189 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
39190 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
39191 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
39192 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
39193 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
39194 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
39195 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
39196 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
39197 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
39198 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
39199 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
39200 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
39201 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
39202 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
39203 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
39204 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
39205 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}};
39206 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
39207 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
39208 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
39209 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
39210 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}};
39211 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
39212 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
39213 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
39214 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}};
39215 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
39216
39217 static swig_cast_info *swig_cast_initial[] = {
39218 _swigc__p_char,
39219 _swigc__p_form_ops_t,
39220 _swigc__p_int,
39221 _swigc__p_unsigned_char,
39222 _swigc__p_unsigned_int,
39223 _swigc__p_unsigned_long,
39224 _swigc__p_void,
39225 _swigc__p_wxANIHandler,
39226 _swigc__p_wxAcceleratorTable,
39227 _swigc__p_wxActivateEvent,
39228 _swigc__p_wxArrayString,
39229 _swigc__p_wxBMPHandler,
39230 _swigc__p_wxBitmap,
39231 _swigc__p_wxBitmapDataObject,
39232 _swigc__p_wxBoxSizer,
39233 _swigc__p_wxBusyCursor,
39234 _swigc__p_wxBusyInfo,
39235 _swigc__p_wxCURHandler,
39236 _swigc__p_wxCaret,
39237 _swigc__p_wxChar,
39238 _swigc__p_wxChildFocusEvent,
39239 _swigc__p_wxClipboard,
39240 _swigc__p_wxClipboardLocker,
39241 _swigc__p_wxClipboardTextEvent,
39242 _swigc__p_wxCloseEvent,
39243 _swigc__p_wxColour,
39244 _swigc__p_wxCommandEvent,
39245 _swigc__p_wxConfig,
39246 _swigc__p_wxConfigBase,
39247 _swigc__p_wxConfigPathChanger,
39248 _swigc__p_wxContextMenuEvent,
39249 _swigc__p_wxControl,
39250 _swigc__p_wxControlWithItems,
39251 _swigc__p_wxCursor,
39252 _swigc__p_wxCustomDataObject,
39253 _swigc__p_wxDC,
39254 _swigc__p_wxDataFormat,
39255 _swigc__p_wxDataObject,
39256 _swigc__p_wxDataObjectComposite,
39257 _swigc__p_wxDataObjectSimple,
39258 _swigc__p_wxDateEvent,
39259 _swigc__p_wxDateSpan,
39260 _swigc__p_wxDateTime,
39261 _swigc__p_wxDateTime__TimeZone,
39262 _swigc__p_wxDisplay,
39263 _swigc__p_wxDisplayChangedEvent,
39264 _swigc__p_wxDropFilesEvent,
39265 _swigc__p_wxDuplexMode,
39266 _swigc__p_wxEraseEvent,
39267 _swigc__p_wxEvent,
39268 _swigc__p_wxEvtHandler,
39269 _swigc__p_wxFSFile,
39270 _swigc__p_wxFileConfig,
39271 _swigc__p_wxFileDataObject,
39272 _swigc__p_wxFileHistory,
39273 _swigc__p_wxFileSystem,
39274 _swigc__p_wxFileType,
39275 _swigc__p_wxFileTypeInfo,
39276 _swigc__p_wxFlexGridSizer,
39277 _swigc__p_wxFocusEvent,
39278 _swigc__p_wxFont,
39279 _swigc__p_wxFrame,
39280 _swigc__p_wxGBSizerItem,
39281 _swigc__p_wxGIFHandler,
39282 _swigc__p_wxGridBagSizer,
39283 _swigc__p_wxGridSizer,
39284 _swigc__p_wxICOHandler,
39285 _swigc__p_wxIcon,
39286 _swigc__p_wxIconizeEvent,
39287 _swigc__p_wxIdleEvent,
39288 _swigc__p_wxImage,
39289 _swigc__p_wxImageHandler,
39290 _swigc__p_wxIndividualLayoutConstraint,
39291 _swigc__p_wxInitDialogEvent,
39292 _swigc__p_wxJPEGHandler,
39293 _swigc__p_wxJoystick,
39294 _swigc__p_wxJoystickEvent,
39295 _swigc__p_wxKeyEvent,
39296 _swigc__p_wxKillError,
39297 _swigc__p_wxLayoutConstraints,
39298 _swigc__p_wxLog,
39299 _swigc__p_wxLogBuffer,
39300 _swigc__p_wxLogChain,
39301 _swigc__p_wxLogGui,
39302 _swigc__p_wxLogNull,
39303 _swigc__p_wxLogStderr,
39304 _swigc__p_wxLogTextCtrl,
39305 _swigc__p_wxLogWindow,
39306 _swigc__p_wxMaximizeEvent,
39307 _swigc__p_wxMenu,
39308 _swigc__p_wxMenuBar,
39309 _swigc__p_wxMenuEvent,
39310 _swigc__p_wxMenuItem,
39311 _swigc__p_wxMetafileDataObject,
39312 _swigc__p_wxMimeTypesManager,
39313 _swigc__p_wxMouseCaptureChangedEvent,
39314 _swigc__p_wxMouseCaptureLostEvent,
39315 _swigc__p_wxMouseEvent,
39316 _swigc__p_wxMouseState,
39317 _swigc__p_wxMoveEvent,
39318 _swigc__p_wxMutexGuiLocker,
39319 _swigc__p_wxNavigationKeyEvent,
39320 _swigc__p_wxNcPaintEvent,
39321 _swigc__p_wxNotifyEvent,
39322 _swigc__p_wxObject,
39323 _swigc__p_wxOutputStream,
39324 _swigc__p_wxPCXHandler,
39325 _swigc__p_wxPNGHandler,
39326 _swigc__p_wxPNMHandler,
39327 _swigc__p_wxPaintEvent,
39328 _swigc__p_wxPaletteChangedEvent,
39329 _swigc__p_wxPaperSize,
39330 _swigc__p_wxPlatformInfo,
39331 _swigc__p_wxPoint,
39332 _swigc__p_wxPowerEvent,
39333 _swigc__p_wxProcessEvent,
39334 _swigc__p_wxPyApp,
39335 _swigc__p_wxPyArtProvider,
39336 _swigc__p_wxPyBitmapDataObject,
39337 _swigc__p_wxPyCommandEvent,
39338 _swigc__p_wxPyDataObjectSimple,
39339 _swigc__p_wxPyDropSource,
39340 _swigc__p_wxPyDropTarget,
39341 _swigc__p_wxPyEvent,
39342 _swigc__p_wxPyFileDropTarget,
39343 _swigc__p_wxPyImageHandler,
39344 _swigc__p_wxPyLog,
39345 _swigc__p_wxPyProcess,
39346 _swigc__p_wxPySizer,
39347 _swigc__p_wxPyTextDataObject,
39348 _swigc__p_wxPyTextDropTarget,
39349 _swigc__p_wxPyTimer,
39350 _swigc__p_wxPyTipProvider,
39351 _swigc__p_wxPyValidator,
39352 _swigc__p_wxQueryNewPaletteEvent,
39353 _swigc__p_wxRect,
39354 _swigc__p_wxScrollEvent,
39355 _swigc__p_wxScrollWinEvent,
39356 _swigc__p_wxSetCursorEvent,
39357 _swigc__p_wxShowEvent,
39358 _swigc__p_wxSingleInstanceChecker,
39359 _swigc__p_wxSize,
39360 _swigc__p_wxSizeEvent,
39361 _swigc__p_wxSizer,
39362 _swigc__p_wxSizerItem,
39363 _swigc__p_wxSound,
39364 _swigc__p_wxStandardPaths,
39365 _swigc__p_wxStaticBoxSizer,
39366 _swigc__p_wxStdDialogButtonSizer,
39367 _swigc__p_wxStopWatch,
39368 _swigc__p_wxString,
39369 _swigc__p_wxSysColourChangedEvent,
39370 _swigc__p_wxSystemOptions,
39371 _swigc__p_wxSystemSettings,
39372 _swigc__p_wxTIFFHandler,
39373 _swigc__p_wxTextCtrl,
39374 _swigc__p_wxTextDataObject,
39375 _swigc__p_wxTimeSpan,
39376 _swigc__p_wxTimer,
39377 _swigc__p_wxTimerEvent,
39378 _swigc__p_wxTimerRunner,
39379 _swigc__p_wxTipProvider,
39380 _swigc__p_wxToolTip,
39381 _swigc__p_wxURLDataObject,
39382 _swigc__p_wxUpdateUIEvent,
39383 _swigc__p_wxValidator,
39384 _swigc__p_wxVideoMode,
39385 _swigc__p_wxWindow,
39386 _swigc__p_wxWindowCreateEvent,
39387 _swigc__p_wxWindowDestroyEvent,
39388 _swigc__p_wxWindowDisabler,
39389 _swigc__p_wxXPMHandler,
39390 };
39391
39392
39393 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
39394
39395 static swig_const_info swig_const_table[] = {
39396 {0, 0, 0, 0.0, 0, 0}};
39397
39398 #ifdef __cplusplus
39399 }
39400 #endif
39401 /* -----------------------------------------------------------------------------
39402 * Type initialization:
39403 * This problem is tough by the requirement that no dynamic
39404 * memory is used. Also, since swig_type_info structures store pointers to
39405 * swig_cast_info structures and swig_cast_info structures store pointers back
39406 * to swig_type_info structures, we need some lookup code at initialization.
39407 * The idea is that swig generates all the structures that are needed.
39408 * The runtime then collects these partially filled structures.
39409 * The SWIG_InitializeModule function takes these initial arrays out of
39410 * swig_module, and does all the lookup, filling in the swig_module.types
39411 * array with the correct data and linking the correct swig_cast_info
39412 * structures together.
39413 *
39414 * The generated swig_type_info structures are assigned staticly to an initial
39415 * array. We just loop though that array, and handle each type individually.
39416 * First we lookup if this type has been already loaded, and if so, use the
39417 * loaded structure instead of the generated one. Then we have to fill in the
39418 * cast linked list. The cast data is initially stored in something like a
39419 * two-dimensional array. Each row corresponds to a type (there are the same
39420 * number of rows as there are in the swig_type_initial array). Each entry in
39421 * a column is one of the swig_cast_info structures for that type.
39422 * The cast_initial array is actually an array of arrays, because each row has
39423 * a variable number of columns. So to actually build the cast linked list,
39424 * we find the array of casts associated with the type, and loop through it
39425 * adding the casts to the list. The one last trick we need to do is making
39426 * sure the type pointer in the swig_cast_info struct is correct.
39427 *
39428 * First off, we lookup the cast->type name to see if it is already loaded.
39429 * There are three cases to handle:
39430 * 1) If the cast->type has already been loaded AND the type we are adding
39431 * casting info to has not been loaded (it is in this module), THEN we
39432 * replace the cast->type pointer with the type pointer that has already
39433 * been loaded.
39434 * 2) If BOTH types (the one we are adding casting info to, and the
39435 * cast->type) are loaded, THEN the cast info has already been loaded by
39436 * the previous module so we just ignore it.
39437 * 3) Finally, if cast->type has not already been loaded, then we add that
39438 * swig_cast_info to the linked list (because the cast->type) pointer will
39439 * be correct.
39440 * ----------------------------------------------------------------------------- */
39441
39442 #ifdef __cplusplus
39443 extern "C" {
39444 #if 0
39445 } /* c-mode */
39446 #endif
39447 #endif
39448
39449 #if 0
39450 #define SWIGRUNTIME_DEBUG
39451 #endif
39452
39453 SWIGRUNTIME void
39454 SWIG_InitializeModule(void *clientdata) {
39455 size_t i;
39456 swig_module_info *module_head;
39457 static int init_run = 0;
39458
39459 clientdata = clientdata;
39460
39461 if (init_run) return;
39462 init_run = 1;
39463
39464 /* Initialize the swig_module */
39465 swig_module.type_initial = swig_type_initial;
39466 swig_module.cast_initial = swig_cast_initial;
39467
39468 /* Try and load any already created modules */
39469 module_head = SWIG_GetModule(clientdata);
39470 if (module_head) {
39471 swig_module.next = module_head->next;
39472 module_head->next = &swig_module;
39473 } else {
39474 /* This is the first module loaded */
39475 swig_module.next = &swig_module;
39476 SWIG_SetModule(clientdata, &swig_module);
39477 }
39478
39479 /* Now work on filling in swig_module.types */
39480 #ifdef SWIGRUNTIME_DEBUG
39481 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
39482 #endif
39483 for (i = 0; i < swig_module.size; ++i) {
39484 swig_type_info *type = 0;
39485 swig_type_info *ret;
39486 swig_cast_info *cast;
39487
39488 #ifdef SWIGRUNTIME_DEBUG
39489 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39490 #endif
39491
39492 /* if there is another module already loaded */
39493 if (swig_module.next != &swig_module) {
39494 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
39495 }
39496 if (type) {
39497 /* Overwrite clientdata field */
39498 #ifdef SWIGRUNTIME_DEBUG
39499 printf("SWIG_InitializeModule: found type %s\n", type->name);
39500 #endif
39501 if (swig_module.type_initial[i]->clientdata) {
39502 type->clientdata = swig_module.type_initial[i]->clientdata;
39503 #ifdef SWIGRUNTIME_DEBUG
39504 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
39505 #endif
39506 }
39507 } else {
39508 type = swig_module.type_initial[i];
39509 }
39510
39511 /* Insert casting types */
39512 cast = swig_module.cast_initial[i];
39513 while (cast->type) {
39514 /* Don't need to add information already in the list */
39515 ret = 0;
39516 #ifdef SWIGRUNTIME_DEBUG
39517 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
39518 #endif
39519 if (swig_module.next != &swig_module) {
39520 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
39521 #ifdef SWIGRUNTIME_DEBUG
39522 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
39523 #endif
39524 }
39525 if (ret) {
39526 if (type == swig_module.type_initial[i]) {
39527 #ifdef SWIGRUNTIME_DEBUG
39528 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
39529 #endif
39530 cast->type = ret;
39531 ret = 0;
39532 } else {
39533 /* Check for casting already in the list */
39534 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
39535 #ifdef SWIGRUNTIME_DEBUG
39536 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
39537 #endif
39538 if (!ocast) ret = 0;
39539 }
39540 }
39541
39542 if (!ret) {
39543 #ifdef SWIGRUNTIME_DEBUG
39544 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
39545 #endif
39546 if (type->cast) {
39547 type->cast->prev = cast;
39548 cast->next = type->cast;
39549 }
39550 type->cast = cast;
39551 }
39552 cast++;
39553 }
39554 /* Set entry in modules->types array equal to the type */
39555 swig_module.types[i] = type;
39556 }
39557 swig_module.types[i] = 0;
39558
39559 #ifdef SWIGRUNTIME_DEBUG
39560 printf("**** SWIG_InitializeModule: Cast List ******\n");
39561 for (i = 0; i < swig_module.size; ++i) {
39562 int j = 0;
39563 swig_cast_info *cast = swig_module.cast_initial[i];
39564 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39565 while (cast->type) {
39566 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
39567 cast++;
39568 ++j;
39569 }
39570 printf("---- Total casts: %d\n",j);
39571 }
39572 printf("**** SWIG_InitializeModule: Cast List ******\n");
39573 #endif
39574 }
39575
39576 /* This function will propagate the clientdata field of type to
39577 * any new swig_type_info structures that have been added into the list
39578 * of equivalent types. It is like calling
39579 * SWIG_TypeClientData(type, clientdata) a second time.
39580 */
39581 SWIGRUNTIME void
39582 SWIG_PropagateClientData(void) {
39583 size_t i;
39584 swig_cast_info *equiv;
39585 static int init_run = 0;
39586
39587 if (init_run) return;
39588 init_run = 1;
39589
39590 for (i = 0; i < swig_module.size; i++) {
39591 if (swig_module.types[i]->clientdata) {
39592 equiv = swig_module.types[i]->cast;
39593 while (equiv) {
39594 if (!equiv->converter) {
39595 if (equiv->type && !equiv->type->clientdata)
39596 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
39597 }
39598 equiv = equiv->next;
39599 }
39600 }
39601 }
39602 }
39603
39604 #ifdef __cplusplus
39605 #if 0
39606 {
39607 /* c-mode */
39608 #endif
39609 }
39610 #endif
39611
39612
39613
39614 #ifdef __cplusplus
39615 extern "C" {
39616 #endif
39617
39618 /* Python-specific SWIG API */
39619 #define SWIG_newvarlink() SWIG_Python_newvarlink()
39620 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
39621 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
39622
39623 /* -----------------------------------------------------------------------------
39624 * global variable support code.
39625 * ----------------------------------------------------------------------------- */
39626
39627 typedef struct swig_globalvar {
39628 char *name; /* Name of global variable */
39629 PyObject *(*get_attr)(void); /* Return the current value */
39630 int (*set_attr)(PyObject *); /* Set the value */
39631 struct swig_globalvar *next;
39632 } swig_globalvar;
39633
39634 typedef struct swig_varlinkobject {
39635 PyObject_HEAD
39636 swig_globalvar *vars;
39637 } swig_varlinkobject;
39638
39639 SWIGINTERN PyObject *
39640 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
39641 return PyString_FromString("<Swig global variables>");
39642 }
39643
39644 SWIGINTERN PyObject *
39645 swig_varlink_str(swig_varlinkobject *v) {
39646 PyObject *str = PyString_FromString("(");
39647 swig_globalvar *var;
39648 for (var = v->vars; var; var=var->next) {
39649 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
39650 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
39651 }
39652 PyString_ConcatAndDel(&str,PyString_FromString(")"));
39653 return str;
39654 }
39655
39656 SWIGINTERN int
39657 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
39658 PyObject *str = swig_varlink_str(v);
39659 fprintf(fp,"Swig global variables ");
39660 fprintf(fp,"%s\n", PyString_AsString(str));
39661 Py_DECREF(str);
39662 return 0;
39663 }
39664
39665 SWIGINTERN void
39666 swig_varlink_dealloc(swig_varlinkobject *v) {
39667 swig_globalvar *var = v->vars;
39668 while (var) {
39669 swig_globalvar *n = var->next;
39670 free(var->name);
39671 free(var);
39672 var = n;
39673 }
39674 }
39675
39676 SWIGINTERN PyObject *
39677 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
39678 PyObject *res = NULL;
39679 swig_globalvar *var = v->vars;
39680 while (var) {
39681 if (strcmp(var->name,n) == 0) {
39682 res = (*var->get_attr)();
39683 break;
39684 }
39685 var = var->next;
39686 }
39687 if (res == NULL && !PyErr_Occurred()) {
39688 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39689 }
39690 return res;
39691 }
39692
39693 SWIGINTERN int
39694 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
39695 int res = 1;
39696 swig_globalvar *var = v->vars;
39697 while (var) {
39698 if (strcmp(var->name,n) == 0) {
39699 res = (*var->set_attr)(p);
39700 break;
39701 }
39702 var = var->next;
39703 }
39704 if (res == 1 && !PyErr_Occurred()) {
39705 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39706 }
39707 return res;
39708 }
39709
39710 SWIGINTERN PyTypeObject*
39711 swig_varlink_type(void) {
39712 static char varlink__doc__[] = "Swig var link object";
39713 static PyTypeObject varlink_type;
39714 static int type_init = 0;
39715 if (!type_init) {
39716 const PyTypeObject tmp
39717 = {
39718 PyObject_HEAD_INIT(NULL)
39719 0, /* Number of items in variable part (ob_size) */
39720 (char *)"swigvarlink", /* Type name (tp_name) */
39721 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
39722 0, /* Itemsize (tp_itemsize) */
39723 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
39724 (printfunc) swig_varlink_print, /* Print (tp_print) */
39725 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
39726 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
39727 0, /* tp_compare */
39728 (reprfunc) swig_varlink_repr, /* tp_repr */
39729 0, /* tp_as_number */
39730 0, /* tp_as_sequence */
39731 0, /* tp_as_mapping */
39732 0, /* tp_hash */
39733 0, /* tp_call */
39734 (reprfunc)swig_varlink_str, /* tp_str */
39735 0, /* tp_getattro */
39736 0, /* tp_setattro */
39737 0, /* tp_as_buffer */
39738 0, /* tp_flags */
39739 varlink__doc__, /* tp_doc */
39740 0, /* tp_traverse */
39741 0, /* tp_clear */
39742 0, /* tp_richcompare */
39743 0, /* tp_weaklistoffset */
39744 #if PY_VERSION_HEX >= 0x02020000
39745 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
39746 #endif
39747 #if PY_VERSION_HEX >= 0x02030000
39748 0, /* tp_del */
39749 #endif
39750 #ifdef COUNT_ALLOCS
39751 0,0,0,0 /* tp_alloc -> tp_next */
39752 #endif
39753 };
39754 varlink_type = tmp;
39755 varlink_type.ob_type = &PyType_Type;
39756 type_init = 1;
39757 }
39758 return &varlink_type;
39759 }
39760
39761 /* Create a variable linking object for use later */
39762 SWIGINTERN PyObject *
39763 SWIG_Python_newvarlink(void) {
39764 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
39765 if (result) {
39766 result->vars = 0;
39767 }
39768 return ((PyObject*) result);
39769 }
39770
39771 SWIGINTERN void
39772 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
39773 swig_varlinkobject *v = (swig_varlinkobject *) p;
39774 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
39775 if (gv) {
39776 size_t size = strlen(name)+1;
39777 gv->name = (char *)malloc(size);
39778 if (gv->name) {
39779 strncpy(gv->name,name,size);
39780 gv->get_attr = get_attr;
39781 gv->set_attr = set_attr;
39782 gv->next = v->vars;
39783 }
39784 }
39785 v->vars = gv;
39786 }
39787
39788 SWIGINTERN PyObject *
39789 SWIG_globals() {
39790 static PyObject *_SWIG_globals = 0;
39791 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
39792 return _SWIG_globals;
39793 }
39794
39795 /* -----------------------------------------------------------------------------
39796 * constants/methods manipulation
39797 * ----------------------------------------------------------------------------- */
39798
39799 /* Install Constants */
39800 SWIGINTERN void
39801 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
39802 PyObject *obj = 0;
39803 size_t i;
39804 for (i = 0; constants[i].type; ++i) {
39805 switch(constants[i].type) {
39806 case SWIG_PY_POINTER:
39807 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
39808 break;
39809 case SWIG_PY_BINARY:
39810 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
39811 break;
39812 default:
39813 obj = 0;
39814 break;
39815 }
39816 if (obj) {
39817 PyDict_SetItemString(d, constants[i].name, obj);
39818 Py_DECREF(obj);
39819 }
39820 }
39821 }
39822
39823 /* -----------------------------------------------------------------------------*/
39824 /* Fix SwigMethods to carry the callback ptrs when needed */
39825 /* -----------------------------------------------------------------------------*/
39826
39827 SWIGINTERN void
39828 SWIG_Python_FixMethods(PyMethodDef *methods,
39829 swig_const_info *const_table,
39830 swig_type_info **types,
39831 swig_type_info **types_initial) {
39832 size_t i;
39833 for (i = 0; methods[i].ml_name; ++i) {
39834 const char *c = methods[i].ml_doc;
39835 if (c && (c = strstr(c, "swig_ptr: "))) {
39836 int j;
39837 swig_const_info *ci = 0;
39838 const char *name = c + 10;
39839 for (j = 0; const_table[j].type; ++j) {
39840 if (strncmp(const_table[j].name, name,
39841 strlen(const_table[j].name)) == 0) {
39842 ci = &(const_table[j]);
39843 break;
39844 }
39845 }
39846 if (ci) {
39847 size_t shift = (ci->ptype) - types;
39848 swig_type_info *ty = types_initial[shift];
39849 size_t ldoc = (c - methods[i].ml_doc);
39850 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
39851 char *ndoc = (char*)malloc(ldoc + lptr + 10);
39852 if (ndoc) {
39853 char *buff = ndoc;
39854 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
39855 if (ptr) {
39856 strncpy(buff, methods[i].ml_doc, ldoc);
39857 buff += ldoc;
39858 strncpy(buff, "swig_ptr: ", 10);
39859 buff += 10;
39860 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
39861 methods[i].ml_doc = ndoc;
39862 }
39863 }
39864 }
39865 }
39866 }
39867 }
39868
39869 #ifdef __cplusplus
39870 }
39871 #endif
39872
39873 /* -----------------------------------------------------------------------------*
39874 * Partial Init method
39875 * -----------------------------------------------------------------------------*/
39876
39877 #ifdef __cplusplus
39878 extern "C"
39879 #endif
39880 SWIGEXPORT void SWIG_init(void) {
39881 PyObject *m, *d;
39882
39883 /* Fix SwigMethods to carry the callback ptrs when needed */
39884 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
39885
39886 m = Py_InitModule((char *) SWIG_name, SwigMethods);
39887 d = PyModule_GetDict(m);
39888
39889 SWIG_InitializeModule(0);
39890 SWIG_InstallConstants(d,swig_const_table);
39891
39892
39893 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
39894 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
39895 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
39896 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
39897 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
39898 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
39899 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
39900 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
39901 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
39902 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
39903 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
39904 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
39905 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
39906 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
39907 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
39908 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
39909 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
39910 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
39911 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
39912 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
39913 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
39914 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
39915 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
39916 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
39917 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
39918 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
39919 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
39920 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
39921 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
39922 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
39923 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
39924 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
39925 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
39926 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
39927 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
39928 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
39929 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
39930 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
39931 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
39932 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
39933 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
39934 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
39935 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
39936 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
39937 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
39938 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
39939 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
39940 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
39941 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
39942 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
39943 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
39944 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
39945 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
39946 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
39947 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
39948 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
39949 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
39950 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
39951 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
39952 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
39953 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
39954 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
39955 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
39956 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
39957 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
39958 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
39959 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
39960 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
39961 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
39962 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
39963 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
39964 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
39965 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
39966 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
39967 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
39968 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
39969 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
39970 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
39971 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
39972 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
39973 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
39974 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
39975 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
39976 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
39977 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
39978 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
39979 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
39980 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
39981 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
39982 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
39983 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
39984 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
39985 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
39986 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
39987 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
39988 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
39989 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
39990 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
39991 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
39992 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
39993 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
39994 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
39995 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
39996 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
39997 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
39998 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
39999 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
40000 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
40001 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
40002 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
40003 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
40004 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
40005 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
40006 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
40007 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
40008 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
40009 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
40010 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
40011 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
40012 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
40013 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
40014 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
40015 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
40016 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
40017 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
40018 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
40019 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
40020 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
40021 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
40022 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
40023 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
40024 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
40025 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
40026 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
40027 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
40028 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
40029 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
40030 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
40031 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
40032 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
40033 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
40034 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
40035 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
40036 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
40037
40038 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
40039
40040 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
40041 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
40042 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
40043 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
40044 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
40045 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
40046 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
40047 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
40048 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
40049 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
40050 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
40051 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
40052 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
40053 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
40054 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
40055 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
40056 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
40057 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
40058 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
40059 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
40060 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
40061 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
40062 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
40063 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
40064 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
40065 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
40066 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
40067 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
40068 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
40069 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
40070 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
40071 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
40072 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
40073 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
40074 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
40075 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
40076 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
40077 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
40078 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
40079 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
40080 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
40081 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
40082 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
40083 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
40084 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
40085 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
40086 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
40087 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
40088 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
40089 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
40090 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
40091 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
40092 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
40093
40094 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
40095
40096 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
40097 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
40098 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
40099 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
40100 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
40101 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
40102 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
40103 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
40104 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
40105 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
40106 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
40107 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
40108 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
40109 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
40110 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
40111 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
40112 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
40113 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
40114 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
40115 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
40116 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
40117 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
40118 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
40119 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
40120 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
40121 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
40122 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
40123 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
40124 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
40125 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
40126 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
40127 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
40128 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
40129 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
40130 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
40131 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
40132 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
40133 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
40134 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
40135 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
40136 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
40137 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
40138 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
40139 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
40140 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
40141 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
40142 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
40143 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
40144 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
40145 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
40146 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
40147 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
40148 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
40149 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
40150 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
40151 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
40152 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
40153 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
40154 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
40155 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
40156 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
40157 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
40158 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
40159 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
40160 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
40161 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
40162 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
40163 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
40164 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
40165 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
40166 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
40167 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
40168 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
40169 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
40170 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
40171 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
40172
40173 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
40174
40175 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
40176 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
40177 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
40178 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
40179 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
40180 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
40181 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
40182 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
40183 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
40184 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
40185 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
40186 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
40187 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
40188 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
40189 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
40190 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
40191 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
40192 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
40193 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
40194 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
40195 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
40196 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
40197 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
40198 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
40199 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
40200 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
40201 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
40202 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
40203 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
40204 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
40205 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
40206 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
40207 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
40208 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
40209 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
40210 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
40211 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
40212 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
40213 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
40214 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
40215 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
40216 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
40217 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
40218 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
40219 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
40220 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
40221 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
40222 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
40223 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
40224 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
40225 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
40226 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
40227 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
40228 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
40229 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
40230 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
40231 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
40232 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
40233 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
40234 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
40235 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
40236 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
40237 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
40238 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
40239 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
40240 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
40241 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
40242 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
40243 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
40244 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
40245 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
40246 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
40247 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
40248 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
40249 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
40250 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
40251 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
40252 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
40253 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
40254 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
40255 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
40256 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
40257 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
40258 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
40259 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
40260 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
40261 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
40262 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
40263 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
40264 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
40265 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
40266 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
40267 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
40268 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
40269 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
40270 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
40271 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
40272 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
40273 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
40274 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
40275 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
40276 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
40277 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
40278 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
40279 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
40280 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
40281 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
40282 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
40283 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
40284 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
40285 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
40286 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
40287 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
40288 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
40289 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
40290 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
40291 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
40292 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
40293 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
40294 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
40295 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
40296 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
40297 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
40298 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
40299 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
40300 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
40301 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
40302 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
40303 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
40304 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
40305 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
40306 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
40307 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
40308 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
40309 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
40310 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
40311 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
40312 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
40313 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
40314 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
40315 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
40316 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
40317 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
40318 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
40319 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
40320 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
40321 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
40322 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
40323 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
40324 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
40325 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
40326 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
40327 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
40328 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
40329 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
40330 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
40331 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
40332 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
40333 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
40334 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
40335 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
40336 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
40337 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
40338 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
40339 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
40340 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
40341 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
40342 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
40343 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
40344 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
40345 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
40346 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
40347 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
40348 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
40349 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
40350 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
40351 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
40352 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
40353 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
40354 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
40355 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
40356 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
40357 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
40358 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
40359 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
40360 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
40361 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
40362 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
40363 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
40364 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
40365 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
40366 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
40367 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
40368 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
40369 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
40370 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
40371 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
40372 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
40373 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
40374 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
40375
40376 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
40377 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
40378 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
40379 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
40380
40381 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
40382 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
40383 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
40384 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
40385 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
40386 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
40387 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
40388 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
40389 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
40390 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
40391 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
40392 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
40393 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
40394 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
40395 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
40396 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
40397 }
40398
wxWidgets (Impactor)