]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
AUI updates
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAboutDialogInfo swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorTable swig_types[9]
2476 #define SWIGTYPE_p_wxActivateEvent swig_types[10]
2477 #define SWIGTYPE_p_wxArrayString swig_types[11]
2478 #define SWIGTYPE_p_wxBMPHandler swig_types[12]
2479 #define SWIGTYPE_p_wxBitmap swig_types[13]
2480 #define SWIGTYPE_p_wxBitmapDataObject swig_types[14]
2481 #define SWIGTYPE_p_wxBoxSizer swig_types[15]
2482 #define SWIGTYPE_p_wxBusyCursor swig_types[16]
2483 #define SWIGTYPE_p_wxBusyInfo swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChar swig_types[20]
2487 #define SWIGTYPE_p_wxChildFocusEvent swig_types[21]
2488 #define SWIGTYPE_p_wxClipboard swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
2490 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[24]
2491 #define SWIGTYPE_p_wxCloseEvent swig_types[25]
2492 #define SWIGTYPE_p_wxColour swig_types[26]
2493 #define SWIGTYPE_p_wxCommandEvent swig_types[27]
2494 #define SWIGTYPE_p_wxConfig swig_types[28]
2495 #define SWIGTYPE_p_wxConfigBase swig_types[29]
2496 #define SWIGTYPE_p_wxConfigPathChanger swig_types[30]
2497 #define SWIGTYPE_p_wxContextMenuEvent swig_types[31]
2498 #define SWIGTYPE_p_wxControl swig_types[32]
2499 #define SWIGTYPE_p_wxControlWithItems swig_types[33]
2500 #define SWIGTYPE_p_wxCursor swig_types[34]
2501 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
2502 #define SWIGTYPE_p_wxDC swig_types[36]
2503 #define SWIGTYPE_p_wxDataFormat swig_types[37]
2504 #define SWIGTYPE_p_wxDataObject swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectComposite swig_types[39]
2506 #define SWIGTYPE_p_wxDataObjectSimple swig_types[40]
2507 #define SWIGTYPE_p_wxDateEvent swig_types[41]
2508 #define SWIGTYPE_p_wxDateSpan swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime swig_types[43]
2510 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[44]
2511 #define SWIGTYPE_p_wxDisplay swig_types[45]
2512 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDropFilesEvent swig_types[47]
2514 #define SWIGTYPE_p_wxDuplexMode swig_types[48]
2515 #define SWIGTYPE_p_wxEraseEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvent swig_types[50]
2517 #define SWIGTYPE_p_wxEvtHandler swig_types[51]
2518 #define SWIGTYPE_p_wxFSFile swig_types[52]
2519 #define SWIGTYPE_p_wxFileConfig swig_types[53]
2520 #define SWIGTYPE_p_wxFileDataObject swig_types[54]
2521 #define SWIGTYPE_p_wxFileHistory swig_types[55]
2522 #define SWIGTYPE_p_wxFileSystem swig_types[56]
2523 #define SWIGTYPE_p_wxFileType swig_types[57]
2524 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
2525 #define SWIGTYPE_p_wxFlexGridSizer swig_types[59]
2526 #define SWIGTYPE_p_wxFocusEvent swig_types[60]
2527 #define SWIGTYPE_p_wxFont swig_types[61]
2528 #define SWIGTYPE_p_wxFrame swig_types[62]
2529 #define SWIGTYPE_p_wxGBSizerItem swig_types[63]
2530 #define SWIGTYPE_p_wxGIFHandler swig_types[64]
2531 #define SWIGTYPE_p_wxGridBagSizer swig_types[65]
2532 #define SWIGTYPE_p_wxGridSizer swig_types[66]
2533 #define SWIGTYPE_p_wxICOHandler swig_types[67]
2534 #define SWIGTYPE_p_wxIcon swig_types[68]
2535 #define SWIGTYPE_p_wxIconizeEvent swig_types[69]
2536 #define SWIGTYPE_p_wxIdleEvent swig_types[70]
2537 #define SWIGTYPE_p_wxImage swig_types[71]
2538 #define SWIGTYPE_p_wxImageHandler swig_types[72]
2539 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[73]
2540 #define SWIGTYPE_p_wxInitDialogEvent swig_types[74]
2541 #define SWIGTYPE_p_wxJPEGHandler swig_types[75]
2542 #define SWIGTYPE_p_wxJoystick swig_types[76]
2543 #define SWIGTYPE_p_wxJoystickEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKeyEvent swig_types[78]
2545 #define SWIGTYPE_p_wxKillError swig_types[79]
2546 #define SWIGTYPE_p_wxLayoutConstraints swig_types[80]
2547 #define SWIGTYPE_p_wxLog swig_types[81]
2548 #define SWIGTYPE_p_wxLogBuffer swig_types[82]
2549 #define SWIGTYPE_p_wxLogChain swig_types[83]
2550 #define SWIGTYPE_p_wxLogGui swig_types[84]
2551 #define SWIGTYPE_p_wxLogNull swig_types[85]
2552 #define SWIGTYPE_p_wxLogStderr swig_types[86]
2553 #define SWIGTYPE_p_wxLogTextCtrl swig_types[87]
2554 #define SWIGTYPE_p_wxLogWindow swig_types[88]
2555 #define SWIGTYPE_p_wxMaximizeEvent swig_types[89]
2556 #define SWIGTYPE_p_wxMenu swig_types[90]
2557 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2558 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2559 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2560 #define SWIGTYPE_p_wxMetafile swig_types[94]
2561 #define SWIGTYPE_p_wxMetafileDataObject swig_types[95]
2562 #define SWIGTYPE_p_wxMimeTypesManager swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMouseState swig_types[100]
2567 #define SWIGTYPE_p_wxMoveEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[102]
2569 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNcPaintEvent swig_types[104]
2571 #define SWIGTYPE_p_wxNotifyEvent swig_types[105]
2572 #define SWIGTYPE_p_wxObject swig_types[106]
2573 #define SWIGTYPE_p_wxOutputStream swig_types[107]
2574 #define SWIGTYPE_p_wxPCXHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNGHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPNMHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPaintEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[112]
2579 #define SWIGTYPE_p_wxPaperSize swig_types[113]
2580 #define SWIGTYPE_p_wxPlatformInfo swig_types[114]
2581 #define SWIGTYPE_p_wxPoint swig_types[115]
2582 #define SWIGTYPE_p_wxPowerEvent swig_types[116]
2583 #define SWIGTYPE_p_wxProcessEvent swig_types[117]
2584 #define SWIGTYPE_p_wxPyApp swig_types[118]
2585 #define SWIGTYPE_p_wxPyArtProvider swig_types[119]
2586 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[120]
2587 #define SWIGTYPE_p_wxPyCommandEvent swig_types[121]
2588 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropSource swig_types[123]
2590 #define SWIGTYPE_p_wxPyDropTarget swig_types[124]
2591 #define SWIGTYPE_p_wxPyEvent swig_types[125]
2592 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[126]
2593 #define SWIGTYPE_p_wxPyImageHandler swig_types[127]
2594 #define SWIGTYPE_p_wxPyLog swig_types[128]
2595 #define SWIGTYPE_p_wxPyProcess swig_types[129]
2596 #define SWIGTYPE_p_wxPySizer swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDataObject swig_types[131]
2598 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[132]
2599 #define SWIGTYPE_p_wxPyTimer swig_types[133]
2600 #define SWIGTYPE_p_wxPyTipProvider swig_types[134]
2601 #define SWIGTYPE_p_wxPyValidator swig_types[135]
2602 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[136]
2603 #define SWIGTYPE_p_wxRect swig_types[137]
2604 #define SWIGTYPE_p_wxScrollEvent swig_types[138]
2605 #define SWIGTYPE_p_wxScrollWinEvent swig_types[139]
2606 #define SWIGTYPE_p_wxSetCursorEvent swig_types[140]
2607 #define SWIGTYPE_p_wxShowEvent swig_types[141]
2608 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[142]
2609 #define SWIGTYPE_p_wxSize swig_types[143]
2610 #define SWIGTYPE_p_wxSizeEvent swig_types[144]
2611 #define SWIGTYPE_p_wxSizer swig_types[145]
2612 #define SWIGTYPE_p_wxSizerItem swig_types[146]
2613 #define SWIGTYPE_p_wxSound swig_types[147]
2614 #define SWIGTYPE_p_wxStandardPaths swig_types[148]
2615 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[150]
2617 #define SWIGTYPE_p_wxStopWatch swig_types[151]
2618 #define SWIGTYPE_p_wxString swig_types[152]
2619 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[153]
2620 #define SWIGTYPE_p_wxSystemOptions swig_types[154]
2621 #define SWIGTYPE_p_wxSystemSettings swig_types[155]
2622 #define SWIGTYPE_p_wxTGAHandler swig_types[156]
2623 #define SWIGTYPE_p_wxTIFFHandler swig_types[157]
2624 #define SWIGTYPE_p_wxTextCtrl swig_types[158]
2625 #define SWIGTYPE_p_wxTextDataObject swig_types[159]
2626 #define SWIGTYPE_p_wxTimeSpan swig_types[160]
2627 #define SWIGTYPE_p_wxTimer swig_types[161]
2628 #define SWIGTYPE_p_wxTimerEvent swig_types[162]
2629 #define SWIGTYPE_p_wxTimerRunner swig_types[163]
2630 #define SWIGTYPE_p_wxTipProvider swig_types[164]
2631 #define SWIGTYPE_p_wxToolTip swig_types[165]
2632 #define SWIGTYPE_p_wxURLDataObject swig_types[166]
2633 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[167]
2634 #define SWIGTYPE_p_wxValidator swig_types[168]
2635 #define SWIGTYPE_p_wxVideoMode swig_types[169]
2636 #define SWIGTYPE_p_wxWindow swig_types[170]
2637 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[171]
2638 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[172]
2639 #define SWIGTYPE_p_wxWindowDisabler swig_types[173]
2640 #define SWIGTYPE_p_wxXPMHandler swig_types[174]
2641 static swig_type_info *swig_types[176];
2642 static swig_module_info swig_module = {swig_types, 175, 0, 0, 0, 0};
2643 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2644 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2645
2646 /* -------- TYPES TABLE (END) -------- */
2647
2648 #if (PY_VERSION_HEX <= 0x02000000)
2649 # if !defined(SWIG_PYTHON_CLASSIC)
2650 # error "This python version requires to use swig with the '-classic' option"
2651 # endif
2652 #endif
2653 #if (PY_VERSION_HEX <= 0x02020000)
2654 # error "This python version requires to use swig with the '-nomodern' option"
2655 #endif
2656 #if (PY_VERSION_HEX <= 0x02020000)
2657 # error "This python version requires to use swig with the '-nomodernargs' option"
2658 #endif
2659 #ifndef METH_O
2660 # error "This python version requires to use swig with the '-nofastunpack' option"
2661 #endif
2662
2663 /*-----------------------------------------------
2664 @(target):= _misc_.so
2665 ------------------------------------------------*/
2666 #define SWIG_init init_misc_
2667
2668 #define SWIG_name "_misc_"
2669
2670 #define SWIGVERSION 0x010329
2671
2672
2673 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2674 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2675
2676
2677 #include <stdexcept>
2678
2679
2680 namespace swig {
2681 class PyObject_ptr {
2682 protected:
2683 PyObject *_obj;
2684
2685 public:
2686 PyObject_ptr() :_obj(0)
2687 {
2688 }
2689
2690 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2691 {
2692 Py_XINCREF(_obj);
2693 }
2694
2695 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2696 {
2697 if (initial_ref) Py_XINCREF(_obj);
2698 }
2699
2700 PyObject_ptr & operator=(const PyObject_ptr& item)
2701 {
2702 Py_XINCREF(item._obj);
2703 Py_XDECREF(_obj);
2704 _obj = item._obj;
2705 return *this;
2706 }
2707
2708 ~PyObject_ptr()
2709 {
2710 Py_XDECREF(_obj);
2711 }
2712
2713 operator PyObject *() const
2714 {
2715 return _obj;
2716 }
2717
2718 PyObject *operator->() const
2719 {
2720 return _obj;
2721 }
2722 };
2723 }
2724
2725
2726 namespace swig {
2727 struct PyObject_var : PyObject_ptr {
2728 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2729
2730 PyObject_var & operator = (PyObject* obj)
2731 {
2732 Py_XDECREF(_obj);
2733 _obj = obj;
2734 return *this;
2735 }
2736 };
2737 }
2738
2739
2740 #include "wx/wxPython/wxPython.h"
2741 #include "wx/wxPython/pyclasses.h"
2742 #include "wx/wxPython/pyistream.h"
2743
2744 static const wxString wxPyEmptyString(wxEmptyString);
2745
2746
2747
2748 #define SWIG_From_long PyInt_FromLong
2749
2750
2751 SWIGINTERNINLINE PyObject *
2752 SWIG_From_int (int value)
2753 {
2754 return SWIG_From_long (value);
2755 }
2756
2757
2758 #include <limits.h>
2759 #ifndef LLONG_MIN
2760 # define LLONG_MIN LONG_LONG_MIN
2761 #endif
2762 #ifndef LLONG_MAX
2763 # define LLONG_MAX LONG_LONG_MAX
2764 #endif
2765 #ifndef ULLONG_MAX
2766 # define ULLONG_MAX ULONG_LONG_MAX
2767 #endif
2768
2769
2770 SWIGINTERN int
2771 SWIG_AsVal_long (PyObject* obj, long* val)
2772 {
2773 if (PyNumber_Check(obj)) {
2774 if (val) *val = PyInt_AsLong(obj);
2775 return SWIG_OK;
2776 }
2777 return SWIG_TypeError;
2778 }
2779
2780
2781 SWIGINTERN int
2782 SWIG_AsVal_int (PyObject * obj, int *val)
2783 {
2784 long v;
2785 int res = SWIG_AsVal_long (obj, &v);
2786 if (SWIG_IsOK(res)) {
2787 if ((v < INT_MIN || v > INT_MAX)) {
2788 return SWIG_OverflowError;
2789 } else {
2790 if (val) *val = static_cast< int >(v);
2791 }
2792 }
2793 return res;
2794 }
2795
2796 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2797
2798 #include <wx/stockitem.h>
2799
2800 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2801 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2802 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2803
2804 SWIGINTERN int
2805 SWIG_AsVal_bool (PyObject *obj, bool *val)
2806 {
2807 if (obj == Py_True) {
2808 if (val) *val = true;
2809 return SWIG_OK;
2810 } else if (obj == Py_False) {
2811 if (val) *val = false;
2812 return SWIG_OK;
2813 } else {
2814 long v = 0;
2815 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2816 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2817 return res;
2818 }
2819 }
2820
2821
2822 SWIGINTERN int
2823 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2824 {
2825 long v = 0;
2826 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2827 return SWIG_TypeError;
2828 }
2829 else if (val)
2830 *val = (unsigned long)v;
2831 return SWIG_OK;
2832 }
2833
2834
2835 SWIGINTERNINLINE PyObject*
2836 SWIG_From_unsigned_SS_long (unsigned long value)
2837 {
2838 return (value > LONG_MAX) ?
2839 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2840 }
2841
2842
2843 void* wxGetXDisplay()
2844 {
2845 #ifdef __WXGTK__
2846 return wxGetDisplay();
2847 #else
2848 return NULL;
2849 #endif
2850 }
2851
2852
2853 wxWindow* FindWindowAtPointer() {
2854 wxPoint unused;
2855 return wxFindWindowAtPointer(unused);
2856 }
2857
2858
2859 bool wxThread_IsMain() {
2860 #ifdef WXP_WITH_THREAD
2861 return wxThread::IsMain();
2862 #else
2863 return true;
2864 #endif
2865 }
2866
2867 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2868 delete self;
2869 }
2870
2871 #include <wx/snglinst.h>
2872
2873
2874 #ifdef __WXMSW__
2875 #include <wx/msw/private.h>
2876 #include <wx/dynload.h>
2877 #endif
2878
2879
2880
2881 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2882 #if 0
2883 , int method
2884 #endif
2885 )
2886 {
2887 #ifdef __WXMSW__
2888 #if 0
2889 switch (method)
2890 {
2891 case 1:
2892 // This one only partially works. Appears to be an undocumented
2893 // "standard" convention that not all widgets adhear to. For
2894 // example, for some widgets backgrounds or non-client areas may
2895 // not be painted.
2896 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2897 break;
2898
2899 case 2:
2900 #endif
2901 // This one works much better, nearly all widgets and their
2902 // children are captured correctly[**]. Prior to the big
2903 // background erase changes that Vadim did in 2004-2005 this
2904 // method failed badly on XP with Themes activated, most native
2905 // widgets draw only partially, if at all. Without themes it
2906 // worked just like on Win2k. After those changes this method
2907 // works very well.
2908 //
2909 // ** For example the radio buttons in a wxRadioBox are not its
2910 // children by default, but you can capture it via the panel
2911 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2912 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2913 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2914 PRF_ERASEBKGND | PRF_OWNED );
2915 return true;
2916 #if 0
2917 break;
2918
2919 case 3:
2920 // This one is only defined in the latest SDK and is only
2921 // available on XP. MSDN says it is similar to sending WM_PRINT
2922 // so I expect that it will work similar to the above. Since it
2923 // is avaialble only on XP, it can't be compiled like this and
2924 // will have to be loaded dynamically.
2925 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2926
2927 // fall through
2928
2929 case 4:
2930 // Use PrintWindow if available, or fallback to WM_PRINT
2931 // otherwise. Unfortunately using PrintWindow is even worse than
2932 // WM_PRINT. For most native widgets nothing is drawn to the dc
2933 // at all, with or without Themes.
2934 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2935 static bool s_triedToLoad = false;
2936 static PrintWindow_t pfnPrintWindow = NULL;
2937 if ( !s_triedToLoad )
2938 {
2939
2940 s_triedToLoad = true;
2941 wxDynamicLibrary dllUser32(_T("user32.dll"));
2942 if ( dllUser32.IsLoaded() )
2943 {
2944 wxLogNull nolog; // Don't report errors here
2945 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2946 }
2947 }
2948 if (pfnPrintWindow)
2949 {
2950 //printf("Using PrintWindow\n");
2951 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2952 }
2953 else
2954 {
2955 //printf("Using WM_PRINT\n");
2956 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2957 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2958 PRF_ERASEBKGND | PRF_OWNED );
2959 }
2960 }
2961 #endif // 0
2962 #else
2963 return false;
2964 #endif // __WXMSW__
2965 }
2966
2967
2968
2969 #include <wx/tipdlg.h>
2970
2971
2972 SWIGINTERNINLINE PyObject *
2973 SWIG_From_size_t (size_t value)
2974 {
2975 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2976 }
2977
2978
2979 class wxPyTipProvider : public wxTipProvider {
2980 public:
2981 wxPyTipProvider(size_t currentTip)
2982 : wxTipProvider(currentTip) {}
2983
2984 DEC_PYCALLBACK_STRING__pure(GetTip);
2985 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2986 PYPRIVATE;
2987 };
2988
2989 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2990 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2991
2992
2993 SWIGINTERNINLINE int
2994 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2995 {
2996 unsigned long v;
2997 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2998 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2999 return res;
3000 }
3001
3002
3003 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3004
3005 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3006
3007 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3008 : wxTimer(owner, id)
3009 {
3010 if (owner == NULL)
3011 SetOwner(this);
3012 }
3013
3014
3015 SWIGINTERN swig_type_info*
3016 SWIG_pchar_descriptor()
3017 {
3018 static int init = 0;
3019 static swig_type_info* info = 0;
3020 if (!init) {
3021 info = SWIG_TypeQuery("_p_char");
3022 init = 1;
3023 }
3024 return info;
3025 }
3026
3027
3028 SWIGINTERNINLINE PyObject *
3029 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3030 {
3031 if (carray) {
3032 if (size > INT_MAX) {
3033 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3034 return pchar_descriptor ?
3035 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3036 } else {
3037 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3038 }
3039 } else {
3040 return SWIG_Py_Void();
3041 }
3042 }
3043
3044
3045 SWIGINTERNINLINE PyObject *
3046 SWIG_FromCharPtr(const char *cptr)
3047 {
3048 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3049 }
3050
3051
3052 SWIGINTERN int
3053 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3054 {
3055 unsigned long v;
3056 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3057 if (SWIG_IsOK(res)) {
3058 if ((v > UINT_MAX)) {
3059 return SWIG_OverflowError;
3060 } else {
3061 if (val) *val = static_cast< unsigned int >(v);
3062 }
3063 }
3064 return res;
3065 }
3066
3067 SWIGINTERN wxString wxLog_TimeStamp(){
3068 wxString msg;
3069 wxLog::TimeStamp(&msg);
3070 return msg;
3071 }
3072 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3073 // Make some wrappers that double any % signs so they are 'escaped'
3074 void wxPyLogFatalError(const wxString& msg)
3075 {
3076 wxString m(msg);
3077 m.Replace(wxT("%"), wxT("%%"));
3078 wxLogFatalError(m);
3079 }
3080
3081 void wxPyLogError(const wxString& msg)
3082 {
3083 wxString m(msg);
3084 m.Replace(wxT("%"), wxT("%%"));
3085 wxLogError(m);
3086 }
3087
3088 void wxPyLogWarning(const wxString& msg)
3089 {
3090 wxString m(msg);
3091 m.Replace(wxT("%"), wxT("%%"));
3092 wxLogWarning(m);
3093 }
3094
3095 void wxPyLogMessage(const wxString& msg)
3096 {
3097 wxString m(msg);
3098 m.Replace(wxT("%"), wxT("%%"));
3099 wxLogMessage(m);
3100 }
3101
3102 void wxPyLogInfo(const wxString& msg)
3103 {
3104 wxString m(msg);
3105 m.Replace(wxT("%"), wxT("%%"));
3106 wxLogInfo(m);
3107 }
3108
3109 void wxPyLogDebug(const wxString& msg)
3110 {
3111 wxString m(msg);
3112 m.Replace(wxT("%"), wxT("%%"));
3113 wxLogDebug(m);
3114 }
3115
3116 void wxPyLogVerbose(const wxString& msg)
3117 {
3118 wxString m(msg);
3119 m.Replace(wxT("%"), wxT("%%"));
3120 wxLogVerbose(m);
3121 }
3122
3123 void wxPyLogStatus(const wxString& msg)
3124 {
3125 wxString m(msg);
3126 m.Replace(wxT("%"), wxT("%%"));
3127 wxLogStatus(m);
3128 }
3129
3130 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3131 {
3132 wxString m(msg);
3133 m.Replace(wxT("%"), wxT("%%"));
3134 wxLogStatus(pFrame, m);
3135 }
3136
3137 void wxPyLogSysError(const wxString& msg)
3138 {
3139 wxString m(msg);
3140 m.Replace(wxT("%"), wxT("%%"));
3141 wxLogSysError(m);
3142 }
3143
3144 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3145 {
3146 wxString m(msg);
3147 m.Replace(wxT("%"), wxT("%%"));
3148 wxLogGeneric(level, m);
3149 }
3150
3151 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3152 {
3153 wxString m(msg);
3154 m.Replace(wxT("%"), wxT("%%"));
3155 wxLogTrace(mask, m);
3156 }
3157
3158 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3159 {
3160 wxString m(msg);
3161 m.Replace(wxT("%"), wxT("%%"));
3162 wxLogTrace(mask, m);
3163 }
3164
3165
3166
3167 // A wxLog class that can be derived from in wxPython
3168 class wxPyLog : public wxLog {
3169 public:
3170 wxPyLog() : wxLog() {}
3171
3172 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3173 bool found;
3174 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3175 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3176 PyObject* s = wx2PyString(szString);
3177 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3178 Py_DECREF(s);
3179 }
3180 wxPyEndBlockThreads(blocked);
3181 if (! found)
3182 wxLog::DoLog(level, szString, t);
3183 }
3184
3185 virtual void DoLogString(const wxChar *szString, time_t t) {
3186 bool found;
3187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3188 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3189 PyObject* s = wx2PyString(szString);
3190 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3191 Py_DECREF(s);
3192 }
3193 wxPyEndBlockThreads(blocked);
3194 if (! found)
3195 wxLog::DoLogString(szString, t);
3196 }
3197
3198 DEC_PYCALLBACK_VOID_(Flush);
3199 PYPRIVATE;
3200 };
3201 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3202
3203
3204
3205
3206 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3207
3208
3209 #include <wx/joystick.h>
3210
3211
3212 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3213 // A C++ stub class for wxJoystick for platforms that don't have it.
3214 class wxJoystick : public wxObject {
3215 public:
3216 wxJoystick(int joystick = wxJOYSTICK1) {
3217 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3218 PyErr_SetString(PyExc_NotImplementedError,
3219 "wxJoystick is not available on this platform.");
3220 wxPyEndBlockThreads(blocked);
3221 }
3222 wxPoint GetPosition() { return wxPoint(-1,-1); }
3223 int GetZPosition() { return -1; }
3224 int GetButtonState() { return -1; }
3225 int GetPOVPosition() { return -1; }
3226 int GetPOVCTSPosition() { return -1; }
3227 int GetRudderPosition() { return -1; }
3228 int GetUPosition() { return -1; }
3229 int GetVPosition() { return -1; }
3230 int GetMovementThreshold() { return -1; }
3231 void SetMovementThreshold(int threshold) {}
3232
3233 bool IsOk(void) { return false; }
3234 int GetNumberJoysticks() { return -1; }
3235 int GetManufacturerId() { return -1; }
3236 int GetProductId() { return -1; }
3237 wxString GetProductName() { return wxEmptyString; }
3238 int GetXMin() { return -1; }
3239 int GetYMin() { return -1; }
3240 int GetZMin() { return -1; }
3241 int GetXMax() { return -1; }
3242 int GetYMax() { return -1; }
3243 int GetZMax() { return -1; }
3244 int GetNumberButtons() { return -1; }
3245 int GetNumberAxes() { return -1; }
3246 int GetMaxButtons() { return -1; }
3247 int GetMaxAxes() { return -1; }
3248 int GetPollingMin() { return -1; }
3249 int GetPollingMax() { return -1; }
3250 int GetRudderMin() { return -1; }
3251 int GetRudderMax() { return -1; }
3252 int GetUMin() { return -1; }
3253 int GetUMax() { return -1; }
3254 int GetVMin() { return -1; }
3255 int GetVMax() { return -1; }
3256
3257 bool HasRudder() { return false; }
3258 bool HasZ() { return false; }
3259 bool HasU() { return false; }
3260 bool HasV() { return false; }
3261 bool HasPOV() { return false; }
3262 bool HasPOV4Dir() { return false; }
3263 bool HasPOVCTS() { return false; }
3264
3265 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3266 bool ReleaseCapture() { return false; }
3267 };
3268 #endif
3269
3270
3271 #include <wx/sound.h>
3272
3273
3274 #if !wxUSE_SOUND
3275 // A C++ stub class for wxWave for platforms that don't have it.
3276 class wxSound : public wxObject
3277 {
3278 public:
3279 wxSound() {
3280 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3281 PyErr_SetString(PyExc_NotImplementedError,
3282 "wxSound is not available on this platform.");
3283 wxPyEndBlockThreads(blocked);
3284 }
3285 wxSound(const wxString&/*, bool*/) {
3286 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3287 PyErr_SetString(PyExc_NotImplementedError,
3288 "wxSound is not available on this platform.");
3289 wxPyEndBlockThreads(blocked);
3290 }
3291 wxSound(int, const wxByte*) {
3292 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3293 PyErr_SetString(PyExc_NotImplementedError,
3294 "wxSound is not available on this platform.");
3295 wxPyEndBlockThreads(blocked);
3296 }
3297
3298 ~wxSound() {};
3299
3300 bool Create(const wxString&/*, bool*/) { return false; }
3301 bool Create(int, const wxByte*) { return false; };
3302 bool IsOk() { return false; };
3303 bool Play(unsigned) const { return false; }
3304 static bool Play(const wxString&, unsigned) { return false; }
3305 static void Stop() {}
3306 };
3307
3308 #endif
3309
3310 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3311 if (fileName.Length() == 0)
3312 return new wxSound;
3313 else
3314 return new wxSound(fileName);
3315 }
3316 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3317 unsigned char* buffer; int size;
3318 wxSound *sound = NULL;
3319
3320 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3321 if (!PyArg_Parse(data, "t#", &buffer, &size))
3322 goto done;
3323 sound = new wxSound(size, buffer);
3324 done:
3325 wxPyEndBlockThreads(blocked);
3326 return sound;
3327 }
3328 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3329 #ifndef __WXMAC__
3330 unsigned char* buffer;
3331 int size;
3332 bool rv = false;
3333
3334 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3335 if (!PyArg_Parse(data, "t#", &buffer, &size))
3336 goto done;
3337 rv = self->Create(size, buffer);
3338 done:
3339 wxPyEndBlockThreads(blocked);
3340 return rv;
3341 #else
3342 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3343 PyErr_SetString(PyExc_NotImplementedError,
3344 "Create from data is not available on this platform.");
3345 wxPyEndBlockThreads(blocked);
3346 return false;
3347 #endif
3348 }
3349
3350 #include <wx/mimetype.h>
3351
3352 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3353 wxString str;
3354 if (self->GetMimeType(&str))
3355 return wx2PyString(str);
3356 else
3357 RETURN_NONE();
3358 }
3359 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3360 wxArrayString arr;
3361 if (self->GetMimeTypes(arr))
3362 return wxArrayString2PyList_helper(arr);
3363 else
3364 RETURN_NONE();
3365 }
3366 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3367 wxArrayString arr;
3368 if (self->GetExtensions(arr))
3369 return wxArrayString2PyList_helper(arr);
3370 else
3371 RETURN_NONE();
3372 }
3373 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3374 wxIconLocation loc;
3375 if (self->GetIcon(&loc))
3376 return new wxIcon(loc);
3377 else
3378 return NULL;
3379 }
3380 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3381 wxIconLocation loc;
3382 if (self->GetIcon(&loc)) {
3383 wxString iconFile = loc.GetFileName();
3384 int iconIndex = -1;
3385
3386
3387
3388 // Make a tuple and put the values in it
3389 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3390 PyObject* tuple = PyTuple_New(3);
3391 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3392 wxT("wxIcon"), true));
3393 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3394 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3395 wxPyEndBlockThreads(blocked);
3396 return tuple;
3397 }
3398 else
3399 RETURN_NONE();
3400 }
3401 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3402 wxString str;
3403 if (self->GetDescription(&str))
3404 return wx2PyString(str);
3405 else
3406 RETURN_NONE();
3407 }
3408 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3409 wxString str;
3410 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3411 return wx2PyString(str);
3412 else
3413 RETURN_NONE();
3414 }
3415 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3416 wxString str;
3417 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3418 return wx2PyString(str);
3419 else
3420 RETURN_NONE();
3421 }
3422 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3423 wxArrayString verbs;
3424 wxArrayString commands;
3425 if (self->GetAllCommands(&verbs, &commands,
3426 wxFileType::MessageParameters(filename, mimetype))) {
3427 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3428 PyObject* tuple = PyTuple_New(2);
3429 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3430 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3431 wxPyEndBlockThreads(blocked);
3432 return tuple;
3433 }
3434 else
3435 RETURN_NONE();
3436 }
3437 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3438 return wxFileType::ExpandCommand(command,
3439 wxFileType::MessageParameters(filename, mimetype));
3440 }
3441 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3442 wxArrayString arr;
3443 self->EnumAllFileTypes(arr);
3444 return wxArrayString2PyList_helper(arr);
3445 }
3446
3447 #include <wx/artprov.h>
3448
3449 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3450 static const wxString wxPyART_MENU(wxART_MENU);
3451 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3452 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3453 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3454 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3455 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3456 static const wxString wxPyART_OTHER(wxART_OTHER);
3457 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3458 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3459 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3460 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3461 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3462 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3463 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3464 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3465 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3466 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3467 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3468 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3469 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3470 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3471 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3472 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3473 static const wxString wxPyART_PRINT(wxART_PRINT);
3474 static const wxString wxPyART_HELP(wxART_HELP);
3475 static const wxString wxPyART_TIP(wxART_TIP);
3476 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3477 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3478 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3479 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3480 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3481 static const wxString wxPyART_CDROM(wxART_CDROM);
3482 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3483 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3484 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3485 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3486 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3487 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3488 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3489 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3490 static const wxString wxPyART_ERROR(wxART_ERROR);
3491 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3492 static const wxString wxPyART_WARNING(wxART_WARNING);
3493 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3494 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3495 static const wxString wxPyART_COPY(wxART_COPY);
3496 static const wxString wxPyART_CUT(wxART_CUT);
3497 static const wxString wxPyART_PASTE(wxART_PASTE);
3498 static const wxString wxPyART_DELETE(wxART_DELETE);
3499 static const wxString wxPyART_NEW(wxART_NEW);
3500 static const wxString wxPyART_UNDO(wxART_UNDO);
3501 static const wxString wxPyART_REDO(wxART_REDO);
3502 static const wxString wxPyART_QUIT(wxART_QUIT);
3503 static const wxString wxPyART_FIND(wxART_FIND);
3504 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3505 // Python aware wxArtProvider
3506 class wxPyArtProvider : public wxArtProvider {
3507 public:
3508
3509 virtual wxBitmap CreateBitmap(const wxArtID& id,
3510 const wxArtClient& client,
3511 const wxSize& size) {
3512 wxBitmap rval = wxNullBitmap;
3513 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3514 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3515 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3516 PyObject* ro;
3517 wxBitmap* ptr;
3518 PyObject* s1, *s2;
3519 s1 = wx2PyString(id);
3520 s2 = wx2PyString(client);
3521 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3522 Py_DECREF(so);
3523 Py_DECREF(s1);
3524 Py_DECREF(s2);
3525 if (ro) {
3526 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3527 rval = *ptr;
3528 Py_DECREF(ro);
3529 }
3530 }
3531 wxPyEndBlockThreads(blocked);
3532 return rval;
3533 }
3534
3535 PYPRIVATE;
3536 };
3537
3538 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3539
3540
3541
3542 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3543 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3544 PyObject* ret = PyTuple_New(3);
3545 if (ret) {
3546 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3547 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3548 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3549 }
3550 wxPyEndBlockThreads(blocked);
3551 return ret;
3552 }
3553
3554 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3555 bool cont;
3556 long index = 0;
3557 wxString value;
3558
3559 cont = self->GetFirstGroup(value, index);
3560 return __EnumerationHelper(cont, value, index);
3561 }
3562 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3563 bool cont;
3564 wxString value;
3565
3566 cont = self->GetNextGroup(value, index);
3567 return __EnumerationHelper(cont, value, index);
3568 }
3569 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3570 bool cont;
3571 long index = 0;
3572 wxString value;
3573
3574 cont = self->GetFirstEntry(value, index);
3575 return __EnumerationHelper(cont, value, index);
3576 }
3577 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3578 bool cont;
3579 wxString value;
3580
3581 cont = self->GetNextEntry(value, index);
3582 return __EnumerationHelper(cont, value, index);
3583 }
3584 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3585 long rv;
3586 self->Read(key, &rv, defaultVal);
3587 return rv;
3588 }
3589
3590 SWIGINTERN int
3591 SWIG_AsVal_double (PyObject *obj, double* val)
3592 {
3593 if (PyNumber_Check(obj)) {
3594 if (val) *val = PyFloat_AsDouble(obj);
3595 return SWIG_OK;
3596 }
3597 return SWIG_TypeError;
3598 }
3599
3600 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3601 double rv;
3602 self->Read(key, &rv, defaultVal);
3603 return rv;
3604 }
3605
3606 #define SWIG_From_double PyFloat_FromDouble
3607
3608 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3609 bool rv;
3610 self->Read(key, &rv, defaultVal);
3611 return rv;
3612 }
3613
3614 #include <wx/datetime.h>
3615
3616 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3617 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3618
3619 #define LOCAL_TZ wxDateTime::Local
3620
3621 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3622 wxString am;
3623 wxString pm;
3624 wxDateTime::GetAmPmStrings(&am, &pm);
3625 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3626 PyObject* tup = PyTuple_New(2);
3627 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3628 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3629 wxPyEndBlockThreads(blocked);
3630 return tup;
3631 }
3632
3633 SWIGINTERNINLINE PyObject *
3634 SWIG_From_unsigned_SS_int (unsigned int value)
3635 {
3636 return SWIG_From_unsigned_SS_long (value);
3637 }
3638
3639 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3640 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3641 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3642 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3643 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3644 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3645 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3646 return (*self < *other);
3647 }
3648 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3649 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3650 return (*self <= *other);
3651 }
3652 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3653 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3654 return (*self > *other);
3655 }
3656 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3657 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3658 return (*self >= *other);
3659 }
3660 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3661 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3662 return (*self == *other);
3663 }
3664 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3665 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3666 return (*self != *other);
3667 }
3668 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3669 const wxChar* rv;
3670 const wxChar* _date = date;
3671 rv = self->ParseRfc822Date(_date);
3672 if (rv == NULL) return -1;
3673 return rv - _date;
3674 }
3675 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3676 const wxChar* rv;
3677 const wxChar* _date = date;
3678 rv = self->ParseFormat(_date, format, dateDef);
3679 if (rv == NULL) return -1;
3680 return rv - _date;
3681 }
3682 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3683 const wxChar* rv;
3684 const wxChar* _datetime = datetime;
3685 rv = self->ParseDateTime(_datetime);
3686 if (rv == NULL) return -1;
3687 return rv - _datetime;
3688 }
3689 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3690 const wxChar* rv;
3691 const wxChar* _date = date;
3692 rv = self->ParseDate(_date);
3693 if (rv == NULL) return -1;
3694 return rv - _date;
3695 }
3696 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3697 const wxChar* rv;
3698 const wxChar* _time = time;
3699 rv = self->ParseTime(_time);
3700 if (rv == NULL) return -1;
3701 return rv - _time;
3702 }
3703 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3704 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3705 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3706 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3707 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3708 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3709 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3710 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3711 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3712 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3713 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3714 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3715 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3716 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3717 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3718 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3719
3720 #include <wx/dataobj.h>
3721
3722 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3723 size_t count = self->GetFormatCount(dir);
3724 wxDataFormat* formats = new wxDataFormat[count];
3725 self->GetAllFormats(formats, dir);
3726
3727 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3728 PyObject* list = PyList_New(count);
3729 for (size_t i=0; i<count; i++) {
3730 wxDataFormat* format = new wxDataFormat(formats[i]);
3731 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3732 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3733 }
3734 wxPyEndBlockThreads(blocked);
3735 delete [] formats;
3736 return list;
3737 }
3738 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3739 PyObject* rval = NULL;
3740 size_t size = self->GetDataSize(format);
3741 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3742 if (size) {
3743 char* buf = new char[size];
3744 if (self->GetDataHere(format, buf))
3745 rval = PyString_FromStringAndSize(buf, size);
3746 delete [] buf;
3747 }
3748 if (! rval) {
3749 rval = Py_None;
3750 Py_INCREF(rval);
3751 }
3752 wxPyEndBlockThreads(blocked);
3753 return rval;
3754 }
3755 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3756 bool rval;
3757 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3758 if (PyString_Check(data)) {
3759 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3760 }
3761 else {
3762 // raise a TypeError if not a string
3763 PyErr_SetString(PyExc_TypeError, "String expected.");
3764 rval = false;
3765 }
3766 wxPyEndBlockThreads(blocked);
3767 return rval;
3768 }
3769 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3770 PyObject* rval = NULL;
3771 size_t size = self->GetDataSize();
3772 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3773 if (size) {
3774 char* buf = new char[size];
3775 if (self->GetDataHere(buf))
3776 rval = PyString_FromStringAndSize(buf, size);
3777 delete [] buf;
3778 }
3779 if (! rval) {
3780 rval = Py_None;
3781 Py_INCREF(rval);
3782 }
3783 wxPyEndBlockThreads(blocked);
3784 return rval;
3785 }
3786 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3787 bool rval;
3788 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3789 if (PyString_Check(data)) {
3790 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3791 }
3792 else {
3793 // raise a TypeError if not a string
3794 PyErr_SetString(PyExc_TypeError, "String expected.");
3795 rval = false;
3796 }
3797 wxPyEndBlockThreads(blocked);
3798 return rval;
3799 }
3800 // Create a new class for wxPython to use
3801 class wxPyDataObjectSimple : public wxDataObjectSimple {
3802 public:
3803 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3804 : wxDataObjectSimple(format) {}
3805
3806 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3807 bool GetDataHere(void *buf) const;
3808 bool SetData(size_t len, const void *buf);
3809 PYPRIVATE;
3810 };
3811
3812 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3813
3814 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3815 // We need to get the data for this object and write it to buf. I think
3816 // the best way to do this for wxPython is to have the Python method
3817 // return either a string or None and then act appropriately with the
3818 // C++ version.
3819
3820 bool rval = false;
3821 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3822 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3823 PyObject* ro;
3824 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3825 if (ro) {
3826 rval = (ro != Py_None && PyString_Check(ro));
3827 if (rval)
3828 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3829 Py_DECREF(ro);
3830 }
3831 }
3832 wxPyEndBlockThreads(blocked);
3833 return rval;
3834 }
3835
3836 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3837 // For this one we simply need to make a string from buf and len
3838 // and send it to the Python method.
3839 bool rval = false;
3840 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3841 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3842 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3843 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3844 Py_DECREF(data);
3845 }
3846 wxPyEndBlockThreads(blocked);
3847 return rval;
3848 }
3849
3850 // Create a new class for wxPython to use
3851 class wxPyTextDataObject : public wxTextDataObject {
3852 public:
3853 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3854 : wxTextDataObject(text) {}
3855
3856 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3857 DEC_PYCALLBACK_STRING__const(GetText);
3858 DEC_PYCALLBACK__STRING(SetText);
3859 PYPRIVATE;
3860 };
3861
3862 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3863 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3864 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3865
3866
3867 // Create a new class for wxPython to use
3868 class wxPyBitmapDataObject : public wxBitmapDataObject {
3869 public:
3870 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3871 : wxBitmapDataObject(bitmap) {}
3872
3873 wxBitmap GetBitmap() const;
3874 void SetBitmap(const wxBitmap& bitmap);
3875 PYPRIVATE;
3876 };
3877
3878 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3879 wxBitmap* rval = &wxNullBitmap;
3880 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3881 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3882 PyObject* ro;
3883 wxBitmap* ptr;
3884 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3885 if (ro) {
3886 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3887 rval = ptr;
3888 Py_DECREF(ro);
3889 }
3890 }
3891 wxPyEndBlockThreads(blocked);
3892 return *rval;
3893 }
3894
3895 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3896 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3897 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3898 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3899 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3900 Py_DECREF(bo);
3901 }
3902 wxPyEndBlockThreads(blocked);
3903 }
3904
3905 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3906 return new wxCustomDataObject(wxDataFormat(formatName));
3907 }
3908 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3909 bool rval;
3910 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3911 if (PyString_Check(data)) {
3912 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3913 }
3914 else {
3915 // raise a TypeError if not a string
3916 PyErr_SetString(PyExc_TypeError, "String expected.");
3917 rval = false;
3918 }
3919 wxPyEndBlockThreads(blocked);
3920 return rval;
3921 }
3922 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3923 PyObject* obj;
3924 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3925 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3926 wxPyEndBlockThreads(blocked);
3927 return obj;
3928 }
3929
3930 #include <wx/metafile.h>
3931
3932
3933 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3934
3935
3936 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3937 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3938 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3939 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3940 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3941
3942
3943 class wxPyTextDropTarget : public wxTextDropTarget {
3944 public:
3945 wxPyTextDropTarget() {}
3946
3947 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3948
3949 DEC_PYCALLBACK__(OnLeave);
3950 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3951 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3952 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3953 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3954
3955 PYPRIVATE;
3956 };
3957
3958 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3959 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3960 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3961 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3962 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3963 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3964
3965
3966
3967 class wxPyFileDropTarget : public wxFileDropTarget {
3968 public:
3969 wxPyFileDropTarget() {}
3970
3971 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3972
3973 DEC_PYCALLBACK__(OnLeave);
3974 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3975 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3976 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3977 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3978
3979 PYPRIVATE;
3980 };
3981
3982 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3983 const wxArrayString& filenames) {
3984 bool rval = false;
3985 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3986 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3987 PyObject* list = wxArrayString2PyList_helper(filenames);
3988 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3989 Py_DECREF(list);
3990 }
3991 wxPyEndBlockThreads(blocked);
3992 return rval;
3993 }
3994
3995
3996
3997 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3998 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3999 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4000 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4001 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4002
4003
4004
4005
4006 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4007
4008 #include <wx/display.h>
4009
4010 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4011 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4012
4013 #if !wxUSE_DISPLAY
4014 const wxVideoMode wxDefaultVideoMode;
4015 #endif
4016
4017 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4018 #if wxUSE_DISPLAY
4019 PyObject* pyList = NULL;
4020 wxArrayVideoModes arr = self->GetModes(mode);
4021 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4022 pyList = PyList_New(0);
4023 for (size_t i=0; i < arr.GetCount(); i++)
4024 {
4025 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4026 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4027 PyList_Append(pyList, pyObj);
4028 Py_DECREF(pyObj);
4029 }
4030 wxPyEndBlockThreads(blocked);
4031 return pyList;
4032 #else
4033 wxPyRaiseNotImplemented();
4034 return NULL;
4035 #endif
4036 }
4037 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4038 #if wxUSE_DISPLAY
4039 return self->GetCurrentMode();
4040 #else
4041 wxPyRaiseNotImplemented();
4042 return wxDefaultVideoMode;
4043 #endif
4044 }
4045 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4046 #if wxUSE_DISPLAY
4047 return self->ChangeMode(mode);
4048 #else
4049 wxPyRaiseNotImplemented();
4050 return false;
4051 #endif
4052 }
4053 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4054 #if wxUSE_DISPLAY
4055 self->ResetMode();
4056 #else
4057 wxPyRaiseNotImplemented();
4058 #endif
4059 }
4060
4061 #include <wx/stdpaths.h>
4062
4063 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4064 return (wxStandardPaths*) &wxStandardPaths::Get();
4065 }
4066 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4067 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4068
4069 #ifndef wxHAS_POWER_EVENTS
4070 // Dummy class and other definitions for platforms that don't have them
4071
4072 // See wxPython_int.h for wxPowerEvent
4073
4074 enum {
4075 wxEVT_POWER_SUSPENDING,
4076 wxEVT_POWER_SUSPENDED,
4077 wxEVT_POWER_SUSPEND_CANCEL,
4078 wxEVT_POWER_RESUME,
4079 };
4080
4081 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4082 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4083
4084 #endif
4085
4086
4087 #include <wx/aboutdlg.h>
4088
4089 #ifdef __cplusplus
4090 extern "C" {
4091 #endif
4092 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4093 PyObject *resultobj = 0;
4094 wxSystemColour arg1 ;
4095 wxColour result;
4096 int val1 ;
4097 int ecode1 = 0 ;
4098 PyObject * obj0 = 0 ;
4099 char * kwnames[] = {
4100 (char *) "index", NULL
4101 };
4102
4103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4104 ecode1 = SWIG_AsVal_int(obj0, &val1);
4105 if (!SWIG_IsOK(ecode1)) {
4106 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4107 }
4108 arg1 = static_cast< wxSystemColour >(val1);
4109 {
4110 if (!wxPyCheckForApp()) SWIG_fail;
4111 PyThreadState* __tstate = wxPyBeginAllowThreads();
4112 result = wxSystemSettings::GetColour(arg1);
4113 wxPyEndAllowThreads(__tstate);
4114 if (PyErr_Occurred()) SWIG_fail;
4115 }
4116 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4117 return resultobj;
4118 fail:
4119 return NULL;
4120 }
4121
4122
4123 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4124 PyObject *resultobj = 0;
4125 wxSystemFont arg1 ;
4126 wxFont result;
4127 int val1 ;
4128 int ecode1 = 0 ;
4129 PyObject * obj0 = 0 ;
4130 char * kwnames[] = {
4131 (char *) "index", NULL
4132 };
4133
4134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4135 ecode1 = SWIG_AsVal_int(obj0, &val1);
4136 if (!SWIG_IsOK(ecode1)) {
4137 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4138 }
4139 arg1 = static_cast< wxSystemFont >(val1);
4140 {
4141 if (!wxPyCheckForApp()) SWIG_fail;
4142 PyThreadState* __tstate = wxPyBeginAllowThreads();
4143 result = wxSystemSettings::GetFont(arg1);
4144 wxPyEndAllowThreads(__tstate);
4145 if (PyErr_Occurred()) SWIG_fail;
4146 }
4147 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4148 return resultobj;
4149 fail:
4150 return NULL;
4151 }
4152
4153
4154 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4155 PyObject *resultobj = 0;
4156 wxSystemMetric arg1 ;
4157 wxWindow *arg2 = (wxWindow *) NULL ;
4158 int result;
4159 int val1 ;
4160 int ecode1 = 0 ;
4161 void *argp2 = 0 ;
4162 int res2 = 0 ;
4163 PyObject * obj0 = 0 ;
4164 PyObject * obj1 = 0 ;
4165 char * kwnames[] = {
4166 (char *) "index",(char *) "win", NULL
4167 };
4168
4169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4170 ecode1 = SWIG_AsVal_int(obj0, &val1);
4171 if (!SWIG_IsOK(ecode1)) {
4172 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4173 }
4174 arg1 = static_cast< wxSystemMetric >(val1);
4175 if (obj1) {
4176 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4177 if (!SWIG_IsOK(res2)) {
4178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4179 }
4180 arg2 = reinterpret_cast< wxWindow * >(argp2);
4181 }
4182 {
4183 if (!wxPyCheckForApp()) SWIG_fail;
4184 PyThreadState* __tstate = wxPyBeginAllowThreads();
4185 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4186 wxPyEndAllowThreads(__tstate);
4187 if (PyErr_Occurred()) SWIG_fail;
4188 }
4189 resultobj = SWIG_From_int(static_cast< int >(result));
4190 return resultobj;
4191 fail:
4192 return NULL;
4193 }
4194
4195
4196 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4197 PyObject *resultobj = 0;
4198 wxSystemFeature arg1 ;
4199 bool result;
4200 int val1 ;
4201 int ecode1 = 0 ;
4202 PyObject * obj0 = 0 ;
4203 char * kwnames[] = {
4204 (char *) "index", NULL
4205 };
4206
4207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4208 ecode1 = SWIG_AsVal_int(obj0, &val1);
4209 if (!SWIG_IsOK(ecode1)) {
4210 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4211 }
4212 arg1 = static_cast< wxSystemFeature >(val1);
4213 {
4214 if (!wxPyCheckForApp()) SWIG_fail;
4215 PyThreadState* __tstate = wxPyBeginAllowThreads();
4216 result = (bool)wxSystemSettings::HasFeature(arg1);
4217 wxPyEndAllowThreads(__tstate);
4218 if (PyErr_Occurred()) SWIG_fail;
4219 }
4220 {
4221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4222 }
4223 return resultobj;
4224 fail:
4225 return NULL;
4226 }
4227
4228
4229 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4230 PyObject *resultobj = 0;
4231 wxSystemScreenType result;
4232
4233 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4234 {
4235 if (!wxPyCheckForApp()) SWIG_fail;
4236 PyThreadState* __tstate = wxPyBeginAllowThreads();
4237 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4238 wxPyEndAllowThreads(__tstate);
4239 if (PyErr_Occurred()) SWIG_fail;
4240 }
4241 resultobj = SWIG_From_int(static_cast< int >(result));
4242 return resultobj;
4243 fail:
4244 return NULL;
4245 }
4246
4247
4248 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4249 PyObject *resultobj = 0;
4250 wxSystemScreenType arg1 ;
4251 int val1 ;
4252 int ecode1 = 0 ;
4253 PyObject * obj0 = 0 ;
4254 char * kwnames[] = {
4255 (char *) "screen", NULL
4256 };
4257
4258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4259 ecode1 = SWIG_AsVal_int(obj0, &val1);
4260 if (!SWIG_IsOK(ecode1)) {
4261 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4262 }
4263 arg1 = static_cast< wxSystemScreenType >(val1);
4264 {
4265 if (!wxPyCheckForApp()) SWIG_fail;
4266 PyThreadState* __tstate = wxPyBeginAllowThreads();
4267 wxSystemSettings::SetScreenType(arg1);
4268 wxPyEndAllowThreads(__tstate);
4269 if (PyErr_Occurred()) SWIG_fail;
4270 }
4271 resultobj = SWIG_Py_Void();
4272 return resultobj;
4273 fail:
4274 return NULL;
4275 }
4276
4277
4278 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4279 PyObject *obj;
4280 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4281 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4282 return SWIG_Py_Void();
4283 }
4284
4285 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4286 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4287 return 1;
4288 }
4289
4290
4291 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4292 PyObject *pyobj = 0;
4293
4294 {
4295 #if wxUSE_UNICODE
4296 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4297 #else
4298 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4299 #endif
4300 }
4301 return pyobj;
4302 }
4303
4304
4305 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4306 PyObject *resultobj = 0;
4307 wxSystemOptions *result = 0 ;
4308
4309 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4310 {
4311 PyThreadState* __tstate = wxPyBeginAllowThreads();
4312 result = (wxSystemOptions *)new wxSystemOptions();
4313 wxPyEndAllowThreads(__tstate);
4314 if (PyErr_Occurred()) SWIG_fail;
4315 }
4316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4317 return resultobj;
4318 fail:
4319 return NULL;
4320 }
4321
4322
4323 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4324 PyObject *resultobj = 0;
4325 wxString *arg1 = 0 ;
4326 wxString *arg2 = 0 ;
4327 bool temp1 = false ;
4328 bool temp2 = false ;
4329 PyObject * obj0 = 0 ;
4330 PyObject * obj1 = 0 ;
4331 char * kwnames[] = {
4332 (char *) "name",(char *) "value", NULL
4333 };
4334
4335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4336 {
4337 arg1 = wxString_in_helper(obj0);
4338 if (arg1 == NULL) SWIG_fail;
4339 temp1 = true;
4340 }
4341 {
4342 arg2 = wxString_in_helper(obj1);
4343 if (arg2 == NULL) SWIG_fail;
4344 temp2 = true;
4345 }
4346 {
4347 PyThreadState* __tstate = wxPyBeginAllowThreads();
4348 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4349 wxPyEndAllowThreads(__tstate);
4350 if (PyErr_Occurred()) SWIG_fail;
4351 }
4352 resultobj = SWIG_Py_Void();
4353 {
4354 if (temp1)
4355 delete arg1;
4356 }
4357 {
4358 if (temp2)
4359 delete arg2;
4360 }
4361 return resultobj;
4362 fail:
4363 {
4364 if (temp1)
4365 delete arg1;
4366 }
4367 {
4368 if (temp2)
4369 delete arg2;
4370 }
4371 return NULL;
4372 }
4373
4374
4375 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4376 PyObject *resultobj = 0;
4377 wxString *arg1 = 0 ;
4378 int arg2 ;
4379 bool temp1 = false ;
4380 int val2 ;
4381 int ecode2 = 0 ;
4382 PyObject * obj0 = 0 ;
4383 PyObject * obj1 = 0 ;
4384 char * kwnames[] = {
4385 (char *) "name",(char *) "value", NULL
4386 };
4387
4388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4389 {
4390 arg1 = wxString_in_helper(obj0);
4391 if (arg1 == NULL) SWIG_fail;
4392 temp1 = true;
4393 }
4394 ecode2 = SWIG_AsVal_int(obj1, &val2);
4395 if (!SWIG_IsOK(ecode2)) {
4396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4397 }
4398 arg2 = static_cast< int >(val2);
4399 {
4400 PyThreadState* __tstate = wxPyBeginAllowThreads();
4401 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4402 wxPyEndAllowThreads(__tstate);
4403 if (PyErr_Occurred()) SWIG_fail;
4404 }
4405 resultobj = SWIG_Py_Void();
4406 {
4407 if (temp1)
4408 delete arg1;
4409 }
4410 return resultobj;
4411 fail:
4412 {
4413 if (temp1)
4414 delete arg1;
4415 }
4416 return NULL;
4417 }
4418
4419
4420 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4421 PyObject *resultobj = 0;
4422 wxString *arg1 = 0 ;
4423 wxString result;
4424 bool temp1 = false ;
4425 PyObject * obj0 = 0 ;
4426 char * kwnames[] = {
4427 (char *) "name", NULL
4428 };
4429
4430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4431 {
4432 arg1 = wxString_in_helper(obj0);
4433 if (arg1 == NULL) SWIG_fail;
4434 temp1 = true;
4435 }
4436 {
4437 PyThreadState* __tstate = wxPyBeginAllowThreads();
4438 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4439 wxPyEndAllowThreads(__tstate);
4440 if (PyErr_Occurred()) SWIG_fail;
4441 }
4442 {
4443 #if wxUSE_UNICODE
4444 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4445 #else
4446 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4447 #endif
4448 }
4449 {
4450 if (temp1)
4451 delete arg1;
4452 }
4453 return resultobj;
4454 fail:
4455 {
4456 if (temp1)
4457 delete arg1;
4458 }
4459 return NULL;
4460 }
4461
4462
4463 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4464 PyObject *resultobj = 0;
4465 wxString *arg1 = 0 ;
4466 int result;
4467 bool temp1 = false ;
4468 PyObject * obj0 = 0 ;
4469 char * kwnames[] = {
4470 (char *) "name", NULL
4471 };
4472
4473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4474 {
4475 arg1 = wxString_in_helper(obj0);
4476 if (arg1 == NULL) SWIG_fail;
4477 temp1 = true;
4478 }
4479 {
4480 PyThreadState* __tstate = wxPyBeginAllowThreads();
4481 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4482 wxPyEndAllowThreads(__tstate);
4483 if (PyErr_Occurred()) SWIG_fail;
4484 }
4485 resultobj = SWIG_From_int(static_cast< int >(result));
4486 {
4487 if (temp1)
4488 delete arg1;
4489 }
4490 return resultobj;
4491 fail:
4492 {
4493 if (temp1)
4494 delete arg1;
4495 }
4496 return NULL;
4497 }
4498
4499
4500 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4501 PyObject *resultobj = 0;
4502 wxString *arg1 = 0 ;
4503 bool result;
4504 bool temp1 = false ;
4505 PyObject * obj0 = 0 ;
4506 char * kwnames[] = {
4507 (char *) "name", NULL
4508 };
4509
4510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4511 {
4512 arg1 = wxString_in_helper(obj0);
4513 if (arg1 == NULL) SWIG_fail;
4514 temp1 = true;
4515 }
4516 {
4517 PyThreadState* __tstate = wxPyBeginAllowThreads();
4518 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4519 wxPyEndAllowThreads(__tstate);
4520 if (PyErr_Occurred()) SWIG_fail;
4521 }
4522 {
4523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4524 }
4525 {
4526 if (temp1)
4527 delete arg1;
4528 }
4529 return resultobj;
4530 fail:
4531 {
4532 if (temp1)
4533 delete arg1;
4534 }
4535 return NULL;
4536 }
4537
4538
4539 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4540 PyObject *resultobj = 0;
4541 wxString *arg1 = 0 ;
4542 bool result;
4543 bool temp1 = false ;
4544 PyObject * obj0 = 0 ;
4545 char * kwnames[] = {
4546 (char *) "name", NULL
4547 };
4548
4549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4550 {
4551 arg1 = wxString_in_helper(obj0);
4552 if (arg1 == NULL) SWIG_fail;
4553 temp1 = true;
4554 }
4555 {
4556 PyThreadState* __tstate = wxPyBeginAllowThreads();
4557 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4558 wxPyEndAllowThreads(__tstate);
4559 if (PyErr_Occurred()) SWIG_fail;
4560 }
4561 {
4562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4563 }
4564 {
4565 if (temp1)
4566 delete arg1;
4567 }
4568 return resultobj;
4569 fail:
4570 {
4571 if (temp1)
4572 delete arg1;
4573 }
4574 return NULL;
4575 }
4576
4577
4578 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4579 PyObject *obj;
4580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4581 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4582 return SWIG_Py_Void();
4583 }
4584
4585 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4586 return SWIG_Python_InitShadowInstance(args);
4587 }
4588
4589 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4590 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4591 return 1;
4592 }
4593
4594
4595 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4596 PyObject *pyobj = 0;
4597
4598 {
4599 #if wxUSE_UNICODE
4600 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4601 #else
4602 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4603 #endif
4604 }
4605 return pyobj;
4606 }
4607
4608
4609 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4610 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4611 return 1;
4612 }
4613
4614
4615 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4616 PyObject *pyobj = 0;
4617
4618 {
4619 #if wxUSE_UNICODE
4620 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4621 #else
4622 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4623 #endif
4624 }
4625 return pyobj;
4626 }
4627
4628
4629 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4630 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4631 return 1;
4632 }
4633
4634
4635 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4636 PyObject *pyobj = 0;
4637
4638 {
4639 #if wxUSE_UNICODE
4640 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4641 #else
4642 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4643 #endif
4644 }
4645 return pyobj;
4646 }
4647
4648
4649 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4650 PyObject *resultobj = 0;
4651 long result;
4652
4653 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4654 {
4655 PyThreadState* __tstate = wxPyBeginAllowThreads();
4656 result = (long)wxNewId();
4657 wxPyEndAllowThreads(__tstate);
4658 if (PyErr_Occurred()) SWIG_fail;
4659 }
4660 resultobj = SWIG_From_long(static_cast< long >(result));
4661 return resultobj;
4662 fail:
4663 return NULL;
4664 }
4665
4666
4667 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4668 PyObject *resultobj = 0;
4669 long arg1 ;
4670 long val1 ;
4671 int ecode1 = 0 ;
4672 PyObject * obj0 = 0 ;
4673 char * kwnames[] = {
4674 (char *) "id", NULL
4675 };
4676
4677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4678 ecode1 = SWIG_AsVal_long(obj0, &val1);
4679 if (!SWIG_IsOK(ecode1)) {
4680 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4681 }
4682 arg1 = static_cast< long >(val1);
4683 {
4684 PyThreadState* __tstate = wxPyBeginAllowThreads();
4685 wxRegisterId(arg1);
4686 wxPyEndAllowThreads(__tstate);
4687 if (PyErr_Occurred()) SWIG_fail;
4688 }
4689 resultobj = SWIG_Py_Void();
4690 return resultobj;
4691 fail:
4692 return NULL;
4693 }
4694
4695
4696 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4697 PyObject *resultobj = 0;
4698 long result;
4699
4700 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4701 {
4702 PyThreadState* __tstate = wxPyBeginAllowThreads();
4703 result = (long)wxGetCurrentId();
4704 wxPyEndAllowThreads(__tstate);
4705 if (PyErr_Occurred()) SWIG_fail;
4706 }
4707 resultobj = SWIG_From_long(static_cast< long >(result));
4708 return resultobj;
4709 fail:
4710 return NULL;
4711 }
4712
4713
4714 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4715 PyObject *resultobj = 0;
4716 int arg1 ;
4717 bool result;
4718 int val1 ;
4719 int ecode1 = 0 ;
4720 PyObject * obj0 = 0 ;
4721 char * kwnames[] = {
4722 (char *) "id", NULL
4723 };
4724
4725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4726 ecode1 = SWIG_AsVal_int(obj0, &val1);
4727 if (!SWIG_IsOK(ecode1)) {
4728 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4729 }
4730 arg1 = static_cast< int >(val1);
4731 {
4732 PyThreadState* __tstate = wxPyBeginAllowThreads();
4733 result = (bool)wxIsStockID(arg1);
4734 wxPyEndAllowThreads(__tstate);
4735 if (PyErr_Occurred()) SWIG_fail;
4736 }
4737 {
4738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4739 }
4740 return resultobj;
4741 fail:
4742 return NULL;
4743 }
4744
4745
4746 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4747 PyObject *resultobj = 0;
4748 int arg1 ;
4749 wxString *arg2 = 0 ;
4750 bool result;
4751 int val1 ;
4752 int ecode1 = 0 ;
4753 bool temp2 = false ;
4754 PyObject * obj0 = 0 ;
4755 PyObject * obj1 = 0 ;
4756 char * kwnames[] = {
4757 (char *) "id",(char *) "label", NULL
4758 };
4759
4760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4761 ecode1 = SWIG_AsVal_int(obj0, &val1);
4762 if (!SWIG_IsOK(ecode1)) {
4763 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4764 }
4765 arg1 = static_cast< int >(val1);
4766 {
4767 arg2 = wxString_in_helper(obj1);
4768 if (arg2 == NULL) SWIG_fail;
4769 temp2 = true;
4770 }
4771 {
4772 PyThreadState* __tstate = wxPyBeginAllowThreads();
4773 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4774 wxPyEndAllowThreads(__tstate);
4775 if (PyErr_Occurred()) SWIG_fail;
4776 }
4777 {
4778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4779 }
4780 {
4781 if (temp2)
4782 delete arg2;
4783 }
4784 return resultobj;
4785 fail:
4786 {
4787 if (temp2)
4788 delete arg2;
4789 }
4790 return NULL;
4791 }
4792
4793
4794 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4795 PyObject *resultobj = 0;
4796 int arg1 ;
4797 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4798 wxString result;
4799 int val1 ;
4800 int ecode1 = 0 ;
4801 long val2 ;
4802 int ecode2 = 0 ;
4803 PyObject * obj0 = 0 ;
4804 PyObject * obj1 = 0 ;
4805 char * kwnames[] = {
4806 (char *) "id",(char *) "flags", NULL
4807 };
4808
4809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4810 ecode1 = SWIG_AsVal_int(obj0, &val1);
4811 if (!SWIG_IsOK(ecode1)) {
4812 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4813 }
4814 arg1 = static_cast< int >(val1);
4815 if (obj1) {
4816 ecode2 = SWIG_AsVal_long(obj1, &val2);
4817 if (!SWIG_IsOK(ecode2)) {
4818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4819 }
4820 arg2 = static_cast< long >(val2);
4821 }
4822 {
4823 PyThreadState* __tstate = wxPyBeginAllowThreads();
4824 result = wxGetStockLabel(arg1,arg2);
4825 wxPyEndAllowThreads(__tstate);
4826 if (PyErr_Occurred()) SWIG_fail;
4827 }
4828 {
4829 #if wxUSE_UNICODE
4830 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4831 #else
4832 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4833 #endif
4834 }
4835 return resultobj;
4836 fail:
4837 return NULL;
4838 }
4839
4840
4841 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4842 PyObject *resultobj = 0;
4843 int arg1 ;
4844 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4845 wxString result;
4846 int val1 ;
4847 int ecode1 = 0 ;
4848 int val2 ;
4849 int ecode2 = 0 ;
4850 PyObject * obj0 = 0 ;
4851 PyObject * obj1 = 0 ;
4852 char * kwnames[] = {
4853 (char *) "id",(char *) "client", NULL
4854 };
4855
4856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4857 ecode1 = SWIG_AsVal_int(obj0, &val1);
4858 if (!SWIG_IsOK(ecode1)) {
4859 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4860 }
4861 arg1 = static_cast< int >(val1);
4862 if (obj1) {
4863 ecode2 = SWIG_AsVal_int(obj1, &val2);
4864 if (!SWIG_IsOK(ecode2)) {
4865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4866 }
4867 arg2 = static_cast< wxStockHelpStringClient >(val2);
4868 }
4869 {
4870 PyThreadState* __tstate = wxPyBeginAllowThreads();
4871 result = wxGetStockHelpString(arg1,arg2);
4872 wxPyEndAllowThreads(__tstate);
4873 if (PyErr_Occurred()) SWIG_fail;
4874 }
4875 {
4876 #if wxUSE_UNICODE
4877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4878 #else
4879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4880 #endif
4881 }
4882 return resultobj;
4883 fail:
4884 return NULL;
4885 }
4886
4887
4888 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4889 PyObject *resultobj = 0;
4890
4891 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4892 {
4893 if (!wxPyCheckForApp()) SWIG_fail;
4894 PyThreadState* __tstate = wxPyBeginAllowThreads();
4895 wxBell();
4896 wxPyEndAllowThreads(__tstate);
4897 if (PyErr_Occurred()) SWIG_fail;
4898 }
4899 resultobj = SWIG_Py_Void();
4900 return resultobj;
4901 fail:
4902 return NULL;
4903 }
4904
4905
4906 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4907 PyObject *resultobj = 0;
4908
4909 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4910 {
4911 if (!wxPyCheckForApp()) SWIG_fail;
4912 PyThreadState* __tstate = wxPyBeginAllowThreads();
4913 wxEndBusyCursor();
4914 wxPyEndAllowThreads(__tstate);
4915 if (PyErr_Occurred()) SWIG_fail;
4916 }
4917 resultobj = SWIG_Py_Void();
4918 return resultobj;
4919 fail:
4920 return NULL;
4921 }
4922
4923
4924 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4925 PyObject *resultobj = 0;
4926 bool arg1 = (bool) true ;
4927 long result;
4928 bool val1 ;
4929 int ecode1 = 0 ;
4930 PyObject * obj0 = 0 ;
4931 char * kwnames[] = {
4932 (char *) "resetTimer", NULL
4933 };
4934
4935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4936 if (obj0) {
4937 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4938 if (!SWIG_IsOK(ecode1)) {
4939 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4940 }
4941 arg1 = static_cast< bool >(val1);
4942 }
4943 {
4944 PyThreadState* __tstate = wxPyBeginAllowThreads();
4945 result = (long)wxGetElapsedTime(arg1);
4946 wxPyEndAllowThreads(__tstate);
4947 if (PyErr_Occurred()) SWIG_fail;
4948 }
4949 resultobj = SWIG_From_long(static_cast< long >(result));
4950 return resultobj;
4951 fail:
4952 return NULL;
4953 }
4954
4955
4956 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4957 PyObject *resultobj = 0;
4958 bool result;
4959
4960 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4961 {
4962 PyThreadState* __tstate = wxPyBeginAllowThreads();
4963 result = (bool)wxIsBusy();
4964 wxPyEndAllowThreads(__tstate);
4965 if (PyErr_Occurred()) SWIG_fail;
4966 }
4967 {
4968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4969 }
4970 return resultobj;
4971 fail:
4972 return NULL;
4973 }
4974
4975
4976 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4977 PyObject *resultobj = 0;
4978 wxString result;
4979
4980 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4981 {
4982 PyThreadState* __tstate = wxPyBeginAllowThreads();
4983 result = wxNow();
4984 wxPyEndAllowThreads(__tstate);
4985 if (PyErr_Occurred()) SWIG_fail;
4986 }
4987 {
4988 #if wxUSE_UNICODE
4989 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4990 #else
4991 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4992 #endif
4993 }
4994 return resultobj;
4995 fail:
4996 return NULL;
4997 }
4998
4999
5000 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5001 PyObject *resultobj = 0;
5002 wxString const &arg1_defvalue = wxPyEmptyString ;
5003 wxString *arg1 = (wxString *) &arg1_defvalue ;
5004 bool result;
5005 bool temp1 = false ;
5006 PyObject * obj0 = 0 ;
5007 char * kwnames[] = {
5008 (char *) "command", NULL
5009 };
5010
5011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5012 if (obj0) {
5013 {
5014 arg1 = wxString_in_helper(obj0);
5015 if (arg1 == NULL) SWIG_fail;
5016 temp1 = true;
5017 }
5018 }
5019 {
5020 PyThreadState* __tstate = wxPyBeginAllowThreads();
5021 result = (bool)wxShell((wxString const &)*arg1);
5022 wxPyEndAllowThreads(__tstate);
5023 if (PyErr_Occurred()) SWIG_fail;
5024 }
5025 {
5026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5027 }
5028 {
5029 if (temp1)
5030 delete arg1;
5031 }
5032 return resultobj;
5033 fail:
5034 {
5035 if (temp1)
5036 delete arg1;
5037 }
5038 return NULL;
5039 }
5040
5041
5042 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5043 PyObject *resultobj = 0;
5044
5045 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5046 {
5047 PyThreadState* __tstate = wxPyBeginAllowThreads();
5048 wxStartTimer();
5049 wxPyEndAllowThreads(__tstate);
5050 if (PyErr_Occurred()) SWIG_fail;
5051 }
5052 resultobj = SWIG_Py_Void();
5053 return resultobj;
5054 fail:
5055 return NULL;
5056 }
5057
5058
5059 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5060 PyObject *resultobj = 0;
5061 int *arg1 = (int *) 0 ;
5062 int *arg2 = (int *) 0 ;
5063 int result;
5064 int temp1 ;
5065 int res1 = SWIG_TMPOBJ ;
5066 int temp2 ;
5067 int res2 = SWIG_TMPOBJ ;
5068
5069 arg1 = &temp1;
5070 arg2 = &temp2;
5071 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5072 {
5073 PyThreadState* __tstate = wxPyBeginAllowThreads();
5074 result = (int)wxGetOsVersion(arg1,arg2);
5075 wxPyEndAllowThreads(__tstate);
5076 if (PyErr_Occurred()) SWIG_fail;
5077 }
5078 resultobj = SWIG_From_int(static_cast< int >(result));
5079 if (SWIG_IsTmpObj(res1)) {
5080 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5081 } else {
5082 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5084 }
5085 if (SWIG_IsTmpObj(res2)) {
5086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5087 } else {
5088 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5090 }
5091 return resultobj;
5092 fail:
5093 return NULL;
5094 }
5095
5096
5097 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5098 PyObject *resultobj = 0;
5099 wxString result;
5100
5101 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5102 {
5103 PyThreadState* __tstate = wxPyBeginAllowThreads();
5104 result = wxGetOsDescription();
5105 wxPyEndAllowThreads(__tstate);
5106 if (PyErr_Occurred()) SWIG_fail;
5107 }
5108 {
5109 #if wxUSE_UNICODE
5110 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5111 #else
5112 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5113 #endif
5114 }
5115 return resultobj;
5116 fail:
5117 return NULL;
5118 }
5119
5120
5121 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5122 PyObject *resultobj = 0;
5123 bool result;
5124
5125 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5126 {
5127 PyThreadState* __tstate = wxPyBeginAllowThreads();
5128 result = (bool)wxIsPlatformLittleEndian();
5129 wxPyEndAllowThreads(__tstate);
5130 if (PyErr_Occurred()) SWIG_fail;
5131 }
5132 {
5133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5134 }
5135 return resultobj;
5136 fail:
5137 return NULL;
5138 }
5139
5140
5141 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5142 PyObject *resultobj = 0;
5143 bool result;
5144
5145 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5146 {
5147 PyThreadState* __tstate = wxPyBeginAllowThreads();
5148 result = (bool)wxIsPlatform64Bit();
5149 wxPyEndAllowThreads(__tstate);
5150 if (PyErr_Occurred()) SWIG_fail;
5151 }
5152 {
5153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5154 }
5155 return resultobj;
5156 fail:
5157 return NULL;
5158 }
5159
5160
5161 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5162 PyObject *resultobj = 0;
5163 wxMemorySize result;
5164
5165 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5166 {
5167 PyThreadState* __tstate = wxPyBeginAllowThreads();
5168 result = wxGetFreeMemory();
5169 wxPyEndAllowThreads(__tstate);
5170 if (PyErr_Occurred()) SWIG_fail;
5171 }
5172 {
5173 #if wxUSE_LONGLONG
5174 resultobj = PyLong_FromLongLong((&result)->GetValue());
5175 #else
5176 resultobj = PyInt_FromLong(result);
5177 #endif
5178 }
5179 return resultobj;
5180 fail:
5181 return NULL;
5182 }
5183
5184
5185 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5186 PyObject *resultobj = 0;
5187 wxShutdownFlags arg1 ;
5188 bool result;
5189 int val1 ;
5190 int ecode1 = 0 ;
5191 PyObject * obj0 = 0 ;
5192 char * kwnames[] = {
5193 (char *) "wFlags", NULL
5194 };
5195
5196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5197 ecode1 = SWIG_AsVal_int(obj0, &val1);
5198 if (!SWIG_IsOK(ecode1)) {
5199 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5200 }
5201 arg1 = static_cast< wxShutdownFlags >(val1);
5202 {
5203 if (!wxPyCheckForApp()) SWIG_fail;
5204 PyThreadState* __tstate = wxPyBeginAllowThreads();
5205 result = (bool)wxShutdown(arg1);
5206 wxPyEndAllowThreads(__tstate);
5207 if (PyErr_Occurred()) SWIG_fail;
5208 }
5209 {
5210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5211 }
5212 return resultobj;
5213 fail:
5214 return NULL;
5215 }
5216
5217
5218 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5219 PyObject *resultobj = 0;
5220 int arg1 ;
5221 int val1 ;
5222 int ecode1 = 0 ;
5223 PyObject * obj0 = 0 ;
5224 char * kwnames[] = {
5225 (char *) "secs", NULL
5226 };
5227
5228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5229 ecode1 = SWIG_AsVal_int(obj0, &val1);
5230 if (!SWIG_IsOK(ecode1)) {
5231 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5232 }
5233 arg1 = static_cast< int >(val1);
5234 {
5235 PyThreadState* __tstate = wxPyBeginAllowThreads();
5236 wxSleep(arg1);
5237 wxPyEndAllowThreads(__tstate);
5238 if (PyErr_Occurred()) SWIG_fail;
5239 }
5240 resultobj = SWIG_Py_Void();
5241 return resultobj;
5242 fail:
5243 return NULL;
5244 }
5245
5246
5247 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5248 PyObject *resultobj = 0;
5249 unsigned long arg1 ;
5250 unsigned long val1 ;
5251 int ecode1 = 0 ;
5252 PyObject * obj0 = 0 ;
5253 char * kwnames[] = {
5254 (char *) "milliseconds", NULL
5255 };
5256
5257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5258 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5259 if (!SWIG_IsOK(ecode1)) {
5260 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5261 }
5262 arg1 = static_cast< unsigned long >(val1);
5263 {
5264 PyThreadState* __tstate = wxPyBeginAllowThreads();
5265 wxMilliSleep(arg1);
5266 wxPyEndAllowThreads(__tstate);
5267 if (PyErr_Occurred()) SWIG_fail;
5268 }
5269 resultobj = SWIG_Py_Void();
5270 return resultobj;
5271 fail:
5272 return NULL;
5273 }
5274
5275
5276 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5277 PyObject *resultobj = 0;
5278 unsigned long arg1 ;
5279 unsigned long val1 ;
5280 int ecode1 = 0 ;
5281 PyObject * obj0 = 0 ;
5282 char * kwnames[] = {
5283 (char *) "microseconds", NULL
5284 };
5285
5286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5287 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5288 if (!SWIG_IsOK(ecode1)) {
5289 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5290 }
5291 arg1 = static_cast< unsigned long >(val1);
5292 {
5293 PyThreadState* __tstate = wxPyBeginAllowThreads();
5294 wxMicroSleep(arg1);
5295 wxPyEndAllowThreads(__tstate);
5296 if (PyErr_Occurred()) SWIG_fail;
5297 }
5298 resultobj = SWIG_Py_Void();
5299 return resultobj;
5300 fail:
5301 return NULL;
5302 }
5303
5304
5305 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5306 PyObject *resultobj = 0;
5307 bool arg1 ;
5308 bool val1 ;
5309 int ecode1 = 0 ;
5310 PyObject * obj0 = 0 ;
5311 char * kwnames[] = {
5312 (char *) "enable", NULL
5313 };
5314
5315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5316 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5317 if (!SWIG_IsOK(ecode1)) {
5318 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5319 }
5320 arg1 = static_cast< bool >(val1);
5321 {
5322 PyThreadState* __tstate = wxPyBeginAllowThreads();
5323 wxEnableTopLevelWindows(arg1);
5324 wxPyEndAllowThreads(__tstate);
5325 if (PyErr_Occurred()) SWIG_fail;
5326 }
5327 resultobj = SWIG_Py_Void();
5328 return resultobj;
5329 fail:
5330 return NULL;
5331 }
5332
5333
5334 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5335 PyObject *resultobj = 0;
5336 wxString *arg1 = 0 ;
5337 wxString result;
5338 bool temp1 = false ;
5339 PyObject * obj0 = 0 ;
5340 char * kwnames[] = {
5341 (char *) "in", NULL
5342 };
5343
5344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5345 {
5346 arg1 = wxString_in_helper(obj0);
5347 if (arg1 == NULL) SWIG_fail;
5348 temp1 = true;
5349 }
5350 {
5351 PyThreadState* __tstate = wxPyBeginAllowThreads();
5352 result = wxStripMenuCodes((wxString const &)*arg1);
5353 wxPyEndAllowThreads(__tstate);
5354 if (PyErr_Occurred()) SWIG_fail;
5355 }
5356 {
5357 #if wxUSE_UNICODE
5358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5359 #else
5360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5361 #endif
5362 }
5363 {
5364 if (temp1)
5365 delete arg1;
5366 }
5367 return resultobj;
5368 fail:
5369 {
5370 if (temp1)
5371 delete arg1;
5372 }
5373 return NULL;
5374 }
5375
5376
5377 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5378 PyObject *resultobj = 0;
5379 wxString result;
5380
5381 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5382 {
5383 PyThreadState* __tstate = wxPyBeginAllowThreads();
5384 result = wxGetEmailAddress();
5385 wxPyEndAllowThreads(__tstate);
5386 if (PyErr_Occurred()) SWIG_fail;
5387 }
5388 {
5389 #if wxUSE_UNICODE
5390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5391 #else
5392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5393 #endif
5394 }
5395 return resultobj;
5396 fail:
5397 return NULL;
5398 }
5399
5400
5401 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5402 PyObject *resultobj = 0;
5403 wxString result;
5404
5405 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5406 {
5407 PyThreadState* __tstate = wxPyBeginAllowThreads();
5408 result = wxGetHostName();
5409 wxPyEndAllowThreads(__tstate);
5410 if (PyErr_Occurred()) SWIG_fail;
5411 }
5412 {
5413 #if wxUSE_UNICODE
5414 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5415 #else
5416 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5417 #endif
5418 }
5419 return resultobj;
5420 fail:
5421 return NULL;
5422 }
5423
5424
5425 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5426 PyObject *resultobj = 0;
5427 wxString result;
5428
5429 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5430 {
5431 PyThreadState* __tstate = wxPyBeginAllowThreads();
5432 result = wxGetFullHostName();
5433 wxPyEndAllowThreads(__tstate);
5434 if (PyErr_Occurred()) SWIG_fail;
5435 }
5436 {
5437 #if wxUSE_UNICODE
5438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5439 #else
5440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5441 #endif
5442 }
5443 return resultobj;
5444 fail:
5445 return NULL;
5446 }
5447
5448
5449 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5450 PyObject *resultobj = 0;
5451 wxString result;
5452
5453 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5454 {
5455 PyThreadState* __tstate = wxPyBeginAllowThreads();
5456 result = wxGetUserId();
5457 wxPyEndAllowThreads(__tstate);
5458 if (PyErr_Occurred()) SWIG_fail;
5459 }
5460 {
5461 #if wxUSE_UNICODE
5462 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5463 #else
5464 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5465 #endif
5466 }
5467 return resultobj;
5468 fail:
5469 return NULL;
5470 }
5471
5472
5473 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5474 PyObject *resultobj = 0;
5475 wxString result;
5476
5477 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5478 {
5479 PyThreadState* __tstate = wxPyBeginAllowThreads();
5480 result = wxGetUserName();
5481 wxPyEndAllowThreads(__tstate);
5482 if (PyErr_Occurred()) SWIG_fail;
5483 }
5484 {
5485 #if wxUSE_UNICODE
5486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5487 #else
5488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5489 #endif
5490 }
5491 return resultobj;
5492 fail:
5493 return NULL;
5494 }
5495
5496
5497 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5498 PyObject *resultobj = 0;
5499 wxString result;
5500
5501 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5502 {
5503 PyThreadState* __tstate = wxPyBeginAllowThreads();
5504 result = wxGetHomeDir();
5505 wxPyEndAllowThreads(__tstate);
5506 if (PyErr_Occurred()) SWIG_fail;
5507 }
5508 {
5509 #if wxUSE_UNICODE
5510 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5511 #else
5512 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5513 #endif
5514 }
5515 return resultobj;
5516 fail:
5517 return NULL;
5518 }
5519
5520
5521 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5522 PyObject *resultobj = 0;
5523 wxString const &arg1_defvalue = wxPyEmptyString ;
5524 wxString *arg1 = (wxString *) &arg1_defvalue ;
5525 wxString result;
5526 bool temp1 = false ;
5527 PyObject * obj0 = 0 ;
5528 char * kwnames[] = {
5529 (char *) "user", NULL
5530 };
5531
5532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5533 if (obj0) {
5534 {
5535 arg1 = wxString_in_helper(obj0);
5536 if (arg1 == NULL) SWIG_fail;
5537 temp1 = true;
5538 }
5539 }
5540 {
5541 PyThreadState* __tstate = wxPyBeginAllowThreads();
5542 result = wxGetUserHome((wxString const &)*arg1);
5543 wxPyEndAllowThreads(__tstate);
5544 if (PyErr_Occurred()) SWIG_fail;
5545 }
5546 {
5547 #if wxUSE_UNICODE
5548 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5549 #else
5550 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5551 #endif
5552 }
5553 {
5554 if (temp1)
5555 delete arg1;
5556 }
5557 return resultobj;
5558 fail:
5559 {
5560 if (temp1)
5561 delete arg1;
5562 }
5563 return NULL;
5564 }
5565
5566
5567 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5568 PyObject *resultobj = 0;
5569 unsigned long result;
5570
5571 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5572 {
5573 PyThreadState* __tstate = wxPyBeginAllowThreads();
5574 result = (unsigned long)wxGetProcessId();
5575 wxPyEndAllowThreads(__tstate);
5576 if (PyErr_Occurred()) SWIG_fail;
5577 }
5578 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5579 return resultobj;
5580 fail:
5581 return NULL;
5582 }
5583
5584
5585 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5586 PyObject *resultobj = 0;
5587
5588 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5589 {
5590 PyThreadState* __tstate = wxPyBeginAllowThreads();
5591 wxTrap();
5592 wxPyEndAllowThreads(__tstate);
5593 if (PyErr_Occurred()) SWIG_fail;
5594 }
5595 resultobj = SWIG_Py_Void();
5596 return resultobj;
5597 fail:
5598 return NULL;
5599 }
5600
5601
5602 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5603 PyObject *resultobj = 0;
5604 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5605 wxString *arg1 = (wxString *) &arg1_defvalue ;
5606 wxString const &arg2_defvalue = wxPyEmptyString ;
5607 wxString *arg2 = (wxString *) &arg2_defvalue ;
5608 wxString const &arg3_defvalue = wxPyEmptyString ;
5609 wxString *arg3 = (wxString *) &arg3_defvalue ;
5610 wxString const &arg4_defvalue = wxPyEmptyString ;
5611 wxString *arg4 = (wxString *) &arg4_defvalue ;
5612 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5613 wxString *arg5 = (wxString *) &arg5_defvalue ;
5614 int arg6 = (int) 0 ;
5615 wxWindow *arg7 = (wxWindow *) NULL ;
5616 int arg8 = (int) -1 ;
5617 int arg9 = (int) -1 ;
5618 wxString result;
5619 bool temp1 = false ;
5620 bool temp2 = false ;
5621 bool temp3 = false ;
5622 bool temp4 = false ;
5623 bool temp5 = false ;
5624 int val6 ;
5625 int ecode6 = 0 ;
5626 void *argp7 = 0 ;
5627 int res7 = 0 ;
5628 int val8 ;
5629 int ecode8 = 0 ;
5630 int val9 ;
5631 int ecode9 = 0 ;
5632 PyObject * obj0 = 0 ;
5633 PyObject * obj1 = 0 ;
5634 PyObject * obj2 = 0 ;
5635 PyObject * obj3 = 0 ;
5636 PyObject * obj4 = 0 ;
5637 PyObject * obj5 = 0 ;
5638 PyObject * obj6 = 0 ;
5639 PyObject * obj7 = 0 ;
5640 PyObject * obj8 = 0 ;
5641 char * kwnames[] = {
5642 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5643 };
5644
5645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5646 if (obj0) {
5647 {
5648 arg1 = wxString_in_helper(obj0);
5649 if (arg1 == NULL) SWIG_fail;
5650 temp1 = true;
5651 }
5652 }
5653 if (obj1) {
5654 {
5655 arg2 = wxString_in_helper(obj1);
5656 if (arg2 == NULL) SWIG_fail;
5657 temp2 = true;
5658 }
5659 }
5660 if (obj2) {
5661 {
5662 arg3 = wxString_in_helper(obj2);
5663 if (arg3 == NULL) SWIG_fail;
5664 temp3 = true;
5665 }
5666 }
5667 if (obj3) {
5668 {
5669 arg4 = wxString_in_helper(obj3);
5670 if (arg4 == NULL) SWIG_fail;
5671 temp4 = true;
5672 }
5673 }
5674 if (obj4) {
5675 {
5676 arg5 = wxString_in_helper(obj4);
5677 if (arg5 == NULL) SWIG_fail;
5678 temp5 = true;
5679 }
5680 }
5681 if (obj5) {
5682 ecode6 = SWIG_AsVal_int(obj5, &val6);
5683 if (!SWIG_IsOK(ecode6)) {
5684 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5685 }
5686 arg6 = static_cast< int >(val6);
5687 }
5688 if (obj6) {
5689 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5690 if (!SWIG_IsOK(res7)) {
5691 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5692 }
5693 arg7 = reinterpret_cast< wxWindow * >(argp7);
5694 }
5695 if (obj7) {
5696 ecode8 = SWIG_AsVal_int(obj7, &val8);
5697 if (!SWIG_IsOK(ecode8)) {
5698 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5699 }
5700 arg8 = static_cast< int >(val8);
5701 }
5702 if (obj8) {
5703 ecode9 = SWIG_AsVal_int(obj8, &val9);
5704 if (!SWIG_IsOK(ecode9)) {
5705 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5706 }
5707 arg9 = static_cast< int >(val9);
5708 }
5709 {
5710 if (!wxPyCheckForApp()) SWIG_fail;
5711 PyThreadState* __tstate = wxPyBeginAllowThreads();
5712 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5713 wxPyEndAllowThreads(__tstate);
5714 if (PyErr_Occurred()) SWIG_fail;
5715 }
5716 {
5717 #if wxUSE_UNICODE
5718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5719 #else
5720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5721 #endif
5722 }
5723 {
5724 if (temp1)
5725 delete arg1;
5726 }
5727 {
5728 if (temp2)
5729 delete arg2;
5730 }
5731 {
5732 if (temp3)
5733 delete arg3;
5734 }
5735 {
5736 if (temp4)
5737 delete arg4;
5738 }
5739 {
5740 if (temp5)
5741 delete arg5;
5742 }
5743 return resultobj;
5744 fail:
5745 {
5746 if (temp1)
5747 delete arg1;
5748 }
5749 {
5750 if (temp2)
5751 delete arg2;
5752 }
5753 {
5754 if (temp3)
5755 delete arg3;
5756 }
5757 {
5758 if (temp4)
5759 delete arg4;
5760 }
5761 {
5762 if (temp5)
5763 delete arg5;
5764 }
5765 return NULL;
5766 }
5767
5768
5769 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5770 PyObject *resultobj = 0;
5771 wxString *arg1 = 0 ;
5772 wxString *arg2 = 0 ;
5773 wxString const &arg3_defvalue = wxPyEmptyString ;
5774 wxString *arg3 = (wxString *) &arg3_defvalue ;
5775 wxWindow *arg4 = (wxWindow *) NULL ;
5776 wxString result;
5777 bool temp1 = false ;
5778 bool temp2 = false ;
5779 bool temp3 = false ;
5780 void *argp4 = 0 ;
5781 int res4 = 0 ;
5782 PyObject * obj0 = 0 ;
5783 PyObject * obj1 = 0 ;
5784 PyObject * obj2 = 0 ;
5785 PyObject * obj3 = 0 ;
5786 char * kwnames[] = {
5787 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5788 };
5789
5790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5791 {
5792 arg1 = wxString_in_helper(obj0);
5793 if (arg1 == NULL) SWIG_fail;
5794 temp1 = true;
5795 }
5796 {
5797 arg2 = wxString_in_helper(obj1);
5798 if (arg2 == NULL) SWIG_fail;
5799 temp2 = true;
5800 }
5801 if (obj2) {
5802 {
5803 arg3 = wxString_in_helper(obj2);
5804 if (arg3 == NULL) SWIG_fail;
5805 temp3 = true;
5806 }
5807 }
5808 if (obj3) {
5809 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5810 if (!SWIG_IsOK(res4)) {
5811 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5812 }
5813 arg4 = reinterpret_cast< wxWindow * >(argp4);
5814 }
5815 {
5816 if (!wxPyCheckForApp()) SWIG_fail;
5817 PyThreadState* __tstate = wxPyBeginAllowThreads();
5818 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5819 wxPyEndAllowThreads(__tstate);
5820 if (PyErr_Occurred()) SWIG_fail;
5821 }
5822 {
5823 #if wxUSE_UNICODE
5824 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5825 #else
5826 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5827 #endif
5828 }
5829 {
5830 if (temp1)
5831 delete arg1;
5832 }
5833 {
5834 if (temp2)
5835 delete arg2;
5836 }
5837 {
5838 if (temp3)
5839 delete arg3;
5840 }
5841 return resultobj;
5842 fail:
5843 {
5844 if (temp1)
5845 delete arg1;
5846 }
5847 {
5848 if (temp2)
5849 delete arg2;
5850 }
5851 {
5852 if (temp3)
5853 delete arg3;
5854 }
5855 return NULL;
5856 }
5857
5858
5859 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5860 PyObject *resultobj = 0;
5861 wxString *arg1 = 0 ;
5862 wxString *arg2 = 0 ;
5863 wxString const &arg3_defvalue = wxPyEmptyString ;
5864 wxString *arg3 = (wxString *) &arg3_defvalue ;
5865 wxWindow *arg4 = (wxWindow *) NULL ;
5866 wxString result;
5867 bool temp1 = false ;
5868 bool temp2 = false ;
5869 bool temp3 = false ;
5870 void *argp4 = 0 ;
5871 int res4 = 0 ;
5872 PyObject * obj0 = 0 ;
5873 PyObject * obj1 = 0 ;
5874 PyObject * obj2 = 0 ;
5875 PyObject * obj3 = 0 ;
5876 char * kwnames[] = {
5877 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5878 };
5879
5880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5881 {
5882 arg1 = wxString_in_helper(obj0);
5883 if (arg1 == NULL) SWIG_fail;
5884 temp1 = true;
5885 }
5886 {
5887 arg2 = wxString_in_helper(obj1);
5888 if (arg2 == NULL) SWIG_fail;
5889 temp2 = true;
5890 }
5891 if (obj2) {
5892 {
5893 arg3 = wxString_in_helper(obj2);
5894 if (arg3 == NULL) SWIG_fail;
5895 temp3 = true;
5896 }
5897 }
5898 if (obj3) {
5899 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5900 if (!SWIG_IsOK(res4)) {
5901 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5902 }
5903 arg4 = reinterpret_cast< wxWindow * >(argp4);
5904 }
5905 {
5906 if (!wxPyCheckForApp()) SWIG_fail;
5907 PyThreadState* __tstate = wxPyBeginAllowThreads();
5908 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5909 wxPyEndAllowThreads(__tstate);
5910 if (PyErr_Occurred()) SWIG_fail;
5911 }
5912 {
5913 #if wxUSE_UNICODE
5914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5915 #else
5916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5917 #endif
5918 }
5919 {
5920 if (temp1)
5921 delete arg1;
5922 }
5923 {
5924 if (temp2)
5925 delete arg2;
5926 }
5927 {
5928 if (temp3)
5929 delete arg3;
5930 }
5931 return resultobj;
5932 fail:
5933 {
5934 if (temp1)
5935 delete arg1;
5936 }
5937 {
5938 if (temp2)
5939 delete arg2;
5940 }
5941 {
5942 if (temp3)
5943 delete arg3;
5944 }
5945 return NULL;
5946 }
5947
5948
5949 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5950 PyObject *resultobj = 0;
5951 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5952 wxString *arg1 = (wxString *) &arg1_defvalue ;
5953 wxString const &arg2_defvalue = wxPyEmptyString ;
5954 wxString *arg2 = (wxString *) &arg2_defvalue ;
5955 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5956 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5957 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5958 wxWindow *arg5 = (wxWindow *) NULL ;
5959 wxString result;
5960 bool temp1 = false ;
5961 bool temp2 = false ;
5962 long val3 ;
5963 int ecode3 = 0 ;
5964 wxPoint temp4 ;
5965 void *argp5 = 0 ;
5966 int res5 = 0 ;
5967 PyObject * obj0 = 0 ;
5968 PyObject * obj1 = 0 ;
5969 PyObject * obj2 = 0 ;
5970 PyObject * obj3 = 0 ;
5971 PyObject * obj4 = 0 ;
5972 char * kwnames[] = {
5973 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5974 };
5975
5976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5977 if (obj0) {
5978 {
5979 arg1 = wxString_in_helper(obj0);
5980 if (arg1 == NULL) SWIG_fail;
5981 temp1 = true;
5982 }
5983 }
5984 if (obj1) {
5985 {
5986 arg2 = wxString_in_helper(obj1);
5987 if (arg2 == NULL) SWIG_fail;
5988 temp2 = true;
5989 }
5990 }
5991 if (obj2) {
5992 ecode3 = SWIG_AsVal_long(obj2, &val3);
5993 if (!SWIG_IsOK(ecode3)) {
5994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5995 }
5996 arg3 = static_cast< long >(val3);
5997 }
5998 if (obj3) {
5999 {
6000 arg4 = &temp4;
6001 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6002 }
6003 }
6004 if (obj4) {
6005 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6006 if (!SWIG_IsOK(res5)) {
6007 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6008 }
6009 arg5 = reinterpret_cast< wxWindow * >(argp5);
6010 }
6011 {
6012 if (!wxPyCheckForApp()) SWIG_fail;
6013 PyThreadState* __tstate = wxPyBeginAllowThreads();
6014 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6015 wxPyEndAllowThreads(__tstate);
6016 if (PyErr_Occurred()) SWIG_fail;
6017 }
6018 {
6019 #if wxUSE_UNICODE
6020 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6021 #else
6022 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6023 #endif
6024 }
6025 {
6026 if (temp1)
6027 delete arg1;
6028 }
6029 {
6030 if (temp2)
6031 delete arg2;
6032 }
6033 return resultobj;
6034 fail:
6035 {
6036 if (temp1)
6037 delete arg1;
6038 }
6039 {
6040 if (temp2)
6041 delete arg2;
6042 }
6043 return NULL;
6044 }
6045
6046
6047 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6048 PyObject *resultobj = 0;
6049 wxString *arg1 = 0 ;
6050 wxString const &arg2_defvalue = wxPyEmptyString ;
6051 wxString *arg2 = (wxString *) &arg2_defvalue ;
6052 wxString const &arg3_defvalue = wxPyEmptyString ;
6053 wxString *arg3 = (wxString *) &arg3_defvalue ;
6054 wxWindow *arg4 = (wxWindow *) NULL ;
6055 int arg5 = (int) -1 ;
6056 int arg6 = (int) -1 ;
6057 bool arg7 = (bool) true ;
6058 wxString result;
6059 bool temp1 = false ;
6060 bool temp2 = false ;
6061 bool temp3 = false ;
6062 void *argp4 = 0 ;
6063 int res4 = 0 ;
6064 int val5 ;
6065 int ecode5 = 0 ;
6066 int val6 ;
6067 int ecode6 = 0 ;
6068 bool val7 ;
6069 int ecode7 = 0 ;
6070 PyObject * obj0 = 0 ;
6071 PyObject * obj1 = 0 ;
6072 PyObject * obj2 = 0 ;
6073 PyObject * obj3 = 0 ;
6074 PyObject * obj4 = 0 ;
6075 PyObject * obj5 = 0 ;
6076 PyObject * obj6 = 0 ;
6077 char * kwnames[] = {
6078 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6079 };
6080
6081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6082 {
6083 arg1 = wxString_in_helper(obj0);
6084 if (arg1 == NULL) SWIG_fail;
6085 temp1 = true;
6086 }
6087 if (obj1) {
6088 {
6089 arg2 = wxString_in_helper(obj1);
6090 if (arg2 == NULL) SWIG_fail;
6091 temp2 = true;
6092 }
6093 }
6094 if (obj2) {
6095 {
6096 arg3 = wxString_in_helper(obj2);
6097 if (arg3 == NULL) SWIG_fail;
6098 temp3 = true;
6099 }
6100 }
6101 if (obj3) {
6102 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6103 if (!SWIG_IsOK(res4)) {
6104 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6105 }
6106 arg4 = reinterpret_cast< wxWindow * >(argp4);
6107 }
6108 if (obj4) {
6109 ecode5 = SWIG_AsVal_int(obj4, &val5);
6110 if (!SWIG_IsOK(ecode5)) {
6111 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6112 }
6113 arg5 = static_cast< int >(val5);
6114 }
6115 if (obj5) {
6116 ecode6 = SWIG_AsVal_int(obj5, &val6);
6117 if (!SWIG_IsOK(ecode6)) {
6118 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6119 }
6120 arg6 = static_cast< int >(val6);
6121 }
6122 if (obj6) {
6123 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6124 if (!SWIG_IsOK(ecode7)) {
6125 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6126 }
6127 arg7 = static_cast< bool >(val7);
6128 }
6129 {
6130 if (!wxPyCheckForApp()) SWIG_fail;
6131 PyThreadState* __tstate = wxPyBeginAllowThreads();
6132 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6133 wxPyEndAllowThreads(__tstate);
6134 if (PyErr_Occurred()) SWIG_fail;
6135 }
6136 {
6137 #if wxUSE_UNICODE
6138 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6139 #else
6140 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6141 #endif
6142 }
6143 {
6144 if (temp1)
6145 delete arg1;
6146 }
6147 {
6148 if (temp2)
6149 delete arg2;
6150 }
6151 {
6152 if (temp3)
6153 delete arg3;
6154 }
6155 return resultobj;
6156 fail:
6157 {
6158 if (temp1)
6159 delete arg1;
6160 }
6161 {
6162 if (temp2)
6163 delete arg2;
6164 }
6165 {
6166 if (temp3)
6167 delete arg3;
6168 }
6169 return NULL;
6170 }
6171
6172
6173 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6174 PyObject *resultobj = 0;
6175 wxString *arg1 = 0 ;
6176 wxString const &arg2_defvalue = wxPyEmptyString ;
6177 wxString *arg2 = (wxString *) &arg2_defvalue ;
6178 wxString const &arg3_defvalue = wxPyEmptyString ;
6179 wxString *arg3 = (wxString *) &arg3_defvalue ;
6180 wxWindow *arg4 = (wxWindow *) NULL ;
6181 wxString result;
6182 bool temp1 = false ;
6183 bool temp2 = false ;
6184 bool temp3 = false ;
6185 void *argp4 = 0 ;
6186 int res4 = 0 ;
6187 PyObject * obj0 = 0 ;
6188 PyObject * obj1 = 0 ;
6189 PyObject * obj2 = 0 ;
6190 PyObject * obj3 = 0 ;
6191 char * kwnames[] = {
6192 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6193 };
6194
6195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6196 {
6197 arg1 = wxString_in_helper(obj0);
6198 if (arg1 == NULL) SWIG_fail;
6199 temp1 = true;
6200 }
6201 if (obj1) {
6202 {
6203 arg2 = wxString_in_helper(obj1);
6204 if (arg2 == NULL) SWIG_fail;
6205 temp2 = true;
6206 }
6207 }
6208 if (obj2) {
6209 {
6210 arg3 = wxString_in_helper(obj2);
6211 if (arg3 == NULL) SWIG_fail;
6212 temp3 = true;
6213 }
6214 }
6215 if (obj3) {
6216 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6217 if (!SWIG_IsOK(res4)) {
6218 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6219 }
6220 arg4 = reinterpret_cast< wxWindow * >(argp4);
6221 }
6222 {
6223 if (!wxPyCheckForApp()) SWIG_fail;
6224 PyThreadState* __tstate = wxPyBeginAllowThreads();
6225 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6226 wxPyEndAllowThreads(__tstate);
6227 if (PyErr_Occurred()) SWIG_fail;
6228 }
6229 {
6230 #if wxUSE_UNICODE
6231 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6232 #else
6233 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6234 #endif
6235 }
6236 {
6237 if (temp1)
6238 delete arg1;
6239 }
6240 {
6241 if (temp2)
6242 delete arg2;
6243 }
6244 {
6245 if (temp3)
6246 delete arg3;
6247 }
6248 return resultobj;
6249 fail:
6250 {
6251 if (temp1)
6252 delete arg1;
6253 }
6254 {
6255 if (temp2)
6256 delete arg2;
6257 }
6258 {
6259 if (temp3)
6260 delete arg3;
6261 }
6262 return NULL;
6263 }
6264
6265
6266 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6267 PyObject *resultobj = 0;
6268 wxString *arg1 = 0 ;
6269 wxString *arg2 = 0 ;
6270 int arg3 ;
6271 wxString *arg4 = (wxString *) 0 ;
6272 wxWindow *arg5 = (wxWindow *) NULL ;
6273 int arg6 = (int) -1 ;
6274 int arg7 = (int) -1 ;
6275 bool arg8 = (bool) true ;
6276 int arg9 = (int) 150 ;
6277 int arg10 = (int) 200 ;
6278 wxString result;
6279 bool temp1 = false ;
6280 bool temp2 = false ;
6281 void *argp5 = 0 ;
6282 int res5 = 0 ;
6283 int val6 ;
6284 int ecode6 = 0 ;
6285 int val7 ;
6286 int ecode7 = 0 ;
6287 bool val8 ;
6288 int ecode8 = 0 ;
6289 int val9 ;
6290 int ecode9 = 0 ;
6291 int val10 ;
6292 int ecode10 = 0 ;
6293 PyObject * obj0 = 0 ;
6294 PyObject * obj1 = 0 ;
6295 PyObject * obj2 = 0 ;
6296 PyObject * obj3 = 0 ;
6297 PyObject * obj4 = 0 ;
6298 PyObject * obj5 = 0 ;
6299 PyObject * obj6 = 0 ;
6300 PyObject * obj7 = 0 ;
6301 PyObject * obj8 = 0 ;
6302 char * kwnames[] = {
6303 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6304 };
6305
6306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6307 {
6308 arg1 = wxString_in_helper(obj0);
6309 if (arg1 == NULL) SWIG_fail;
6310 temp1 = true;
6311 }
6312 {
6313 arg2 = wxString_in_helper(obj1);
6314 if (arg2 == NULL) SWIG_fail;
6315 temp2 = true;
6316 }
6317 {
6318 arg3 = PyList_Size(obj2);
6319 arg4 = wxString_LIST_helper(obj2);
6320 if (arg4 == NULL) SWIG_fail;
6321 }
6322 if (obj3) {
6323 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6324 if (!SWIG_IsOK(res5)) {
6325 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6326 }
6327 arg5 = reinterpret_cast< wxWindow * >(argp5);
6328 }
6329 if (obj4) {
6330 ecode6 = SWIG_AsVal_int(obj4, &val6);
6331 if (!SWIG_IsOK(ecode6)) {
6332 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6333 }
6334 arg6 = static_cast< int >(val6);
6335 }
6336 if (obj5) {
6337 ecode7 = SWIG_AsVal_int(obj5, &val7);
6338 if (!SWIG_IsOK(ecode7)) {
6339 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6340 }
6341 arg7 = static_cast< int >(val7);
6342 }
6343 if (obj6) {
6344 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6345 if (!SWIG_IsOK(ecode8)) {
6346 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6347 }
6348 arg8 = static_cast< bool >(val8);
6349 }
6350 if (obj7) {
6351 ecode9 = SWIG_AsVal_int(obj7, &val9);
6352 if (!SWIG_IsOK(ecode9)) {
6353 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6354 }
6355 arg9 = static_cast< int >(val9);
6356 }
6357 if (obj8) {
6358 ecode10 = SWIG_AsVal_int(obj8, &val10);
6359 if (!SWIG_IsOK(ecode10)) {
6360 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6361 }
6362 arg10 = static_cast< int >(val10);
6363 }
6364 {
6365 if (!wxPyCheckForApp()) SWIG_fail;
6366 PyThreadState* __tstate = wxPyBeginAllowThreads();
6367 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6368 wxPyEndAllowThreads(__tstate);
6369 if (PyErr_Occurred()) SWIG_fail;
6370 }
6371 {
6372 #if wxUSE_UNICODE
6373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6374 #else
6375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6376 #endif
6377 }
6378 {
6379 if (temp1)
6380 delete arg1;
6381 }
6382 {
6383 if (temp2)
6384 delete arg2;
6385 }
6386 {
6387 if (arg4) delete [] arg4;
6388 }
6389 return resultobj;
6390 fail:
6391 {
6392 if (temp1)
6393 delete arg1;
6394 }
6395 {
6396 if (temp2)
6397 delete arg2;
6398 }
6399 {
6400 if (arg4) delete [] arg4;
6401 }
6402 return NULL;
6403 }
6404
6405
6406 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6407 PyObject *resultobj = 0;
6408 wxString *arg1 = 0 ;
6409 wxString *arg2 = 0 ;
6410 int arg3 ;
6411 wxString *arg4 = (wxString *) 0 ;
6412 wxWindow *arg5 = (wxWindow *) NULL ;
6413 int arg6 = (int) -1 ;
6414 int arg7 = (int) -1 ;
6415 bool arg8 = (bool) true ;
6416 int arg9 = (int) 150 ;
6417 int arg10 = (int) 200 ;
6418 int result;
6419 bool temp1 = false ;
6420 bool temp2 = false ;
6421 void *argp5 = 0 ;
6422 int res5 = 0 ;
6423 int val6 ;
6424 int ecode6 = 0 ;
6425 int val7 ;
6426 int ecode7 = 0 ;
6427 bool val8 ;
6428 int ecode8 = 0 ;
6429 int val9 ;
6430 int ecode9 = 0 ;
6431 int val10 ;
6432 int ecode10 = 0 ;
6433 PyObject * obj0 = 0 ;
6434 PyObject * obj1 = 0 ;
6435 PyObject * obj2 = 0 ;
6436 PyObject * obj3 = 0 ;
6437 PyObject * obj4 = 0 ;
6438 PyObject * obj5 = 0 ;
6439 PyObject * obj6 = 0 ;
6440 PyObject * obj7 = 0 ;
6441 PyObject * obj8 = 0 ;
6442 char * kwnames[] = {
6443 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6444 };
6445
6446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6447 {
6448 arg1 = wxString_in_helper(obj0);
6449 if (arg1 == NULL) SWIG_fail;
6450 temp1 = true;
6451 }
6452 {
6453 arg2 = wxString_in_helper(obj1);
6454 if (arg2 == NULL) SWIG_fail;
6455 temp2 = true;
6456 }
6457 {
6458 arg3 = PyList_Size(obj2);
6459 arg4 = wxString_LIST_helper(obj2);
6460 if (arg4 == NULL) SWIG_fail;
6461 }
6462 if (obj3) {
6463 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6464 if (!SWIG_IsOK(res5)) {
6465 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6466 }
6467 arg5 = reinterpret_cast< wxWindow * >(argp5);
6468 }
6469 if (obj4) {
6470 ecode6 = SWIG_AsVal_int(obj4, &val6);
6471 if (!SWIG_IsOK(ecode6)) {
6472 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6473 }
6474 arg6 = static_cast< int >(val6);
6475 }
6476 if (obj5) {
6477 ecode7 = SWIG_AsVal_int(obj5, &val7);
6478 if (!SWIG_IsOK(ecode7)) {
6479 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6480 }
6481 arg7 = static_cast< int >(val7);
6482 }
6483 if (obj6) {
6484 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6485 if (!SWIG_IsOK(ecode8)) {
6486 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6487 }
6488 arg8 = static_cast< bool >(val8);
6489 }
6490 if (obj7) {
6491 ecode9 = SWIG_AsVal_int(obj7, &val9);
6492 if (!SWIG_IsOK(ecode9)) {
6493 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6494 }
6495 arg9 = static_cast< int >(val9);
6496 }
6497 if (obj8) {
6498 ecode10 = SWIG_AsVal_int(obj8, &val10);
6499 if (!SWIG_IsOK(ecode10)) {
6500 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6501 }
6502 arg10 = static_cast< int >(val10);
6503 }
6504 {
6505 if (!wxPyCheckForApp()) SWIG_fail;
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6508 wxPyEndAllowThreads(__tstate);
6509 if (PyErr_Occurred()) SWIG_fail;
6510 }
6511 resultobj = SWIG_From_int(static_cast< int >(result));
6512 {
6513 if (temp1)
6514 delete arg1;
6515 }
6516 {
6517 if (temp2)
6518 delete arg2;
6519 }
6520 {
6521 if (arg4) delete [] arg4;
6522 }
6523 return resultobj;
6524 fail:
6525 {
6526 if (temp1)
6527 delete arg1;
6528 }
6529 {
6530 if (temp2)
6531 delete arg2;
6532 }
6533 {
6534 if (arg4) delete [] arg4;
6535 }
6536 return NULL;
6537 }
6538
6539
6540 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6541 PyObject *resultobj = 0;
6542 wxString *arg1 = 0 ;
6543 wxString const &arg2_defvalue = wxPyEmptyString ;
6544 wxString *arg2 = (wxString *) &arg2_defvalue ;
6545 int arg3 = (int) wxOK|wxCENTRE ;
6546 wxWindow *arg4 = (wxWindow *) NULL ;
6547 int arg5 = (int) -1 ;
6548 int arg6 = (int) -1 ;
6549 int result;
6550 bool temp1 = false ;
6551 bool temp2 = false ;
6552 int val3 ;
6553 int ecode3 = 0 ;
6554 void *argp4 = 0 ;
6555 int res4 = 0 ;
6556 int val5 ;
6557 int ecode5 = 0 ;
6558 int val6 ;
6559 int ecode6 = 0 ;
6560 PyObject * obj0 = 0 ;
6561 PyObject * obj1 = 0 ;
6562 PyObject * obj2 = 0 ;
6563 PyObject * obj3 = 0 ;
6564 PyObject * obj4 = 0 ;
6565 PyObject * obj5 = 0 ;
6566 char * kwnames[] = {
6567 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6568 };
6569
6570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6571 {
6572 arg1 = wxString_in_helper(obj0);
6573 if (arg1 == NULL) SWIG_fail;
6574 temp1 = true;
6575 }
6576 if (obj1) {
6577 {
6578 arg2 = wxString_in_helper(obj1);
6579 if (arg2 == NULL) SWIG_fail;
6580 temp2 = true;
6581 }
6582 }
6583 if (obj2) {
6584 ecode3 = SWIG_AsVal_int(obj2, &val3);
6585 if (!SWIG_IsOK(ecode3)) {
6586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6587 }
6588 arg3 = static_cast< int >(val3);
6589 }
6590 if (obj3) {
6591 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6592 if (!SWIG_IsOK(res4)) {
6593 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6594 }
6595 arg4 = reinterpret_cast< wxWindow * >(argp4);
6596 }
6597 if (obj4) {
6598 ecode5 = SWIG_AsVal_int(obj4, &val5);
6599 if (!SWIG_IsOK(ecode5)) {
6600 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6601 }
6602 arg5 = static_cast< int >(val5);
6603 }
6604 if (obj5) {
6605 ecode6 = SWIG_AsVal_int(obj5, &val6);
6606 if (!SWIG_IsOK(ecode6)) {
6607 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6608 }
6609 arg6 = static_cast< int >(val6);
6610 }
6611 {
6612 if (!wxPyCheckForApp()) SWIG_fail;
6613 PyThreadState* __tstate = wxPyBeginAllowThreads();
6614 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6615 wxPyEndAllowThreads(__tstate);
6616 if (PyErr_Occurred()) SWIG_fail;
6617 }
6618 resultobj = SWIG_From_int(static_cast< int >(result));
6619 {
6620 if (temp1)
6621 delete arg1;
6622 }
6623 {
6624 if (temp2)
6625 delete arg2;
6626 }
6627 return resultobj;
6628 fail:
6629 {
6630 if (temp1)
6631 delete arg1;
6632 }
6633 {
6634 if (temp2)
6635 delete arg2;
6636 }
6637 return NULL;
6638 }
6639
6640
6641 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6642 PyObject *resultobj = 0;
6643 wxString *arg1 = 0 ;
6644 wxString *arg2 = 0 ;
6645 wxString *arg3 = 0 ;
6646 long arg4 ;
6647 long arg5 = (long) 0 ;
6648 long arg6 = (long) 100 ;
6649 wxWindow *arg7 = (wxWindow *) NULL ;
6650 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6651 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6652 long result;
6653 bool temp1 = false ;
6654 bool temp2 = false ;
6655 bool temp3 = false ;
6656 long val4 ;
6657 int ecode4 = 0 ;
6658 long val5 ;
6659 int ecode5 = 0 ;
6660 long val6 ;
6661 int ecode6 = 0 ;
6662 void *argp7 = 0 ;
6663 int res7 = 0 ;
6664 wxPoint temp8 ;
6665 PyObject * obj0 = 0 ;
6666 PyObject * obj1 = 0 ;
6667 PyObject * obj2 = 0 ;
6668 PyObject * obj3 = 0 ;
6669 PyObject * obj4 = 0 ;
6670 PyObject * obj5 = 0 ;
6671 PyObject * obj6 = 0 ;
6672 PyObject * obj7 = 0 ;
6673 char * kwnames[] = {
6674 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6675 };
6676
6677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6678 {
6679 arg1 = wxString_in_helper(obj0);
6680 if (arg1 == NULL) SWIG_fail;
6681 temp1 = true;
6682 }
6683 {
6684 arg2 = wxString_in_helper(obj1);
6685 if (arg2 == NULL) SWIG_fail;
6686 temp2 = true;
6687 }
6688 {
6689 arg3 = wxString_in_helper(obj2);
6690 if (arg3 == NULL) SWIG_fail;
6691 temp3 = true;
6692 }
6693 ecode4 = SWIG_AsVal_long(obj3, &val4);
6694 if (!SWIG_IsOK(ecode4)) {
6695 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6696 }
6697 arg4 = static_cast< long >(val4);
6698 if (obj4) {
6699 ecode5 = SWIG_AsVal_long(obj4, &val5);
6700 if (!SWIG_IsOK(ecode5)) {
6701 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6702 }
6703 arg5 = static_cast< long >(val5);
6704 }
6705 if (obj5) {
6706 ecode6 = SWIG_AsVal_long(obj5, &val6);
6707 if (!SWIG_IsOK(ecode6)) {
6708 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6709 }
6710 arg6 = static_cast< long >(val6);
6711 }
6712 if (obj6) {
6713 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6714 if (!SWIG_IsOK(res7)) {
6715 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6716 }
6717 arg7 = reinterpret_cast< wxWindow * >(argp7);
6718 }
6719 if (obj7) {
6720 {
6721 arg8 = &temp8;
6722 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6723 }
6724 }
6725 {
6726 if (!wxPyCheckForApp()) SWIG_fail;
6727 PyThreadState* __tstate = wxPyBeginAllowThreads();
6728 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6729 wxPyEndAllowThreads(__tstate);
6730 if (PyErr_Occurred()) SWIG_fail;
6731 }
6732 resultobj = SWIG_From_long(static_cast< long >(result));
6733 {
6734 if (temp1)
6735 delete arg1;
6736 }
6737 {
6738 if (temp2)
6739 delete arg2;
6740 }
6741 {
6742 if (temp3)
6743 delete arg3;
6744 }
6745 return resultobj;
6746 fail:
6747 {
6748 if (temp1)
6749 delete arg1;
6750 }
6751 {
6752 if (temp2)
6753 delete arg2;
6754 }
6755 {
6756 if (temp3)
6757 delete arg3;
6758 }
6759 return NULL;
6760 }
6761
6762
6763 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6764 PyObject *resultobj = 0;
6765 bool result;
6766
6767 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6768 {
6769 if (!wxPyCheckForApp()) SWIG_fail;
6770 PyThreadState* __tstate = wxPyBeginAllowThreads();
6771 result = (bool)wxColourDisplay();
6772 wxPyEndAllowThreads(__tstate);
6773 if (PyErr_Occurred()) SWIG_fail;
6774 }
6775 {
6776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6777 }
6778 return resultobj;
6779 fail:
6780 return NULL;
6781 }
6782
6783
6784 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6785 PyObject *resultobj = 0;
6786 int result;
6787
6788 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6789 {
6790 if (!wxPyCheckForApp()) SWIG_fail;
6791 PyThreadState* __tstate = wxPyBeginAllowThreads();
6792 result = (int)wxDisplayDepth();
6793 wxPyEndAllowThreads(__tstate);
6794 if (PyErr_Occurred()) SWIG_fail;
6795 }
6796 resultobj = SWIG_From_int(static_cast< int >(result));
6797 return resultobj;
6798 fail:
6799 return NULL;
6800 }
6801
6802
6803 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6804 PyObject *resultobj = 0;
6805 int result;
6806
6807 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6808 {
6809 if (!wxPyCheckForApp()) SWIG_fail;
6810 PyThreadState* __tstate = wxPyBeginAllowThreads();
6811 result = (int)wxGetDisplayDepth();
6812 wxPyEndAllowThreads(__tstate);
6813 if (PyErr_Occurred()) SWIG_fail;
6814 }
6815 resultobj = SWIG_From_int(static_cast< int >(result));
6816 return resultobj;
6817 fail:
6818 return NULL;
6819 }
6820
6821
6822 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6823 PyObject *resultobj = 0;
6824 int *arg1 = (int *) 0 ;
6825 int *arg2 = (int *) 0 ;
6826 int temp1 ;
6827 int res1 = SWIG_TMPOBJ ;
6828 int temp2 ;
6829 int res2 = SWIG_TMPOBJ ;
6830
6831 arg1 = &temp1;
6832 arg2 = &temp2;
6833 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6834 {
6835 if (!wxPyCheckForApp()) SWIG_fail;
6836 PyThreadState* __tstate = wxPyBeginAllowThreads();
6837 wxDisplaySize(arg1,arg2);
6838 wxPyEndAllowThreads(__tstate);
6839 if (PyErr_Occurred()) SWIG_fail;
6840 }
6841 resultobj = SWIG_Py_Void();
6842 if (SWIG_IsTmpObj(res1)) {
6843 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6844 } else {
6845 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6846 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6847 }
6848 if (SWIG_IsTmpObj(res2)) {
6849 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6850 } else {
6851 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6852 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6853 }
6854 return resultobj;
6855 fail:
6856 return NULL;
6857 }
6858
6859
6860 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6861 PyObject *resultobj = 0;
6862 wxSize result;
6863
6864 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6865 {
6866 if (!wxPyCheckForApp()) SWIG_fail;
6867 PyThreadState* __tstate = wxPyBeginAllowThreads();
6868 result = wxGetDisplaySize();
6869 wxPyEndAllowThreads(__tstate);
6870 if (PyErr_Occurred()) SWIG_fail;
6871 }
6872 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6873 return resultobj;
6874 fail:
6875 return NULL;
6876 }
6877
6878
6879 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6880 PyObject *resultobj = 0;
6881 int *arg1 = (int *) 0 ;
6882 int *arg2 = (int *) 0 ;
6883 int temp1 ;
6884 int res1 = SWIG_TMPOBJ ;
6885 int temp2 ;
6886 int res2 = SWIG_TMPOBJ ;
6887
6888 arg1 = &temp1;
6889 arg2 = &temp2;
6890 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6891 {
6892 if (!wxPyCheckForApp()) SWIG_fail;
6893 PyThreadState* __tstate = wxPyBeginAllowThreads();
6894 wxDisplaySizeMM(arg1,arg2);
6895 wxPyEndAllowThreads(__tstate);
6896 if (PyErr_Occurred()) SWIG_fail;
6897 }
6898 resultobj = SWIG_Py_Void();
6899 if (SWIG_IsTmpObj(res1)) {
6900 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6901 } else {
6902 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6903 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6904 }
6905 if (SWIG_IsTmpObj(res2)) {
6906 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6907 } else {
6908 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6909 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6910 }
6911 return resultobj;
6912 fail:
6913 return NULL;
6914 }
6915
6916
6917 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6918 PyObject *resultobj = 0;
6919 wxSize result;
6920
6921 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6922 {
6923 if (!wxPyCheckForApp()) SWIG_fail;
6924 PyThreadState* __tstate = wxPyBeginAllowThreads();
6925 result = wxGetDisplaySizeMM();
6926 wxPyEndAllowThreads(__tstate);
6927 if (PyErr_Occurred()) SWIG_fail;
6928 }
6929 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6930 return resultobj;
6931 fail:
6932 return NULL;
6933 }
6934
6935
6936 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6937 PyObject *resultobj = 0;
6938 int *arg1 = (int *) 0 ;
6939 int *arg2 = (int *) 0 ;
6940 int *arg3 = (int *) 0 ;
6941 int *arg4 = (int *) 0 ;
6942 int temp1 ;
6943 int res1 = SWIG_TMPOBJ ;
6944 int temp2 ;
6945 int res2 = SWIG_TMPOBJ ;
6946 int temp3 ;
6947 int res3 = SWIG_TMPOBJ ;
6948 int temp4 ;
6949 int res4 = SWIG_TMPOBJ ;
6950
6951 arg1 = &temp1;
6952 arg2 = &temp2;
6953 arg3 = &temp3;
6954 arg4 = &temp4;
6955 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6956 {
6957 if (!wxPyCheckForApp()) SWIG_fail;
6958 PyThreadState* __tstate = wxPyBeginAllowThreads();
6959 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6960 wxPyEndAllowThreads(__tstate);
6961 if (PyErr_Occurred()) SWIG_fail;
6962 }
6963 resultobj = SWIG_Py_Void();
6964 if (SWIG_IsTmpObj(res1)) {
6965 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6966 } else {
6967 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6969 }
6970 if (SWIG_IsTmpObj(res2)) {
6971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6972 } else {
6973 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6974 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6975 }
6976 if (SWIG_IsTmpObj(res3)) {
6977 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6978 } else {
6979 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6980 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6981 }
6982 if (SWIG_IsTmpObj(res4)) {
6983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6984 } else {
6985 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6987 }
6988 return resultobj;
6989 fail:
6990 return NULL;
6991 }
6992
6993
6994 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6995 PyObject *resultobj = 0;
6996 wxRect result;
6997
6998 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6999 {
7000 if (!wxPyCheckForApp()) SWIG_fail;
7001 PyThreadState* __tstate = wxPyBeginAllowThreads();
7002 result = wxGetClientDisplayRect();
7003 wxPyEndAllowThreads(__tstate);
7004 if (PyErr_Occurred()) SWIG_fail;
7005 }
7006 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7007 return resultobj;
7008 fail:
7009 return NULL;
7010 }
7011
7012
7013 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7014 PyObject *resultobj = 0;
7015 wxCursor *arg1 = 0 ;
7016 void *argp1 = 0 ;
7017 int res1 = 0 ;
7018 PyObject * obj0 = 0 ;
7019 char * kwnames[] = {
7020 (char *) "cursor", NULL
7021 };
7022
7023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7024 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7025 if (!SWIG_IsOK(res1)) {
7026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7027 }
7028 if (!argp1) {
7029 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7030 }
7031 arg1 = reinterpret_cast< wxCursor * >(argp1);
7032 {
7033 if (!wxPyCheckForApp()) SWIG_fail;
7034 PyThreadState* __tstate = wxPyBeginAllowThreads();
7035 wxSetCursor(*arg1);
7036 wxPyEndAllowThreads(__tstate);
7037 if (PyErr_Occurred()) SWIG_fail;
7038 }
7039 resultobj = SWIG_Py_Void();
7040 return resultobj;
7041 fail:
7042 return NULL;
7043 }
7044
7045
7046 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7047 PyObject *resultobj = 0;
7048 void *result = 0 ;
7049
7050 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7051 {
7052 if (!wxPyCheckForApp()) SWIG_fail;
7053 PyThreadState* __tstate = wxPyBeginAllowThreads();
7054 result = (void *)wxGetXDisplay();
7055 wxPyEndAllowThreads(__tstate);
7056 if (PyErr_Occurred()) SWIG_fail;
7057 }
7058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7059 return resultobj;
7060 fail:
7061 return NULL;
7062 }
7063
7064
7065 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7066 PyObject *resultobj = 0;
7067 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7068 void *argp1 = 0 ;
7069 int res1 = 0 ;
7070 PyObject * obj0 = 0 ;
7071 char * kwnames[] = {
7072 (char *) "cursor", NULL
7073 };
7074
7075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7076 if (obj0) {
7077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7078 if (!SWIG_IsOK(res1)) {
7079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7080 }
7081 arg1 = reinterpret_cast< wxCursor * >(argp1);
7082 }
7083 {
7084 if (!wxPyCheckForApp()) SWIG_fail;
7085 PyThreadState* __tstate = wxPyBeginAllowThreads();
7086 wxBeginBusyCursor(arg1);
7087 wxPyEndAllowThreads(__tstate);
7088 if (PyErr_Occurred()) SWIG_fail;
7089 }
7090 resultobj = SWIG_Py_Void();
7091 return resultobj;
7092 fail:
7093 return NULL;
7094 }
7095
7096
7097 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7098 PyObject *resultobj = 0;
7099 wxPoint result;
7100
7101 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7102 {
7103 if (!wxPyCheckForApp()) SWIG_fail;
7104 PyThreadState* __tstate = wxPyBeginAllowThreads();
7105 result = wxGetMousePosition();
7106 wxPyEndAllowThreads(__tstate);
7107 if (PyErr_Occurred()) SWIG_fail;
7108 }
7109 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7110 return resultobj;
7111 fail:
7112 return NULL;
7113 }
7114
7115
7116 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7117 PyObject *resultobj = 0;
7118 wxWindow *result = 0 ;
7119
7120 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7121 {
7122 if (!wxPyCheckForApp()) SWIG_fail;
7123 PyThreadState* __tstate = wxPyBeginAllowThreads();
7124 result = (wxWindow *)FindWindowAtPointer();
7125 wxPyEndAllowThreads(__tstate);
7126 if (PyErr_Occurred()) SWIG_fail;
7127 }
7128 {
7129 resultobj = wxPyMake_wxObject(result, 0);
7130 }
7131 return resultobj;
7132 fail:
7133 return NULL;
7134 }
7135
7136
7137 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7138 PyObject *resultobj = 0;
7139 wxWindow *result = 0 ;
7140
7141 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7142 {
7143 if (!wxPyCheckForApp()) SWIG_fail;
7144 PyThreadState* __tstate = wxPyBeginAllowThreads();
7145 result = (wxWindow *)wxGetActiveWindow();
7146 wxPyEndAllowThreads(__tstate);
7147 if (PyErr_Occurred()) SWIG_fail;
7148 }
7149 {
7150 resultobj = wxPyMake_wxObject(result, 0);
7151 }
7152 return resultobj;
7153 fail:
7154 return NULL;
7155 }
7156
7157
7158 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7159 PyObject *resultobj = 0;
7160 wxPoint *arg1 = 0 ;
7161 wxWindow *result = 0 ;
7162 wxPoint temp1 ;
7163 PyObject * obj0 = 0 ;
7164 char * kwnames[] = {
7165 (char *) "pt", NULL
7166 };
7167
7168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7169 {
7170 arg1 = &temp1;
7171 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7172 }
7173 {
7174 if (!wxPyCheckForApp()) SWIG_fail;
7175 PyThreadState* __tstate = wxPyBeginAllowThreads();
7176 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7177 wxPyEndAllowThreads(__tstate);
7178 if (PyErr_Occurred()) SWIG_fail;
7179 }
7180 {
7181 resultobj = wxPyMake_wxObject(result, 0);
7182 }
7183 return resultobj;
7184 fail:
7185 return NULL;
7186 }
7187
7188
7189 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7190 PyObject *resultobj = 0;
7191 wxPoint *arg1 = 0 ;
7192 wxWindow *result = 0 ;
7193 wxPoint temp1 ;
7194 PyObject * obj0 = 0 ;
7195 char * kwnames[] = {
7196 (char *) "pt", NULL
7197 };
7198
7199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7200 {
7201 arg1 = &temp1;
7202 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7203 }
7204 {
7205 if (!wxPyCheckForApp()) SWIG_fail;
7206 PyThreadState* __tstate = wxPyBeginAllowThreads();
7207 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7208 wxPyEndAllowThreads(__tstate);
7209 if (PyErr_Occurred()) SWIG_fail;
7210 }
7211 {
7212 resultobj = wxPyMake_wxObject(result, 0);
7213 }
7214 return resultobj;
7215 fail:
7216 return NULL;
7217 }
7218
7219
7220 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7221 PyObject *resultobj = 0;
7222 wxWindow *arg1 = (wxWindow *) 0 ;
7223 wxWindow *result = 0 ;
7224 void *argp1 = 0 ;
7225 int res1 = 0 ;
7226 PyObject * obj0 = 0 ;
7227 char * kwnames[] = {
7228 (char *) "win", NULL
7229 };
7230
7231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7233 if (!SWIG_IsOK(res1)) {
7234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7235 }
7236 arg1 = reinterpret_cast< wxWindow * >(argp1);
7237 {
7238 if (!wxPyCheckForApp()) SWIG_fail;
7239 PyThreadState* __tstate = wxPyBeginAllowThreads();
7240 result = (wxWindow *)wxGetTopLevelParent(arg1);
7241 wxPyEndAllowThreads(__tstate);
7242 if (PyErr_Occurred()) SWIG_fail;
7243 }
7244 {
7245 resultobj = wxPyMake_wxObject(result, 0);
7246 }
7247 return resultobj;
7248 fail:
7249 return NULL;
7250 }
7251
7252
7253 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7254 PyObject *resultobj = 0;
7255 wxString *arg1 = 0 ;
7256 bool result;
7257 bool temp1 = false ;
7258 PyObject * obj0 = 0 ;
7259 char * kwnames[] = {
7260 (char *) "url", NULL
7261 };
7262
7263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7264 {
7265 arg1 = wxString_in_helper(obj0);
7266 if (arg1 == NULL) SWIG_fail;
7267 temp1 = true;
7268 }
7269 {
7270 PyThreadState* __tstate = wxPyBeginAllowThreads();
7271 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7272 wxPyEndAllowThreads(__tstate);
7273 if (PyErr_Occurred()) SWIG_fail;
7274 }
7275 {
7276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7277 }
7278 {
7279 if (temp1)
7280 delete arg1;
7281 }
7282 return resultobj;
7283 fail:
7284 {
7285 if (temp1)
7286 delete arg1;
7287 }
7288 return NULL;
7289 }
7290
7291
7292 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7293 PyObject *resultobj = 0;
7294 wxKeyCode arg1 ;
7295 bool result;
7296 int val1 ;
7297 int ecode1 = 0 ;
7298 PyObject * obj0 = 0 ;
7299 char * kwnames[] = {
7300 (char *) "key", NULL
7301 };
7302
7303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7304 ecode1 = SWIG_AsVal_int(obj0, &val1);
7305 if (!SWIG_IsOK(ecode1)) {
7306 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7307 }
7308 arg1 = static_cast< wxKeyCode >(val1);
7309 {
7310 if (!wxPyCheckForApp()) SWIG_fail;
7311 PyThreadState* __tstate = wxPyBeginAllowThreads();
7312 result = (bool)wxGetKeyState(arg1);
7313 wxPyEndAllowThreads(__tstate);
7314 if (PyErr_Occurred()) SWIG_fail;
7315 }
7316 {
7317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7318 }
7319 return resultobj;
7320 fail:
7321 return NULL;
7322 }
7323
7324
7325 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7326 PyObject *resultobj = 0;
7327 wxMouseState *result = 0 ;
7328
7329 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7330 {
7331 PyThreadState* __tstate = wxPyBeginAllowThreads();
7332 result = (wxMouseState *)new wxMouseState();
7333 wxPyEndAllowThreads(__tstate);
7334 if (PyErr_Occurred()) SWIG_fail;
7335 }
7336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7337 return resultobj;
7338 fail:
7339 return NULL;
7340 }
7341
7342
7343 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7344 PyObject *resultobj = 0;
7345 wxMouseState *arg1 = (wxMouseState *) 0 ;
7346 void *argp1 = 0 ;
7347 int res1 = 0 ;
7348 PyObject *swig_obj[1] ;
7349
7350 if (!args) SWIG_fail;
7351 swig_obj[0] = args;
7352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7353 if (!SWIG_IsOK(res1)) {
7354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7355 }
7356 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7357 {
7358 PyThreadState* __tstate = wxPyBeginAllowThreads();
7359 delete arg1;
7360
7361 wxPyEndAllowThreads(__tstate);
7362 if (PyErr_Occurred()) SWIG_fail;
7363 }
7364 resultobj = SWIG_Py_Void();
7365 return resultobj;
7366 fail:
7367 return NULL;
7368 }
7369
7370
7371 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7372 PyObject *resultobj = 0;
7373 wxMouseState *arg1 = (wxMouseState *) 0 ;
7374 int result;
7375 void *argp1 = 0 ;
7376 int res1 = 0 ;
7377 PyObject *swig_obj[1] ;
7378
7379 if (!args) SWIG_fail;
7380 swig_obj[0] = args;
7381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7382 if (!SWIG_IsOK(res1)) {
7383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7384 }
7385 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7386 {
7387 PyThreadState* __tstate = wxPyBeginAllowThreads();
7388 result = (int)(arg1)->GetX();
7389 wxPyEndAllowThreads(__tstate);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 resultobj = SWIG_From_int(static_cast< int >(result));
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7400 PyObject *resultobj = 0;
7401 wxMouseState *arg1 = (wxMouseState *) 0 ;
7402 int result;
7403 void *argp1 = 0 ;
7404 int res1 = 0 ;
7405 PyObject *swig_obj[1] ;
7406
7407 if (!args) SWIG_fail;
7408 swig_obj[0] = args;
7409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7410 if (!SWIG_IsOK(res1)) {
7411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7412 }
7413 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7414 {
7415 PyThreadState* __tstate = wxPyBeginAllowThreads();
7416 result = (int)(arg1)->GetY();
7417 wxPyEndAllowThreads(__tstate);
7418 if (PyErr_Occurred()) SWIG_fail;
7419 }
7420 resultobj = SWIG_From_int(static_cast< int >(result));
7421 return resultobj;
7422 fail:
7423 return NULL;
7424 }
7425
7426
7427 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7428 PyObject *resultobj = 0;
7429 wxMouseState *arg1 = (wxMouseState *) 0 ;
7430 bool result;
7431 void *argp1 = 0 ;
7432 int res1 = 0 ;
7433 PyObject *swig_obj[1] ;
7434
7435 if (!args) SWIG_fail;
7436 swig_obj[0] = args;
7437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7438 if (!SWIG_IsOK(res1)) {
7439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7440 }
7441 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7442 {
7443 PyThreadState* __tstate = wxPyBeginAllowThreads();
7444 result = (bool)(arg1)->LeftDown();
7445 wxPyEndAllowThreads(__tstate);
7446 if (PyErr_Occurred()) SWIG_fail;
7447 }
7448 {
7449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7450 }
7451 return resultobj;
7452 fail:
7453 return NULL;
7454 }
7455
7456
7457 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7458 PyObject *resultobj = 0;
7459 wxMouseState *arg1 = (wxMouseState *) 0 ;
7460 bool result;
7461 void *argp1 = 0 ;
7462 int res1 = 0 ;
7463 PyObject *swig_obj[1] ;
7464
7465 if (!args) SWIG_fail;
7466 swig_obj[0] = args;
7467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7468 if (!SWIG_IsOK(res1)) {
7469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7470 }
7471 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7472 {
7473 PyThreadState* __tstate = wxPyBeginAllowThreads();
7474 result = (bool)(arg1)->MiddleDown();
7475 wxPyEndAllowThreads(__tstate);
7476 if (PyErr_Occurred()) SWIG_fail;
7477 }
7478 {
7479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7480 }
7481 return resultobj;
7482 fail:
7483 return NULL;
7484 }
7485
7486
7487 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7488 PyObject *resultobj = 0;
7489 wxMouseState *arg1 = (wxMouseState *) 0 ;
7490 bool result;
7491 void *argp1 = 0 ;
7492 int res1 = 0 ;
7493 PyObject *swig_obj[1] ;
7494
7495 if (!args) SWIG_fail;
7496 swig_obj[0] = args;
7497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7498 if (!SWIG_IsOK(res1)) {
7499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7500 }
7501 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7502 {
7503 PyThreadState* __tstate = wxPyBeginAllowThreads();
7504 result = (bool)(arg1)->RightDown();
7505 wxPyEndAllowThreads(__tstate);
7506 if (PyErr_Occurred()) SWIG_fail;
7507 }
7508 {
7509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7510 }
7511 return resultobj;
7512 fail:
7513 return NULL;
7514 }
7515
7516
7517 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7518 PyObject *resultobj = 0;
7519 wxMouseState *arg1 = (wxMouseState *) 0 ;
7520 bool result;
7521 void *argp1 = 0 ;
7522 int res1 = 0 ;
7523 PyObject *swig_obj[1] ;
7524
7525 if (!args) SWIG_fail;
7526 swig_obj[0] = args;
7527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7528 if (!SWIG_IsOK(res1)) {
7529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7530 }
7531 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7532 {
7533 PyThreadState* __tstate = wxPyBeginAllowThreads();
7534 result = (bool)(arg1)->ControlDown();
7535 wxPyEndAllowThreads(__tstate);
7536 if (PyErr_Occurred()) SWIG_fail;
7537 }
7538 {
7539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7540 }
7541 return resultobj;
7542 fail:
7543 return NULL;
7544 }
7545
7546
7547 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7548 PyObject *resultobj = 0;
7549 wxMouseState *arg1 = (wxMouseState *) 0 ;
7550 bool result;
7551 void *argp1 = 0 ;
7552 int res1 = 0 ;
7553 PyObject *swig_obj[1] ;
7554
7555 if (!args) SWIG_fail;
7556 swig_obj[0] = args;
7557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7558 if (!SWIG_IsOK(res1)) {
7559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7560 }
7561 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7562 {
7563 PyThreadState* __tstate = wxPyBeginAllowThreads();
7564 result = (bool)(arg1)->ShiftDown();
7565 wxPyEndAllowThreads(__tstate);
7566 if (PyErr_Occurred()) SWIG_fail;
7567 }
7568 {
7569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7570 }
7571 return resultobj;
7572 fail:
7573 return NULL;
7574 }
7575
7576
7577 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7578 PyObject *resultobj = 0;
7579 wxMouseState *arg1 = (wxMouseState *) 0 ;
7580 bool result;
7581 void *argp1 = 0 ;
7582 int res1 = 0 ;
7583 PyObject *swig_obj[1] ;
7584
7585 if (!args) SWIG_fail;
7586 swig_obj[0] = args;
7587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7588 if (!SWIG_IsOK(res1)) {
7589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7590 }
7591 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7592 {
7593 PyThreadState* __tstate = wxPyBeginAllowThreads();
7594 result = (bool)(arg1)->AltDown();
7595 wxPyEndAllowThreads(__tstate);
7596 if (PyErr_Occurred()) SWIG_fail;
7597 }
7598 {
7599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7600 }
7601 return resultobj;
7602 fail:
7603 return NULL;
7604 }
7605
7606
7607 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7608 PyObject *resultobj = 0;
7609 wxMouseState *arg1 = (wxMouseState *) 0 ;
7610 bool result;
7611 void *argp1 = 0 ;
7612 int res1 = 0 ;
7613 PyObject *swig_obj[1] ;
7614
7615 if (!args) SWIG_fail;
7616 swig_obj[0] = args;
7617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7618 if (!SWIG_IsOK(res1)) {
7619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7620 }
7621 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7622 {
7623 PyThreadState* __tstate = wxPyBeginAllowThreads();
7624 result = (bool)(arg1)->MetaDown();
7625 wxPyEndAllowThreads(__tstate);
7626 if (PyErr_Occurred()) SWIG_fail;
7627 }
7628 {
7629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7630 }
7631 return resultobj;
7632 fail:
7633 return NULL;
7634 }
7635
7636
7637 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7638 PyObject *resultobj = 0;
7639 wxMouseState *arg1 = (wxMouseState *) 0 ;
7640 bool result;
7641 void *argp1 = 0 ;
7642 int res1 = 0 ;
7643 PyObject *swig_obj[1] ;
7644
7645 if (!args) SWIG_fail;
7646 swig_obj[0] = args;
7647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7648 if (!SWIG_IsOK(res1)) {
7649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7650 }
7651 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7652 {
7653 PyThreadState* __tstate = wxPyBeginAllowThreads();
7654 result = (bool)(arg1)->CmdDown();
7655 wxPyEndAllowThreads(__tstate);
7656 if (PyErr_Occurred()) SWIG_fail;
7657 }
7658 {
7659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7660 }
7661 return resultobj;
7662 fail:
7663 return NULL;
7664 }
7665
7666
7667 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7668 PyObject *resultobj = 0;
7669 wxMouseState *arg1 = (wxMouseState *) 0 ;
7670 int arg2 ;
7671 void *argp1 = 0 ;
7672 int res1 = 0 ;
7673 int val2 ;
7674 int ecode2 = 0 ;
7675 PyObject * obj0 = 0 ;
7676 PyObject * obj1 = 0 ;
7677 char * kwnames[] = {
7678 (char *) "self",(char *) "x", NULL
7679 };
7680
7681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7683 if (!SWIG_IsOK(res1)) {
7684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7685 }
7686 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7687 ecode2 = SWIG_AsVal_int(obj1, &val2);
7688 if (!SWIG_IsOK(ecode2)) {
7689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7690 }
7691 arg2 = static_cast< int >(val2);
7692 {
7693 PyThreadState* __tstate = wxPyBeginAllowThreads();
7694 (arg1)->SetX(arg2);
7695 wxPyEndAllowThreads(__tstate);
7696 if (PyErr_Occurred()) SWIG_fail;
7697 }
7698 resultobj = SWIG_Py_Void();
7699 return resultobj;
7700 fail:
7701 return NULL;
7702 }
7703
7704
7705 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7706 PyObject *resultobj = 0;
7707 wxMouseState *arg1 = (wxMouseState *) 0 ;
7708 int arg2 ;
7709 void *argp1 = 0 ;
7710 int res1 = 0 ;
7711 int val2 ;
7712 int ecode2 = 0 ;
7713 PyObject * obj0 = 0 ;
7714 PyObject * obj1 = 0 ;
7715 char * kwnames[] = {
7716 (char *) "self",(char *) "y", NULL
7717 };
7718
7719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7721 if (!SWIG_IsOK(res1)) {
7722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7723 }
7724 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7725 ecode2 = SWIG_AsVal_int(obj1, &val2);
7726 if (!SWIG_IsOK(ecode2)) {
7727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7728 }
7729 arg2 = static_cast< int >(val2);
7730 {
7731 PyThreadState* __tstate = wxPyBeginAllowThreads();
7732 (arg1)->SetY(arg2);
7733 wxPyEndAllowThreads(__tstate);
7734 if (PyErr_Occurred()) SWIG_fail;
7735 }
7736 resultobj = SWIG_Py_Void();
7737 return resultobj;
7738 fail:
7739 return NULL;
7740 }
7741
7742
7743 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7744 PyObject *resultobj = 0;
7745 wxMouseState *arg1 = (wxMouseState *) 0 ;
7746 bool arg2 ;
7747 void *argp1 = 0 ;
7748 int res1 = 0 ;
7749 bool val2 ;
7750 int ecode2 = 0 ;
7751 PyObject * obj0 = 0 ;
7752 PyObject * obj1 = 0 ;
7753 char * kwnames[] = {
7754 (char *) "self",(char *) "down", NULL
7755 };
7756
7757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7759 if (!SWIG_IsOK(res1)) {
7760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7761 }
7762 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7763 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7764 if (!SWIG_IsOK(ecode2)) {
7765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7766 }
7767 arg2 = static_cast< bool >(val2);
7768 {
7769 PyThreadState* __tstate = wxPyBeginAllowThreads();
7770 (arg1)->SetLeftDown(arg2);
7771 wxPyEndAllowThreads(__tstate);
7772 if (PyErr_Occurred()) SWIG_fail;
7773 }
7774 resultobj = SWIG_Py_Void();
7775 return resultobj;
7776 fail:
7777 return NULL;
7778 }
7779
7780
7781 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7782 PyObject *resultobj = 0;
7783 wxMouseState *arg1 = (wxMouseState *) 0 ;
7784 bool arg2 ;
7785 void *argp1 = 0 ;
7786 int res1 = 0 ;
7787 bool val2 ;
7788 int ecode2 = 0 ;
7789 PyObject * obj0 = 0 ;
7790 PyObject * obj1 = 0 ;
7791 char * kwnames[] = {
7792 (char *) "self",(char *) "down", NULL
7793 };
7794
7795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7797 if (!SWIG_IsOK(res1)) {
7798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7799 }
7800 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7801 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7802 if (!SWIG_IsOK(ecode2)) {
7803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7804 }
7805 arg2 = static_cast< bool >(val2);
7806 {
7807 PyThreadState* __tstate = wxPyBeginAllowThreads();
7808 (arg1)->SetMiddleDown(arg2);
7809 wxPyEndAllowThreads(__tstate);
7810 if (PyErr_Occurred()) SWIG_fail;
7811 }
7812 resultobj = SWIG_Py_Void();
7813 return resultobj;
7814 fail:
7815 return NULL;
7816 }
7817
7818
7819 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7820 PyObject *resultobj = 0;
7821 wxMouseState *arg1 = (wxMouseState *) 0 ;
7822 bool arg2 ;
7823 void *argp1 = 0 ;
7824 int res1 = 0 ;
7825 bool val2 ;
7826 int ecode2 = 0 ;
7827 PyObject * obj0 = 0 ;
7828 PyObject * obj1 = 0 ;
7829 char * kwnames[] = {
7830 (char *) "self",(char *) "down", NULL
7831 };
7832
7833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7835 if (!SWIG_IsOK(res1)) {
7836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7837 }
7838 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7839 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7840 if (!SWIG_IsOK(ecode2)) {
7841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7842 }
7843 arg2 = static_cast< bool >(val2);
7844 {
7845 PyThreadState* __tstate = wxPyBeginAllowThreads();
7846 (arg1)->SetRightDown(arg2);
7847 wxPyEndAllowThreads(__tstate);
7848 if (PyErr_Occurred()) SWIG_fail;
7849 }
7850 resultobj = SWIG_Py_Void();
7851 return resultobj;
7852 fail:
7853 return NULL;
7854 }
7855
7856
7857 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7858 PyObject *resultobj = 0;
7859 wxMouseState *arg1 = (wxMouseState *) 0 ;
7860 bool arg2 ;
7861 void *argp1 = 0 ;
7862 int res1 = 0 ;
7863 bool val2 ;
7864 int ecode2 = 0 ;
7865 PyObject * obj0 = 0 ;
7866 PyObject * obj1 = 0 ;
7867 char * kwnames[] = {
7868 (char *) "self",(char *) "down", NULL
7869 };
7870
7871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7873 if (!SWIG_IsOK(res1)) {
7874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7875 }
7876 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7877 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7878 if (!SWIG_IsOK(ecode2)) {
7879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7880 }
7881 arg2 = static_cast< bool >(val2);
7882 {
7883 PyThreadState* __tstate = wxPyBeginAllowThreads();
7884 (arg1)->SetControlDown(arg2);
7885 wxPyEndAllowThreads(__tstate);
7886 if (PyErr_Occurred()) SWIG_fail;
7887 }
7888 resultobj = SWIG_Py_Void();
7889 return resultobj;
7890 fail:
7891 return NULL;
7892 }
7893
7894
7895 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7896 PyObject *resultobj = 0;
7897 wxMouseState *arg1 = (wxMouseState *) 0 ;
7898 bool arg2 ;
7899 void *argp1 = 0 ;
7900 int res1 = 0 ;
7901 bool val2 ;
7902 int ecode2 = 0 ;
7903 PyObject * obj0 = 0 ;
7904 PyObject * obj1 = 0 ;
7905 char * kwnames[] = {
7906 (char *) "self",(char *) "down", NULL
7907 };
7908
7909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7911 if (!SWIG_IsOK(res1)) {
7912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7913 }
7914 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7915 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7916 if (!SWIG_IsOK(ecode2)) {
7917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7918 }
7919 arg2 = static_cast< bool >(val2);
7920 {
7921 PyThreadState* __tstate = wxPyBeginAllowThreads();
7922 (arg1)->SetShiftDown(arg2);
7923 wxPyEndAllowThreads(__tstate);
7924 if (PyErr_Occurred()) SWIG_fail;
7925 }
7926 resultobj = SWIG_Py_Void();
7927 return resultobj;
7928 fail:
7929 return NULL;
7930 }
7931
7932
7933 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7934 PyObject *resultobj = 0;
7935 wxMouseState *arg1 = (wxMouseState *) 0 ;
7936 bool arg2 ;
7937 void *argp1 = 0 ;
7938 int res1 = 0 ;
7939 bool val2 ;
7940 int ecode2 = 0 ;
7941 PyObject * obj0 = 0 ;
7942 PyObject * obj1 = 0 ;
7943 char * kwnames[] = {
7944 (char *) "self",(char *) "down", NULL
7945 };
7946
7947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7949 if (!SWIG_IsOK(res1)) {
7950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7951 }
7952 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7953 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7954 if (!SWIG_IsOK(ecode2)) {
7955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7956 }
7957 arg2 = static_cast< bool >(val2);
7958 {
7959 PyThreadState* __tstate = wxPyBeginAllowThreads();
7960 (arg1)->SetAltDown(arg2);
7961 wxPyEndAllowThreads(__tstate);
7962 if (PyErr_Occurred()) SWIG_fail;
7963 }
7964 resultobj = SWIG_Py_Void();
7965 return resultobj;
7966 fail:
7967 return NULL;
7968 }
7969
7970
7971 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7972 PyObject *resultobj = 0;
7973 wxMouseState *arg1 = (wxMouseState *) 0 ;
7974 bool arg2 ;
7975 void *argp1 = 0 ;
7976 int res1 = 0 ;
7977 bool val2 ;
7978 int ecode2 = 0 ;
7979 PyObject * obj0 = 0 ;
7980 PyObject * obj1 = 0 ;
7981 char * kwnames[] = {
7982 (char *) "self",(char *) "down", NULL
7983 };
7984
7985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7987 if (!SWIG_IsOK(res1)) {
7988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7989 }
7990 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7991 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7992 if (!SWIG_IsOK(ecode2)) {
7993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7994 }
7995 arg2 = static_cast< bool >(val2);
7996 {
7997 PyThreadState* __tstate = wxPyBeginAllowThreads();
7998 (arg1)->SetMetaDown(arg2);
7999 wxPyEndAllowThreads(__tstate);
8000 if (PyErr_Occurred()) SWIG_fail;
8001 }
8002 resultobj = SWIG_Py_Void();
8003 return resultobj;
8004 fail:
8005 return NULL;
8006 }
8007
8008
8009 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8010 PyObject *obj;
8011 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8012 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8013 return SWIG_Py_Void();
8014 }
8015
8016 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8017 return SWIG_Python_InitShadowInstance(args);
8018 }
8019
8020 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8021 PyObject *resultobj = 0;
8022 wxMouseState result;
8023
8024 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8025 {
8026 PyThreadState* __tstate = wxPyBeginAllowThreads();
8027 result = wxGetMouseState();
8028 wxPyEndAllowThreads(__tstate);
8029 if (PyErr_Occurred()) SWIG_fail;
8030 }
8031 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8032 return resultobj;
8033 fail:
8034 return NULL;
8035 }
8036
8037
8038 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8039 PyObject *resultobj = 0;
8040
8041 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8042 {
8043 if (!wxPyCheckForApp()) SWIG_fail;
8044 PyThreadState* __tstate = wxPyBeginAllowThreads();
8045 wxWakeUpMainThread();
8046 wxPyEndAllowThreads(__tstate);
8047 if (PyErr_Occurred()) SWIG_fail;
8048 }
8049 resultobj = SWIG_Py_Void();
8050 return resultobj;
8051 fail:
8052 return NULL;
8053 }
8054
8055
8056 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8057 PyObject *resultobj = 0;
8058
8059 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8060 {
8061 if (!wxPyCheckForApp()) SWIG_fail;
8062 PyThreadState* __tstate = wxPyBeginAllowThreads();
8063 wxMutexGuiEnter();
8064 wxPyEndAllowThreads(__tstate);
8065 if (PyErr_Occurred()) SWIG_fail;
8066 }
8067 resultobj = SWIG_Py_Void();
8068 return resultobj;
8069 fail:
8070 return NULL;
8071 }
8072
8073
8074 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8075 PyObject *resultobj = 0;
8076
8077 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8078 {
8079 if (!wxPyCheckForApp()) SWIG_fail;
8080 PyThreadState* __tstate = wxPyBeginAllowThreads();
8081 wxMutexGuiLeave();
8082 wxPyEndAllowThreads(__tstate);
8083 if (PyErr_Occurred()) SWIG_fail;
8084 }
8085 resultobj = SWIG_Py_Void();
8086 return resultobj;
8087 fail:
8088 return NULL;
8089 }
8090
8091
8092 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8093 PyObject *resultobj = 0;
8094 wxMutexGuiLocker *result = 0 ;
8095
8096 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8097 {
8098 if (!wxPyCheckForApp()) SWIG_fail;
8099 PyThreadState* __tstate = wxPyBeginAllowThreads();
8100 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8101 wxPyEndAllowThreads(__tstate);
8102 if (PyErr_Occurred()) SWIG_fail;
8103 }
8104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8105 return resultobj;
8106 fail:
8107 return NULL;
8108 }
8109
8110
8111 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8112 PyObject *resultobj = 0;
8113 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8114 void *argp1 = 0 ;
8115 int res1 = 0 ;
8116 PyObject *swig_obj[1] ;
8117
8118 if (!args) SWIG_fail;
8119 swig_obj[0] = args;
8120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8121 if (!SWIG_IsOK(res1)) {
8122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8123 }
8124 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8125 {
8126 PyThreadState* __tstate = wxPyBeginAllowThreads();
8127 delete arg1;
8128
8129 wxPyEndAllowThreads(__tstate);
8130 if (PyErr_Occurred()) SWIG_fail;
8131 }
8132 resultobj = SWIG_Py_Void();
8133 return resultobj;
8134 fail:
8135 return NULL;
8136 }
8137
8138
8139 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8140 PyObject *obj;
8141 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8142 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8143 return SWIG_Py_Void();
8144 }
8145
8146 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8147 return SWIG_Python_InitShadowInstance(args);
8148 }
8149
8150 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8151 PyObject *resultobj = 0;
8152 bool result;
8153
8154 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8155 {
8156 PyThreadState* __tstate = wxPyBeginAllowThreads();
8157 result = (bool)wxThread_IsMain();
8158 wxPyEndAllowThreads(__tstate);
8159 if (PyErr_Occurred()) SWIG_fail;
8160 }
8161 {
8162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8163 }
8164 return resultobj;
8165 fail:
8166 return NULL;
8167 }
8168
8169
8170 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8171 PyObject *resultobj = 0;
8172 wxString *arg1 = 0 ;
8173 wxToolTip *result = 0 ;
8174 bool temp1 = false ;
8175 PyObject * obj0 = 0 ;
8176 char * kwnames[] = {
8177 (char *) "tip", NULL
8178 };
8179
8180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8181 {
8182 arg1 = wxString_in_helper(obj0);
8183 if (arg1 == NULL) SWIG_fail;
8184 temp1 = true;
8185 }
8186 {
8187 if (!wxPyCheckForApp()) SWIG_fail;
8188 PyThreadState* __tstate = wxPyBeginAllowThreads();
8189 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8190 wxPyEndAllowThreads(__tstate);
8191 if (PyErr_Occurred()) SWIG_fail;
8192 }
8193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8194 {
8195 if (temp1)
8196 delete arg1;
8197 }
8198 return resultobj;
8199 fail:
8200 {
8201 if (temp1)
8202 delete arg1;
8203 }
8204 return NULL;
8205 }
8206
8207
8208 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8209 PyObject *resultobj = 0;
8210 wxToolTip *arg1 = (wxToolTip *) 0 ;
8211 void *argp1 = 0 ;
8212 int res1 = 0 ;
8213 PyObject *swig_obj[1] ;
8214
8215 if (!args) SWIG_fail;
8216 swig_obj[0] = args;
8217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8218 if (!SWIG_IsOK(res1)) {
8219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8220 }
8221 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8222 {
8223 PyThreadState* __tstate = wxPyBeginAllowThreads();
8224 delete arg1;
8225
8226 wxPyEndAllowThreads(__tstate);
8227 if (PyErr_Occurred()) SWIG_fail;
8228 }
8229 resultobj = SWIG_Py_Void();
8230 return resultobj;
8231 fail:
8232 return NULL;
8233 }
8234
8235
8236 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8237 PyObject *resultobj = 0;
8238 wxToolTip *arg1 = (wxToolTip *) 0 ;
8239 wxString *arg2 = 0 ;
8240 void *argp1 = 0 ;
8241 int res1 = 0 ;
8242 bool temp2 = false ;
8243 PyObject * obj0 = 0 ;
8244 PyObject * obj1 = 0 ;
8245 char * kwnames[] = {
8246 (char *) "self",(char *) "tip", NULL
8247 };
8248
8249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8251 if (!SWIG_IsOK(res1)) {
8252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8253 }
8254 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8255 {
8256 arg2 = wxString_in_helper(obj1);
8257 if (arg2 == NULL) SWIG_fail;
8258 temp2 = true;
8259 }
8260 {
8261 PyThreadState* __tstate = wxPyBeginAllowThreads();
8262 (arg1)->SetTip((wxString const &)*arg2);
8263 wxPyEndAllowThreads(__tstate);
8264 if (PyErr_Occurred()) SWIG_fail;
8265 }
8266 resultobj = SWIG_Py_Void();
8267 {
8268 if (temp2)
8269 delete arg2;
8270 }
8271 return resultobj;
8272 fail:
8273 {
8274 if (temp2)
8275 delete arg2;
8276 }
8277 return NULL;
8278 }
8279
8280
8281 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8282 PyObject *resultobj = 0;
8283 wxToolTip *arg1 = (wxToolTip *) 0 ;
8284 wxString result;
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_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8294 }
8295 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8296 {
8297 PyThreadState* __tstate = wxPyBeginAllowThreads();
8298 result = (arg1)->GetTip();
8299 wxPyEndAllowThreads(__tstate);
8300 if (PyErr_Occurred()) SWIG_fail;
8301 }
8302 {
8303 #if wxUSE_UNICODE
8304 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8305 #else
8306 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8307 #endif
8308 }
8309 return resultobj;
8310 fail:
8311 return NULL;
8312 }
8313
8314
8315 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8316 PyObject *resultobj = 0;
8317 wxToolTip *arg1 = (wxToolTip *) 0 ;
8318 wxWindow *result = 0 ;
8319 void *argp1 = 0 ;
8320 int res1 = 0 ;
8321 PyObject *swig_obj[1] ;
8322
8323 if (!args) SWIG_fail;
8324 swig_obj[0] = args;
8325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8326 if (!SWIG_IsOK(res1)) {
8327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8328 }
8329 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8330 {
8331 PyThreadState* __tstate = wxPyBeginAllowThreads();
8332 result = (wxWindow *)(arg1)->GetWindow();
8333 wxPyEndAllowThreads(__tstate);
8334 if (PyErr_Occurred()) SWIG_fail;
8335 }
8336 {
8337 resultobj = wxPyMake_wxObject(result, 0);
8338 }
8339 return resultobj;
8340 fail:
8341 return NULL;
8342 }
8343
8344
8345 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8346 PyObject *resultobj = 0;
8347 bool arg1 ;
8348 bool val1 ;
8349 int ecode1 = 0 ;
8350 PyObject * obj0 = 0 ;
8351 char * kwnames[] = {
8352 (char *) "flag", NULL
8353 };
8354
8355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8356 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8357 if (!SWIG_IsOK(ecode1)) {
8358 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8359 }
8360 arg1 = static_cast< bool >(val1);
8361 {
8362 PyThreadState* __tstate = wxPyBeginAllowThreads();
8363 wxToolTip::Enable(arg1);
8364 wxPyEndAllowThreads(__tstate);
8365 if (PyErr_Occurred()) SWIG_fail;
8366 }
8367 resultobj = SWIG_Py_Void();
8368 return resultobj;
8369 fail:
8370 return NULL;
8371 }
8372
8373
8374 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8375 PyObject *resultobj = 0;
8376 long arg1 ;
8377 long val1 ;
8378 int ecode1 = 0 ;
8379 PyObject * obj0 = 0 ;
8380 char * kwnames[] = {
8381 (char *) "milliseconds", NULL
8382 };
8383
8384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8385 ecode1 = SWIG_AsVal_long(obj0, &val1);
8386 if (!SWIG_IsOK(ecode1)) {
8387 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8388 }
8389 arg1 = static_cast< long >(val1);
8390 {
8391 PyThreadState* __tstate = wxPyBeginAllowThreads();
8392 wxToolTip::SetDelay(arg1);
8393 wxPyEndAllowThreads(__tstate);
8394 if (PyErr_Occurred()) SWIG_fail;
8395 }
8396 resultobj = SWIG_Py_Void();
8397 return resultobj;
8398 fail:
8399 return NULL;
8400 }
8401
8402
8403 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8404 PyObject *obj;
8405 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8406 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8407 return SWIG_Py_Void();
8408 }
8409
8410 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8411 return SWIG_Python_InitShadowInstance(args);
8412 }
8413
8414 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8415 PyObject *resultobj = 0;
8416 wxWindow *arg1 = (wxWindow *) 0 ;
8417 wxSize *arg2 = 0 ;
8418 wxCaret *result = 0 ;
8419 void *argp1 = 0 ;
8420 int res1 = 0 ;
8421 wxSize temp2 ;
8422 PyObject * obj0 = 0 ;
8423 PyObject * obj1 = 0 ;
8424 char * kwnames[] = {
8425 (char *) "window",(char *) "size", NULL
8426 };
8427
8428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8430 if (!SWIG_IsOK(res1)) {
8431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8432 }
8433 arg1 = reinterpret_cast< wxWindow * >(argp1);
8434 {
8435 arg2 = &temp2;
8436 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8437 }
8438 {
8439 if (!wxPyCheckForApp()) SWIG_fail;
8440 PyThreadState* __tstate = wxPyBeginAllowThreads();
8441 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8442 wxPyEndAllowThreads(__tstate);
8443 if (PyErr_Occurred()) SWIG_fail;
8444 }
8445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8446 return resultobj;
8447 fail:
8448 return NULL;
8449 }
8450
8451
8452 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8453 PyObject *resultobj = 0;
8454 wxCaret *arg1 = (wxCaret *) 0 ;
8455 void *argp1 = 0 ;
8456 int res1 = 0 ;
8457 PyObject *swig_obj[1] ;
8458
8459 if (!args) SWIG_fail;
8460 swig_obj[0] = args;
8461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8462 if (!SWIG_IsOK(res1)) {
8463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8464 }
8465 arg1 = reinterpret_cast< wxCaret * >(argp1);
8466 {
8467 PyThreadState* __tstate = wxPyBeginAllowThreads();
8468 delete arg1;
8469
8470 wxPyEndAllowThreads(__tstate);
8471 if (PyErr_Occurred()) SWIG_fail;
8472 }
8473 resultobj = SWIG_Py_Void();
8474 return resultobj;
8475 fail:
8476 return NULL;
8477 }
8478
8479
8480 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8481 PyObject *resultobj = 0;
8482 wxCaret *arg1 = (wxCaret *) 0 ;
8483 void *argp1 = 0 ;
8484 int res1 = 0 ;
8485 PyObject *swig_obj[1] ;
8486
8487 if (!args) SWIG_fail;
8488 swig_obj[0] = args;
8489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8490 if (!SWIG_IsOK(res1)) {
8491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8492 }
8493 arg1 = reinterpret_cast< wxCaret * >(argp1);
8494 {
8495 PyThreadState* __tstate = wxPyBeginAllowThreads();
8496 wxCaret_Destroy(arg1);
8497 wxPyEndAllowThreads(__tstate);
8498 if (PyErr_Occurred()) SWIG_fail;
8499 }
8500 resultobj = SWIG_Py_Void();
8501 return resultobj;
8502 fail:
8503 return NULL;
8504 }
8505
8506
8507 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8508 PyObject *resultobj = 0;
8509 wxCaret *arg1 = (wxCaret *) 0 ;
8510 bool result;
8511 void *argp1 = 0 ;
8512 int res1 = 0 ;
8513 PyObject *swig_obj[1] ;
8514
8515 if (!args) SWIG_fail;
8516 swig_obj[0] = args;
8517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8518 if (!SWIG_IsOK(res1)) {
8519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8520 }
8521 arg1 = reinterpret_cast< wxCaret * >(argp1);
8522 {
8523 PyThreadState* __tstate = wxPyBeginAllowThreads();
8524 result = (bool)(arg1)->IsOk();
8525 wxPyEndAllowThreads(__tstate);
8526 if (PyErr_Occurred()) SWIG_fail;
8527 }
8528 {
8529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8530 }
8531 return resultobj;
8532 fail:
8533 return NULL;
8534 }
8535
8536
8537 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8538 PyObject *resultobj = 0;
8539 wxCaret *arg1 = (wxCaret *) 0 ;
8540 bool result;
8541 void *argp1 = 0 ;
8542 int res1 = 0 ;
8543 PyObject *swig_obj[1] ;
8544
8545 if (!args) SWIG_fail;
8546 swig_obj[0] = args;
8547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8548 if (!SWIG_IsOK(res1)) {
8549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8550 }
8551 arg1 = reinterpret_cast< wxCaret * >(argp1);
8552 {
8553 PyThreadState* __tstate = wxPyBeginAllowThreads();
8554 result = (bool)(arg1)->IsVisible();
8555 wxPyEndAllowThreads(__tstate);
8556 if (PyErr_Occurred()) SWIG_fail;
8557 }
8558 {
8559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8560 }
8561 return resultobj;
8562 fail:
8563 return NULL;
8564 }
8565
8566
8567 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8568 PyObject *resultobj = 0;
8569 wxCaret *arg1 = (wxCaret *) 0 ;
8570 wxPoint result;
8571 void *argp1 = 0 ;
8572 int res1 = 0 ;
8573 PyObject *swig_obj[1] ;
8574
8575 if (!args) SWIG_fail;
8576 swig_obj[0] = args;
8577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8578 if (!SWIG_IsOK(res1)) {
8579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8580 }
8581 arg1 = reinterpret_cast< wxCaret * >(argp1);
8582 {
8583 PyThreadState* __tstate = wxPyBeginAllowThreads();
8584 result = (arg1)->GetPosition();
8585 wxPyEndAllowThreads(__tstate);
8586 if (PyErr_Occurred()) SWIG_fail;
8587 }
8588 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8589 return resultobj;
8590 fail:
8591 return NULL;
8592 }
8593
8594
8595 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8596 PyObject *resultobj = 0;
8597 wxCaret *arg1 = (wxCaret *) 0 ;
8598 int *arg2 = (int *) 0 ;
8599 int *arg3 = (int *) 0 ;
8600 void *argp1 = 0 ;
8601 int res1 = 0 ;
8602 int temp2 ;
8603 int res2 = SWIG_TMPOBJ ;
8604 int temp3 ;
8605 int res3 = SWIG_TMPOBJ ;
8606 PyObject *swig_obj[1] ;
8607
8608 arg2 = &temp2;
8609 arg3 = &temp3;
8610 if (!args) SWIG_fail;
8611 swig_obj[0] = args;
8612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8613 if (!SWIG_IsOK(res1)) {
8614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8615 }
8616 arg1 = reinterpret_cast< wxCaret * >(argp1);
8617 {
8618 PyThreadState* __tstate = wxPyBeginAllowThreads();
8619 (arg1)->GetPosition(arg2,arg3);
8620 wxPyEndAllowThreads(__tstate);
8621 if (PyErr_Occurred()) SWIG_fail;
8622 }
8623 resultobj = SWIG_Py_Void();
8624 if (SWIG_IsTmpObj(res2)) {
8625 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8626 } else {
8627 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8629 }
8630 if (SWIG_IsTmpObj(res3)) {
8631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8632 } else {
8633 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8635 }
8636 return resultobj;
8637 fail:
8638 return NULL;
8639 }
8640
8641
8642 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8643 PyObject *resultobj = 0;
8644 wxCaret *arg1 = (wxCaret *) 0 ;
8645 wxSize result;
8646 void *argp1 = 0 ;
8647 int res1 = 0 ;
8648 PyObject *swig_obj[1] ;
8649
8650 if (!args) SWIG_fail;
8651 swig_obj[0] = args;
8652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8653 if (!SWIG_IsOK(res1)) {
8654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8655 }
8656 arg1 = reinterpret_cast< wxCaret * >(argp1);
8657 {
8658 PyThreadState* __tstate = wxPyBeginAllowThreads();
8659 result = (arg1)->GetSize();
8660 wxPyEndAllowThreads(__tstate);
8661 if (PyErr_Occurred()) SWIG_fail;
8662 }
8663 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8664 return resultobj;
8665 fail:
8666 return NULL;
8667 }
8668
8669
8670 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8671 PyObject *resultobj = 0;
8672 wxCaret *arg1 = (wxCaret *) 0 ;
8673 int *arg2 = (int *) 0 ;
8674 int *arg3 = (int *) 0 ;
8675 void *argp1 = 0 ;
8676 int res1 = 0 ;
8677 int temp2 ;
8678 int res2 = SWIG_TMPOBJ ;
8679 int temp3 ;
8680 int res3 = SWIG_TMPOBJ ;
8681 PyObject *swig_obj[1] ;
8682
8683 arg2 = &temp2;
8684 arg3 = &temp3;
8685 if (!args) SWIG_fail;
8686 swig_obj[0] = args;
8687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8688 if (!SWIG_IsOK(res1)) {
8689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8690 }
8691 arg1 = reinterpret_cast< wxCaret * >(argp1);
8692 {
8693 PyThreadState* __tstate = wxPyBeginAllowThreads();
8694 (arg1)->GetSize(arg2,arg3);
8695 wxPyEndAllowThreads(__tstate);
8696 if (PyErr_Occurred()) SWIG_fail;
8697 }
8698 resultobj = SWIG_Py_Void();
8699 if (SWIG_IsTmpObj(res2)) {
8700 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8701 } else {
8702 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8704 }
8705 if (SWIG_IsTmpObj(res3)) {
8706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8707 } else {
8708 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8710 }
8711 return resultobj;
8712 fail:
8713 return NULL;
8714 }
8715
8716
8717 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8718 PyObject *resultobj = 0;
8719 wxCaret *arg1 = (wxCaret *) 0 ;
8720 wxWindow *result = 0 ;
8721 void *argp1 = 0 ;
8722 int res1 = 0 ;
8723 PyObject *swig_obj[1] ;
8724
8725 if (!args) SWIG_fail;
8726 swig_obj[0] = args;
8727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8728 if (!SWIG_IsOK(res1)) {
8729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8730 }
8731 arg1 = reinterpret_cast< wxCaret * >(argp1);
8732 {
8733 PyThreadState* __tstate = wxPyBeginAllowThreads();
8734 result = (wxWindow *)(arg1)->GetWindow();
8735 wxPyEndAllowThreads(__tstate);
8736 if (PyErr_Occurred()) SWIG_fail;
8737 }
8738 {
8739 resultobj = wxPyMake_wxObject(result, 0);
8740 }
8741 return resultobj;
8742 fail:
8743 return NULL;
8744 }
8745
8746
8747 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8748 PyObject *resultobj = 0;
8749 wxCaret *arg1 = (wxCaret *) 0 ;
8750 int arg2 ;
8751 int arg3 ;
8752 void *argp1 = 0 ;
8753 int res1 = 0 ;
8754 int val2 ;
8755 int ecode2 = 0 ;
8756 int val3 ;
8757 int ecode3 = 0 ;
8758 PyObject * obj0 = 0 ;
8759 PyObject * obj1 = 0 ;
8760 PyObject * obj2 = 0 ;
8761 char * kwnames[] = {
8762 (char *) "self",(char *) "x",(char *) "y", NULL
8763 };
8764
8765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8767 if (!SWIG_IsOK(res1)) {
8768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8769 }
8770 arg1 = reinterpret_cast< wxCaret * >(argp1);
8771 ecode2 = SWIG_AsVal_int(obj1, &val2);
8772 if (!SWIG_IsOK(ecode2)) {
8773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8774 }
8775 arg2 = static_cast< int >(val2);
8776 ecode3 = SWIG_AsVal_int(obj2, &val3);
8777 if (!SWIG_IsOK(ecode3)) {
8778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8779 }
8780 arg3 = static_cast< int >(val3);
8781 {
8782 PyThreadState* __tstate = wxPyBeginAllowThreads();
8783 (arg1)->Move(arg2,arg3);
8784 wxPyEndAllowThreads(__tstate);
8785 if (PyErr_Occurred()) SWIG_fail;
8786 }
8787 resultobj = SWIG_Py_Void();
8788 return resultobj;
8789 fail:
8790 return NULL;
8791 }
8792
8793
8794 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8795 PyObject *resultobj = 0;
8796 wxCaret *arg1 = (wxCaret *) 0 ;
8797 wxPoint *arg2 = 0 ;
8798 void *argp1 = 0 ;
8799 int res1 = 0 ;
8800 wxPoint temp2 ;
8801 PyObject * obj0 = 0 ;
8802 PyObject * obj1 = 0 ;
8803 char * kwnames[] = {
8804 (char *) "self",(char *) "pt", NULL
8805 };
8806
8807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8809 if (!SWIG_IsOK(res1)) {
8810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8811 }
8812 arg1 = reinterpret_cast< wxCaret * >(argp1);
8813 {
8814 arg2 = &temp2;
8815 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8816 }
8817 {
8818 PyThreadState* __tstate = wxPyBeginAllowThreads();
8819 (arg1)->Move((wxPoint const &)*arg2);
8820 wxPyEndAllowThreads(__tstate);
8821 if (PyErr_Occurred()) SWIG_fail;
8822 }
8823 resultobj = SWIG_Py_Void();
8824 return resultobj;
8825 fail:
8826 return NULL;
8827 }
8828
8829
8830 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8831 PyObject *resultobj = 0;
8832 wxCaret *arg1 = (wxCaret *) 0 ;
8833 int arg2 ;
8834 int arg3 ;
8835 void *argp1 = 0 ;
8836 int res1 = 0 ;
8837 int val2 ;
8838 int ecode2 = 0 ;
8839 int val3 ;
8840 int ecode3 = 0 ;
8841 PyObject * obj0 = 0 ;
8842 PyObject * obj1 = 0 ;
8843 PyObject * obj2 = 0 ;
8844 char * kwnames[] = {
8845 (char *) "self",(char *) "width",(char *) "height", NULL
8846 };
8847
8848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8850 if (!SWIG_IsOK(res1)) {
8851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8852 }
8853 arg1 = reinterpret_cast< wxCaret * >(argp1);
8854 ecode2 = SWIG_AsVal_int(obj1, &val2);
8855 if (!SWIG_IsOK(ecode2)) {
8856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8857 }
8858 arg2 = static_cast< int >(val2);
8859 ecode3 = SWIG_AsVal_int(obj2, &val3);
8860 if (!SWIG_IsOK(ecode3)) {
8861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8862 }
8863 arg3 = static_cast< int >(val3);
8864 {
8865 PyThreadState* __tstate = wxPyBeginAllowThreads();
8866 (arg1)->SetSize(arg2,arg3);
8867 wxPyEndAllowThreads(__tstate);
8868 if (PyErr_Occurred()) SWIG_fail;
8869 }
8870 resultobj = SWIG_Py_Void();
8871 return resultobj;
8872 fail:
8873 return NULL;
8874 }
8875
8876
8877 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8878 PyObject *resultobj = 0;
8879 wxCaret *arg1 = (wxCaret *) 0 ;
8880 wxSize *arg2 = 0 ;
8881 void *argp1 = 0 ;
8882 int res1 = 0 ;
8883 wxSize temp2 ;
8884 PyObject * obj0 = 0 ;
8885 PyObject * obj1 = 0 ;
8886 char * kwnames[] = {
8887 (char *) "self",(char *) "size", NULL
8888 };
8889
8890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8892 if (!SWIG_IsOK(res1)) {
8893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8894 }
8895 arg1 = reinterpret_cast< wxCaret * >(argp1);
8896 {
8897 arg2 = &temp2;
8898 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8899 }
8900 {
8901 PyThreadState* __tstate = wxPyBeginAllowThreads();
8902 (arg1)->SetSize((wxSize const &)*arg2);
8903 wxPyEndAllowThreads(__tstate);
8904 if (PyErr_Occurred()) SWIG_fail;
8905 }
8906 resultobj = SWIG_Py_Void();
8907 return resultobj;
8908 fail:
8909 return NULL;
8910 }
8911
8912
8913 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8914 PyObject *resultobj = 0;
8915 wxCaret *arg1 = (wxCaret *) 0 ;
8916 int arg2 = (int) true ;
8917 void *argp1 = 0 ;
8918 int res1 = 0 ;
8919 int val2 ;
8920 int ecode2 = 0 ;
8921 PyObject * obj0 = 0 ;
8922 PyObject * obj1 = 0 ;
8923 char * kwnames[] = {
8924 (char *) "self",(char *) "show", NULL
8925 };
8926
8927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8929 if (!SWIG_IsOK(res1)) {
8930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8931 }
8932 arg1 = reinterpret_cast< wxCaret * >(argp1);
8933 if (obj1) {
8934 ecode2 = SWIG_AsVal_int(obj1, &val2);
8935 if (!SWIG_IsOK(ecode2)) {
8936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8937 }
8938 arg2 = static_cast< int >(val2);
8939 }
8940 {
8941 PyThreadState* __tstate = wxPyBeginAllowThreads();
8942 (arg1)->Show(arg2);
8943 wxPyEndAllowThreads(__tstate);
8944 if (PyErr_Occurred()) SWIG_fail;
8945 }
8946 resultobj = SWIG_Py_Void();
8947 return resultobj;
8948 fail:
8949 return NULL;
8950 }
8951
8952
8953 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8954 PyObject *resultobj = 0;
8955 wxCaret *arg1 = (wxCaret *) 0 ;
8956 void *argp1 = 0 ;
8957 int res1 = 0 ;
8958 PyObject *swig_obj[1] ;
8959
8960 if (!args) SWIG_fail;
8961 swig_obj[0] = args;
8962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8963 if (!SWIG_IsOK(res1)) {
8964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8965 }
8966 arg1 = reinterpret_cast< wxCaret * >(argp1);
8967 {
8968 PyThreadState* __tstate = wxPyBeginAllowThreads();
8969 (arg1)->Hide();
8970 wxPyEndAllowThreads(__tstate);
8971 if (PyErr_Occurred()) SWIG_fail;
8972 }
8973 resultobj = SWIG_Py_Void();
8974 return resultobj;
8975 fail:
8976 return NULL;
8977 }
8978
8979
8980 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8981 PyObject *resultobj = 0;
8982 int result;
8983
8984 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8985 {
8986 PyThreadState* __tstate = wxPyBeginAllowThreads();
8987 result = (int)wxCaret::GetBlinkTime();
8988 wxPyEndAllowThreads(__tstate);
8989 if (PyErr_Occurred()) SWIG_fail;
8990 }
8991 resultobj = SWIG_From_int(static_cast< int >(result));
8992 return resultobj;
8993 fail:
8994 return NULL;
8995 }
8996
8997
8998 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8999 PyObject *resultobj = 0;
9000 int arg1 ;
9001 int val1 ;
9002 int ecode1 = 0 ;
9003 PyObject * obj0 = 0 ;
9004 char * kwnames[] = {
9005 (char *) "milliseconds", NULL
9006 };
9007
9008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9009 ecode1 = SWIG_AsVal_int(obj0, &val1);
9010 if (!SWIG_IsOK(ecode1)) {
9011 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9012 }
9013 arg1 = static_cast< int >(val1);
9014 {
9015 PyThreadState* __tstate = wxPyBeginAllowThreads();
9016 wxCaret::SetBlinkTime(arg1);
9017 wxPyEndAllowThreads(__tstate);
9018 if (PyErr_Occurred()) SWIG_fail;
9019 }
9020 resultobj = SWIG_Py_Void();
9021 return resultobj;
9022 fail:
9023 return NULL;
9024 }
9025
9026
9027 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9028 PyObject *obj;
9029 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9030 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9031 return SWIG_Py_Void();
9032 }
9033
9034 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9035 return SWIG_Python_InitShadowInstance(args);
9036 }
9037
9038 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9039 PyObject *resultobj = 0;
9040 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9041 wxBusyCursor *result = 0 ;
9042 void *argp1 = 0 ;
9043 int res1 = 0 ;
9044 PyObject * obj0 = 0 ;
9045 char * kwnames[] = {
9046 (char *) "cursor", NULL
9047 };
9048
9049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9050 if (obj0) {
9051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9052 if (!SWIG_IsOK(res1)) {
9053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9054 }
9055 arg1 = reinterpret_cast< wxCursor * >(argp1);
9056 }
9057 {
9058 if (!wxPyCheckForApp()) SWIG_fail;
9059 PyThreadState* __tstate = wxPyBeginAllowThreads();
9060 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9061 wxPyEndAllowThreads(__tstate);
9062 if (PyErr_Occurred()) SWIG_fail;
9063 }
9064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9065 return resultobj;
9066 fail:
9067 return NULL;
9068 }
9069
9070
9071 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9072 PyObject *resultobj = 0;
9073 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9074 void *argp1 = 0 ;
9075 int res1 = 0 ;
9076 PyObject *swig_obj[1] ;
9077
9078 if (!args) SWIG_fail;
9079 swig_obj[0] = args;
9080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9081 if (!SWIG_IsOK(res1)) {
9082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9083 }
9084 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9085 {
9086 PyThreadState* __tstate = wxPyBeginAllowThreads();
9087 delete arg1;
9088
9089 wxPyEndAllowThreads(__tstate);
9090 if (PyErr_Occurred()) SWIG_fail;
9091 }
9092 resultobj = SWIG_Py_Void();
9093 return resultobj;
9094 fail:
9095 return NULL;
9096 }
9097
9098
9099 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9100 PyObject *obj;
9101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9102 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9103 return SWIG_Py_Void();
9104 }
9105
9106 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9107 return SWIG_Python_InitShadowInstance(args);
9108 }
9109
9110 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9111 PyObject *resultobj = 0;
9112 wxWindow *arg1 = (wxWindow *) NULL ;
9113 wxWindowDisabler *result = 0 ;
9114 void *argp1 = 0 ;
9115 int res1 = 0 ;
9116 PyObject * obj0 = 0 ;
9117 char * kwnames[] = {
9118 (char *) "winToSkip", NULL
9119 };
9120
9121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9122 if (obj0) {
9123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9124 if (!SWIG_IsOK(res1)) {
9125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9126 }
9127 arg1 = reinterpret_cast< wxWindow * >(argp1);
9128 }
9129 {
9130 if (!wxPyCheckForApp()) SWIG_fail;
9131 PyThreadState* __tstate = wxPyBeginAllowThreads();
9132 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9133 wxPyEndAllowThreads(__tstate);
9134 if (PyErr_Occurred()) SWIG_fail;
9135 }
9136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9137 return resultobj;
9138 fail:
9139 return NULL;
9140 }
9141
9142
9143 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9144 PyObject *resultobj = 0;
9145 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9146 void *argp1 = 0 ;
9147 int res1 = 0 ;
9148 PyObject *swig_obj[1] ;
9149
9150 if (!args) SWIG_fail;
9151 swig_obj[0] = args;
9152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9153 if (!SWIG_IsOK(res1)) {
9154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9155 }
9156 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9157 {
9158 PyThreadState* __tstate = wxPyBeginAllowThreads();
9159 delete arg1;
9160
9161 wxPyEndAllowThreads(__tstate);
9162 if (PyErr_Occurred()) SWIG_fail;
9163 }
9164 resultobj = SWIG_Py_Void();
9165 return resultobj;
9166 fail:
9167 return NULL;
9168 }
9169
9170
9171 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9172 PyObject *obj;
9173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9174 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9175 return SWIG_Py_Void();
9176 }
9177
9178 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9179 return SWIG_Python_InitShadowInstance(args);
9180 }
9181
9182 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9183 PyObject *resultobj = 0;
9184 wxString *arg1 = 0 ;
9185 wxBusyInfo *result = 0 ;
9186 bool temp1 = false ;
9187 PyObject * obj0 = 0 ;
9188 char * kwnames[] = {
9189 (char *) "message", NULL
9190 };
9191
9192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9193 {
9194 arg1 = wxString_in_helper(obj0);
9195 if (arg1 == NULL) SWIG_fail;
9196 temp1 = true;
9197 }
9198 {
9199 if (!wxPyCheckForApp()) SWIG_fail;
9200 PyThreadState* __tstate = wxPyBeginAllowThreads();
9201 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9202 wxPyEndAllowThreads(__tstate);
9203 if (PyErr_Occurred()) SWIG_fail;
9204 }
9205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9206 {
9207 if (temp1)
9208 delete arg1;
9209 }
9210 return resultobj;
9211 fail:
9212 {
9213 if (temp1)
9214 delete arg1;
9215 }
9216 return NULL;
9217 }
9218
9219
9220 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9221 PyObject *resultobj = 0;
9222 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9223 void *argp1 = 0 ;
9224 int res1 = 0 ;
9225 PyObject *swig_obj[1] ;
9226
9227 if (!args) SWIG_fail;
9228 swig_obj[0] = args;
9229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9230 if (!SWIG_IsOK(res1)) {
9231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9232 }
9233 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9234 {
9235 PyThreadState* __tstate = wxPyBeginAllowThreads();
9236 delete arg1;
9237
9238 wxPyEndAllowThreads(__tstate);
9239 if (PyErr_Occurred()) SWIG_fail;
9240 }
9241 resultobj = SWIG_Py_Void();
9242 return resultobj;
9243 fail:
9244 return NULL;
9245 }
9246
9247
9248 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9249 PyObject *obj;
9250 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9251 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9252 return SWIG_Py_Void();
9253 }
9254
9255 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9256 return SWIG_Python_InitShadowInstance(args);
9257 }
9258
9259 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9260 PyObject *resultobj = 0;
9261 wxStopWatch *result = 0 ;
9262
9263 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9264 {
9265 PyThreadState* __tstate = wxPyBeginAllowThreads();
9266 result = (wxStopWatch *)new wxStopWatch();
9267 wxPyEndAllowThreads(__tstate);
9268 if (PyErr_Occurred()) SWIG_fail;
9269 }
9270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9271 return resultobj;
9272 fail:
9273 return NULL;
9274 }
9275
9276
9277 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9278 PyObject *resultobj = 0;
9279 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9280 void *argp1 = 0 ;
9281 int res1 = 0 ;
9282 PyObject *swig_obj[1] ;
9283
9284 if (!args) SWIG_fail;
9285 swig_obj[0] = args;
9286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9287 if (!SWIG_IsOK(res1)) {
9288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9289 }
9290 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9291 {
9292 PyThreadState* __tstate = wxPyBeginAllowThreads();
9293 delete arg1;
9294
9295 wxPyEndAllowThreads(__tstate);
9296 if (PyErr_Occurred()) SWIG_fail;
9297 }
9298 resultobj = SWIG_Py_Void();
9299 return resultobj;
9300 fail:
9301 return NULL;
9302 }
9303
9304
9305 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9306 PyObject *resultobj = 0;
9307 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9308 long arg2 = (long) 0 ;
9309 void *argp1 = 0 ;
9310 int res1 = 0 ;
9311 long val2 ;
9312 int ecode2 = 0 ;
9313 PyObject * obj0 = 0 ;
9314 PyObject * obj1 = 0 ;
9315 char * kwnames[] = {
9316 (char *) "self",(char *) "t0", NULL
9317 };
9318
9319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9321 if (!SWIG_IsOK(res1)) {
9322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9323 }
9324 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9325 if (obj1) {
9326 ecode2 = SWIG_AsVal_long(obj1, &val2);
9327 if (!SWIG_IsOK(ecode2)) {
9328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9329 }
9330 arg2 = static_cast< long >(val2);
9331 }
9332 {
9333 PyThreadState* __tstate = wxPyBeginAllowThreads();
9334 (arg1)->Start(arg2);
9335 wxPyEndAllowThreads(__tstate);
9336 if (PyErr_Occurred()) SWIG_fail;
9337 }
9338 resultobj = SWIG_Py_Void();
9339 return resultobj;
9340 fail:
9341 return NULL;
9342 }
9343
9344
9345 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9346 PyObject *resultobj = 0;
9347 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9348 void *argp1 = 0 ;
9349 int res1 = 0 ;
9350 PyObject *swig_obj[1] ;
9351
9352 if (!args) SWIG_fail;
9353 swig_obj[0] = args;
9354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9355 if (!SWIG_IsOK(res1)) {
9356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9357 }
9358 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9359 {
9360 PyThreadState* __tstate = wxPyBeginAllowThreads();
9361 (arg1)->Pause();
9362 wxPyEndAllowThreads(__tstate);
9363 if (PyErr_Occurred()) SWIG_fail;
9364 }
9365 resultobj = SWIG_Py_Void();
9366 return resultobj;
9367 fail:
9368 return NULL;
9369 }
9370
9371
9372 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9373 PyObject *resultobj = 0;
9374 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9375 void *argp1 = 0 ;
9376 int res1 = 0 ;
9377 PyObject *swig_obj[1] ;
9378
9379 if (!args) SWIG_fail;
9380 swig_obj[0] = args;
9381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9382 if (!SWIG_IsOK(res1)) {
9383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9384 }
9385 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9386 {
9387 PyThreadState* __tstate = wxPyBeginAllowThreads();
9388 (arg1)->Resume();
9389 wxPyEndAllowThreads(__tstate);
9390 if (PyErr_Occurred()) SWIG_fail;
9391 }
9392 resultobj = SWIG_Py_Void();
9393 return resultobj;
9394 fail:
9395 return NULL;
9396 }
9397
9398
9399 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9400 PyObject *resultobj = 0;
9401 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9402 long result;
9403 void *argp1 = 0 ;
9404 int res1 = 0 ;
9405 PyObject *swig_obj[1] ;
9406
9407 if (!args) SWIG_fail;
9408 swig_obj[0] = args;
9409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9410 if (!SWIG_IsOK(res1)) {
9411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9412 }
9413 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9414 {
9415 PyThreadState* __tstate = wxPyBeginAllowThreads();
9416 result = (long)((wxStopWatch const *)arg1)->Time();
9417 wxPyEndAllowThreads(__tstate);
9418 if (PyErr_Occurred()) SWIG_fail;
9419 }
9420 resultobj = SWIG_From_long(static_cast< long >(result));
9421 return resultobj;
9422 fail:
9423 return NULL;
9424 }
9425
9426
9427 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9428 PyObject *obj;
9429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9430 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9431 return SWIG_Py_Void();
9432 }
9433
9434 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9435 return SWIG_Python_InitShadowInstance(args);
9436 }
9437
9438 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9439 PyObject *resultobj = 0;
9440 int arg1 = (int) 9 ;
9441 int arg2 = (int) wxID_FILE1 ;
9442 wxFileHistory *result = 0 ;
9443 int val1 ;
9444 int ecode1 = 0 ;
9445 int val2 ;
9446 int ecode2 = 0 ;
9447 PyObject * obj0 = 0 ;
9448 PyObject * obj1 = 0 ;
9449 char * kwnames[] = {
9450 (char *) "maxFiles",(char *) "idBase", NULL
9451 };
9452
9453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9454 if (obj0) {
9455 ecode1 = SWIG_AsVal_int(obj0, &val1);
9456 if (!SWIG_IsOK(ecode1)) {
9457 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9458 }
9459 arg1 = static_cast< int >(val1);
9460 }
9461 if (obj1) {
9462 ecode2 = SWIG_AsVal_int(obj1, &val2);
9463 if (!SWIG_IsOK(ecode2)) {
9464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9465 }
9466 arg2 = static_cast< int >(val2);
9467 }
9468 {
9469 PyThreadState* __tstate = wxPyBeginAllowThreads();
9470 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9471 wxPyEndAllowThreads(__tstate);
9472 if (PyErr_Occurred()) SWIG_fail;
9473 }
9474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9475 return resultobj;
9476 fail:
9477 return NULL;
9478 }
9479
9480
9481 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9482 PyObject *resultobj = 0;
9483 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9484 void *argp1 = 0 ;
9485 int res1 = 0 ;
9486 PyObject *swig_obj[1] ;
9487
9488 if (!args) SWIG_fail;
9489 swig_obj[0] = args;
9490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9491 if (!SWIG_IsOK(res1)) {
9492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9493 }
9494 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9495 {
9496 PyThreadState* __tstate = wxPyBeginAllowThreads();
9497 delete arg1;
9498
9499 wxPyEndAllowThreads(__tstate);
9500 if (PyErr_Occurred()) SWIG_fail;
9501 }
9502 resultobj = SWIG_Py_Void();
9503 return resultobj;
9504 fail:
9505 return NULL;
9506 }
9507
9508
9509 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9510 PyObject *resultobj = 0;
9511 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9512 wxString *arg2 = 0 ;
9513 void *argp1 = 0 ;
9514 int res1 = 0 ;
9515 bool temp2 = false ;
9516 PyObject * obj0 = 0 ;
9517 PyObject * obj1 = 0 ;
9518 char * kwnames[] = {
9519 (char *) "self",(char *) "file", NULL
9520 };
9521
9522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9524 if (!SWIG_IsOK(res1)) {
9525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9526 }
9527 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9528 {
9529 arg2 = wxString_in_helper(obj1);
9530 if (arg2 == NULL) SWIG_fail;
9531 temp2 = true;
9532 }
9533 {
9534 PyThreadState* __tstate = wxPyBeginAllowThreads();
9535 (arg1)->AddFileToHistory((wxString const &)*arg2);
9536 wxPyEndAllowThreads(__tstate);
9537 if (PyErr_Occurred()) SWIG_fail;
9538 }
9539 resultobj = SWIG_Py_Void();
9540 {
9541 if (temp2)
9542 delete arg2;
9543 }
9544 return resultobj;
9545 fail:
9546 {
9547 if (temp2)
9548 delete arg2;
9549 }
9550 return NULL;
9551 }
9552
9553
9554 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9555 PyObject *resultobj = 0;
9556 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9557 int arg2 ;
9558 void *argp1 = 0 ;
9559 int res1 = 0 ;
9560 int val2 ;
9561 int ecode2 = 0 ;
9562 PyObject * obj0 = 0 ;
9563 PyObject * obj1 = 0 ;
9564 char * kwnames[] = {
9565 (char *) "self",(char *) "i", NULL
9566 };
9567
9568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9570 if (!SWIG_IsOK(res1)) {
9571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9572 }
9573 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9574 ecode2 = SWIG_AsVal_int(obj1, &val2);
9575 if (!SWIG_IsOK(ecode2)) {
9576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9577 }
9578 arg2 = static_cast< int >(val2);
9579 {
9580 PyThreadState* __tstate = wxPyBeginAllowThreads();
9581 (arg1)->RemoveFileFromHistory(arg2);
9582 wxPyEndAllowThreads(__tstate);
9583 if (PyErr_Occurred()) SWIG_fail;
9584 }
9585 resultobj = SWIG_Py_Void();
9586 return resultobj;
9587 fail:
9588 return NULL;
9589 }
9590
9591
9592 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9593 PyObject *resultobj = 0;
9594 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9595 int result;
9596 void *argp1 = 0 ;
9597 int res1 = 0 ;
9598 PyObject *swig_obj[1] ;
9599
9600 if (!args) SWIG_fail;
9601 swig_obj[0] = args;
9602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9603 if (!SWIG_IsOK(res1)) {
9604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9605 }
9606 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9607 {
9608 PyThreadState* __tstate = wxPyBeginAllowThreads();
9609 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9610 wxPyEndAllowThreads(__tstate);
9611 if (PyErr_Occurred()) SWIG_fail;
9612 }
9613 resultobj = SWIG_From_int(static_cast< int >(result));
9614 return resultobj;
9615 fail:
9616 return NULL;
9617 }
9618
9619
9620 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9621 PyObject *resultobj = 0;
9622 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9623 wxMenu *arg2 = (wxMenu *) 0 ;
9624 void *argp1 = 0 ;
9625 int res1 = 0 ;
9626 void *argp2 = 0 ;
9627 int res2 = 0 ;
9628 PyObject * obj0 = 0 ;
9629 PyObject * obj1 = 0 ;
9630 char * kwnames[] = {
9631 (char *) "self",(char *) "menu", NULL
9632 };
9633
9634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9636 if (!SWIG_IsOK(res1)) {
9637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9638 }
9639 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9640 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9641 if (!SWIG_IsOK(res2)) {
9642 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9643 }
9644 arg2 = reinterpret_cast< wxMenu * >(argp2);
9645 {
9646 PyThreadState* __tstate = wxPyBeginAllowThreads();
9647 (arg1)->UseMenu(arg2);
9648 wxPyEndAllowThreads(__tstate);
9649 if (PyErr_Occurred()) SWIG_fail;
9650 }
9651 resultobj = SWIG_Py_Void();
9652 return resultobj;
9653 fail:
9654 return NULL;
9655 }
9656
9657
9658 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9659 PyObject *resultobj = 0;
9660 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9661 wxMenu *arg2 = (wxMenu *) 0 ;
9662 void *argp1 = 0 ;
9663 int res1 = 0 ;
9664 void *argp2 = 0 ;
9665 int res2 = 0 ;
9666 PyObject * obj0 = 0 ;
9667 PyObject * obj1 = 0 ;
9668 char * kwnames[] = {
9669 (char *) "self",(char *) "menu", NULL
9670 };
9671
9672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9674 if (!SWIG_IsOK(res1)) {
9675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9676 }
9677 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9678 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9679 if (!SWIG_IsOK(res2)) {
9680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9681 }
9682 arg2 = reinterpret_cast< wxMenu * >(argp2);
9683 {
9684 PyThreadState* __tstate = wxPyBeginAllowThreads();
9685 (arg1)->RemoveMenu(arg2);
9686 wxPyEndAllowThreads(__tstate);
9687 if (PyErr_Occurred()) SWIG_fail;
9688 }
9689 resultobj = SWIG_Py_Void();
9690 return resultobj;
9691 fail:
9692 return NULL;
9693 }
9694
9695
9696 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9697 PyObject *resultobj = 0;
9698 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9699 wxConfigBase *arg2 = 0 ;
9700 void *argp1 = 0 ;
9701 int res1 = 0 ;
9702 void *argp2 = 0 ;
9703 int res2 = 0 ;
9704 PyObject * obj0 = 0 ;
9705 PyObject * obj1 = 0 ;
9706 char * kwnames[] = {
9707 (char *) "self",(char *) "config", NULL
9708 };
9709
9710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9712 if (!SWIG_IsOK(res1)) {
9713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9714 }
9715 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9716 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9717 if (!SWIG_IsOK(res2)) {
9718 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9719 }
9720 if (!argp2) {
9721 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9722 }
9723 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9724 {
9725 PyThreadState* __tstate = wxPyBeginAllowThreads();
9726 (arg1)->Load(*arg2);
9727 wxPyEndAllowThreads(__tstate);
9728 if (PyErr_Occurred()) SWIG_fail;
9729 }
9730 resultobj = SWIG_Py_Void();
9731 return resultobj;
9732 fail:
9733 return NULL;
9734 }
9735
9736
9737 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9738 PyObject *resultobj = 0;
9739 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9740 wxConfigBase *arg2 = 0 ;
9741 void *argp1 = 0 ;
9742 int res1 = 0 ;
9743 void *argp2 = 0 ;
9744 int res2 = 0 ;
9745 PyObject * obj0 = 0 ;
9746 PyObject * obj1 = 0 ;
9747 char * kwnames[] = {
9748 (char *) "self",(char *) "config", NULL
9749 };
9750
9751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9753 if (!SWIG_IsOK(res1)) {
9754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9755 }
9756 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9757 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9758 if (!SWIG_IsOK(res2)) {
9759 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9760 }
9761 if (!argp2) {
9762 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9763 }
9764 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9765 {
9766 PyThreadState* __tstate = wxPyBeginAllowThreads();
9767 (arg1)->Save(*arg2);
9768 wxPyEndAllowThreads(__tstate);
9769 if (PyErr_Occurred()) SWIG_fail;
9770 }
9771 resultobj = SWIG_Py_Void();
9772 return resultobj;
9773 fail:
9774 return NULL;
9775 }
9776
9777
9778 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9779 PyObject *resultobj = 0;
9780 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9781 void *argp1 = 0 ;
9782 int res1 = 0 ;
9783 PyObject *swig_obj[1] ;
9784
9785 if (!args) SWIG_fail;
9786 swig_obj[0] = args;
9787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9788 if (!SWIG_IsOK(res1)) {
9789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9790 }
9791 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9792 {
9793 PyThreadState* __tstate = wxPyBeginAllowThreads();
9794 (arg1)->AddFilesToMenu();
9795 wxPyEndAllowThreads(__tstate);
9796 if (PyErr_Occurred()) SWIG_fail;
9797 }
9798 resultobj = SWIG_Py_Void();
9799 return resultobj;
9800 fail:
9801 return NULL;
9802 }
9803
9804
9805 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9806 PyObject *resultobj = 0;
9807 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9808 wxMenu *arg2 = (wxMenu *) 0 ;
9809 void *argp1 = 0 ;
9810 int res1 = 0 ;
9811 void *argp2 = 0 ;
9812 int res2 = 0 ;
9813 PyObject * obj0 = 0 ;
9814 PyObject * obj1 = 0 ;
9815 char * kwnames[] = {
9816 (char *) "self",(char *) "menu", NULL
9817 };
9818
9819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9821 if (!SWIG_IsOK(res1)) {
9822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9823 }
9824 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9825 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9826 if (!SWIG_IsOK(res2)) {
9827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9828 }
9829 arg2 = reinterpret_cast< wxMenu * >(argp2);
9830 {
9831 PyThreadState* __tstate = wxPyBeginAllowThreads();
9832 (arg1)->AddFilesToMenu(arg2);
9833 wxPyEndAllowThreads(__tstate);
9834 if (PyErr_Occurred()) SWIG_fail;
9835 }
9836 resultobj = SWIG_Py_Void();
9837 return resultobj;
9838 fail:
9839 return NULL;
9840 }
9841
9842
9843 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9844 PyObject *resultobj = 0;
9845 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9846 int arg2 ;
9847 wxString result;
9848 void *argp1 = 0 ;
9849 int res1 = 0 ;
9850 int val2 ;
9851 int ecode2 = 0 ;
9852 PyObject * obj0 = 0 ;
9853 PyObject * obj1 = 0 ;
9854 char * kwnames[] = {
9855 (char *) "self",(char *) "i", NULL
9856 };
9857
9858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9860 if (!SWIG_IsOK(res1)) {
9861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9862 }
9863 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9864 ecode2 = SWIG_AsVal_int(obj1, &val2);
9865 if (!SWIG_IsOK(ecode2)) {
9866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9867 }
9868 arg2 = static_cast< int >(val2);
9869 {
9870 PyThreadState* __tstate = wxPyBeginAllowThreads();
9871 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9872 wxPyEndAllowThreads(__tstate);
9873 if (PyErr_Occurred()) SWIG_fail;
9874 }
9875 {
9876 #if wxUSE_UNICODE
9877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9878 #else
9879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9880 #endif
9881 }
9882 return resultobj;
9883 fail:
9884 return NULL;
9885 }
9886
9887
9888 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9889 PyObject *resultobj = 0;
9890 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9891 int result;
9892 void *argp1 = 0 ;
9893 int res1 = 0 ;
9894 PyObject *swig_obj[1] ;
9895
9896 if (!args) SWIG_fail;
9897 swig_obj[0] = args;
9898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9899 if (!SWIG_IsOK(res1)) {
9900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9901 }
9902 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9903 {
9904 PyThreadState* __tstate = wxPyBeginAllowThreads();
9905 result = (int)((wxFileHistory const *)arg1)->GetCount();
9906 wxPyEndAllowThreads(__tstate);
9907 if (PyErr_Occurred()) SWIG_fail;
9908 }
9909 resultobj = SWIG_From_int(static_cast< int >(result));
9910 return resultobj;
9911 fail:
9912 return NULL;
9913 }
9914
9915
9916 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9917 PyObject *obj;
9918 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9919 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9920 return SWIG_Py_Void();
9921 }
9922
9923 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9924 return SWIG_Python_InitShadowInstance(args);
9925 }
9926
9927 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9928 PyObject *resultobj = 0;
9929 wxString *arg1 = 0 ;
9930 wxString const &arg2_defvalue = wxPyEmptyString ;
9931 wxString *arg2 = (wxString *) &arg2_defvalue ;
9932 wxSingleInstanceChecker *result = 0 ;
9933 bool temp1 = false ;
9934 bool temp2 = false ;
9935 PyObject * obj0 = 0 ;
9936 PyObject * obj1 = 0 ;
9937 char * kwnames[] = {
9938 (char *) "name",(char *) "path", NULL
9939 };
9940
9941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9942 {
9943 arg1 = wxString_in_helper(obj0);
9944 if (arg1 == NULL) SWIG_fail;
9945 temp1 = true;
9946 }
9947 if (obj1) {
9948 {
9949 arg2 = wxString_in_helper(obj1);
9950 if (arg2 == NULL) SWIG_fail;
9951 temp2 = true;
9952 }
9953 }
9954 {
9955 PyThreadState* __tstate = wxPyBeginAllowThreads();
9956 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9957 wxPyEndAllowThreads(__tstate);
9958 if (PyErr_Occurred()) SWIG_fail;
9959 }
9960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9961 {
9962 if (temp1)
9963 delete arg1;
9964 }
9965 {
9966 if (temp2)
9967 delete arg2;
9968 }
9969 return resultobj;
9970 fail:
9971 {
9972 if (temp1)
9973 delete arg1;
9974 }
9975 {
9976 if (temp2)
9977 delete arg2;
9978 }
9979 return NULL;
9980 }
9981
9982
9983 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9984 PyObject *resultobj = 0;
9985 wxSingleInstanceChecker *result = 0 ;
9986
9987 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9988 {
9989 PyThreadState* __tstate = wxPyBeginAllowThreads();
9990 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9991 wxPyEndAllowThreads(__tstate);
9992 if (PyErr_Occurred()) SWIG_fail;
9993 }
9994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9995 return resultobj;
9996 fail:
9997 return NULL;
9998 }
9999
10000
10001 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10002 PyObject *resultobj = 0;
10003 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10004 void *argp1 = 0 ;
10005 int res1 = 0 ;
10006 PyObject *swig_obj[1] ;
10007
10008 if (!args) SWIG_fail;
10009 swig_obj[0] = args;
10010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10011 if (!SWIG_IsOK(res1)) {
10012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10013 }
10014 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10015 {
10016 PyThreadState* __tstate = wxPyBeginAllowThreads();
10017 delete arg1;
10018
10019 wxPyEndAllowThreads(__tstate);
10020 if (PyErr_Occurred()) SWIG_fail;
10021 }
10022 resultobj = SWIG_Py_Void();
10023 return resultobj;
10024 fail:
10025 return NULL;
10026 }
10027
10028
10029 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10030 PyObject *resultobj = 0;
10031 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10032 wxString *arg2 = 0 ;
10033 wxString const &arg3_defvalue = wxPyEmptyString ;
10034 wxString *arg3 = (wxString *) &arg3_defvalue ;
10035 bool result;
10036 void *argp1 = 0 ;
10037 int res1 = 0 ;
10038 bool temp2 = false ;
10039 bool temp3 = false ;
10040 PyObject * obj0 = 0 ;
10041 PyObject * obj1 = 0 ;
10042 PyObject * obj2 = 0 ;
10043 char * kwnames[] = {
10044 (char *) "self",(char *) "name",(char *) "path", NULL
10045 };
10046
10047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10049 if (!SWIG_IsOK(res1)) {
10050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10051 }
10052 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10053 {
10054 arg2 = wxString_in_helper(obj1);
10055 if (arg2 == NULL) SWIG_fail;
10056 temp2 = true;
10057 }
10058 if (obj2) {
10059 {
10060 arg3 = wxString_in_helper(obj2);
10061 if (arg3 == NULL) SWIG_fail;
10062 temp3 = true;
10063 }
10064 }
10065 {
10066 PyThreadState* __tstate = wxPyBeginAllowThreads();
10067 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10068 wxPyEndAllowThreads(__tstate);
10069 if (PyErr_Occurred()) SWIG_fail;
10070 }
10071 {
10072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10073 }
10074 {
10075 if (temp2)
10076 delete arg2;
10077 }
10078 {
10079 if (temp3)
10080 delete arg3;
10081 }
10082 return resultobj;
10083 fail:
10084 {
10085 if (temp2)
10086 delete arg2;
10087 }
10088 {
10089 if (temp3)
10090 delete arg3;
10091 }
10092 return NULL;
10093 }
10094
10095
10096 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10097 PyObject *resultobj = 0;
10098 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10099 bool result;
10100 void *argp1 = 0 ;
10101 int res1 = 0 ;
10102 PyObject *swig_obj[1] ;
10103
10104 if (!args) SWIG_fail;
10105 swig_obj[0] = args;
10106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10107 if (!SWIG_IsOK(res1)) {
10108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10109 }
10110 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10111 {
10112 PyThreadState* __tstate = wxPyBeginAllowThreads();
10113 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10114 wxPyEndAllowThreads(__tstate);
10115 if (PyErr_Occurred()) SWIG_fail;
10116 }
10117 {
10118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10119 }
10120 return resultobj;
10121 fail:
10122 return NULL;
10123 }
10124
10125
10126 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10127 PyObject *obj;
10128 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10129 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10130 return SWIG_Py_Void();
10131 }
10132
10133 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10134 return SWIG_Python_InitShadowInstance(args);
10135 }
10136
10137 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10138 PyObject *resultobj = 0;
10139 wxPlatformInfo *result = 0 ;
10140
10141 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10142 {
10143 PyThreadState* __tstate = wxPyBeginAllowThreads();
10144 result = (wxPlatformInfo *)new wxPlatformInfo();
10145 wxPyEndAllowThreads(__tstate);
10146 if (PyErr_Occurred()) SWIG_fail;
10147 }
10148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10149 return resultobj;
10150 fail:
10151 return NULL;
10152 }
10153
10154
10155 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10156 PyObject *resultobj = 0;
10157 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10158 wxPlatformInfo *arg2 = 0 ;
10159 bool result;
10160 void *argp1 = 0 ;
10161 int res1 = 0 ;
10162 void *argp2 = 0 ;
10163 int res2 = 0 ;
10164 PyObject * obj0 = 0 ;
10165 PyObject * obj1 = 0 ;
10166 char * kwnames[] = {
10167 (char *) "self",(char *) "t", NULL
10168 };
10169
10170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10172 if (!SWIG_IsOK(res1)) {
10173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10174 }
10175 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10176 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10177 if (!SWIG_IsOK(res2)) {
10178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10179 }
10180 if (!argp2) {
10181 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10182 }
10183 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10184 {
10185 PyThreadState* __tstate = wxPyBeginAllowThreads();
10186 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10187 wxPyEndAllowThreads(__tstate);
10188 if (PyErr_Occurred()) SWIG_fail;
10189 }
10190 {
10191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10192 }
10193 return resultobj;
10194 fail:
10195 return NULL;
10196 }
10197
10198
10199 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10200 PyObject *resultobj = 0;
10201 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10202 wxPlatformInfo *arg2 = 0 ;
10203 bool result;
10204 void *argp1 = 0 ;
10205 int res1 = 0 ;
10206 void *argp2 = 0 ;
10207 int res2 = 0 ;
10208 PyObject * obj0 = 0 ;
10209 PyObject * obj1 = 0 ;
10210 char * kwnames[] = {
10211 (char *) "self",(char *) "t", NULL
10212 };
10213
10214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10216 if (!SWIG_IsOK(res1)) {
10217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10218 }
10219 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10220 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10221 if (!SWIG_IsOK(res2)) {
10222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10223 }
10224 if (!argp2) {
10225 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10226 }
10227 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10228 {
10229 PyThreadState* __tstate = wxPyBeginAllowThreads();
10230 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10231 wxPyEndAllowThreads(__tstate);
10232 if (PyErr_Occurred()) SWIG_fail;
10233 }
10234 {
10235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10236 }
10237 return resultobj;
10238 fail:
10239 return NULL;
10240 }
10241
10242
10243 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10244 PyObject *resultobj = 0;
10245 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10246 int result;
10247 void *argp1 = 0 ;
10248 int res1 = 0 ;
10249 PyObject *swig_obj[1] ;
10250
10251 if (!args) SWIG_fail;
10252 swig_obj[0] = args;
10253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10254 if (!SWIG_IsOK(res1)) {
10255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10256 }
10257 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10258 {
10259 PyThreadState* __tstate = wxPyBeginAllowThreads();
10260 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10261 wxPyEndAllowThreads(__tstate);
10262 if (PyErr_Occurred()) SWIG_fail;
10263 }
10264 resultobj = SWIG_From_int(static_cast< int >(result));
10265 return resultobj;
10266 fail:
10267 return NULL;
10268 }
10269
10270
10271 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10272 PyObject *resultobj = 0;
10273 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10274 int result;
10275 void *argp1 = 0 ;
10276 int res1 = 0 ;
10277 PyObject *swig_obj[1] ;
10278
10279 if (!args) SWIG_fail;
10280 swig_obj[0] = args;
10281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10282 if (!SWIG_IsOK(res1)) {
10283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10284 }
10285 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10286 {
10287 PyThreadState* __tstate = wxPyBeginAllowThreads();
10288 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10289 wxPyEndAllowThreads(__tstate);
10290 if (PyErr_Occurred()) SWIG_fail;
10291 }
10292 resultobj = SWIG_From_int(static_cast< int >(result));
10293 return resultobj;
10294 fail:
10295 return NULL;
10296 }
10297
10298
10299 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10300 PyObject *resultobj = 0;
10301 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10302 int arg2 ;
10303 int arg3 ;
10304 bool result;
10305 void *argp1 = 0 ;
10306 int res1 = 0 ;
10307 int val2 ;
10308 int ecode2 = 0 ;
10309 int val3 ;
10310 int ecode3 = 0 ;
10311 PyObject * obj0 = 0 ;
10312 PyObject * obj1 = 0 ;
10313 PyObject * obj2 = 0 ;
10314 char * kwnames[] = {
10315 (char *) "self",(char *) "major",(char *) "minor", NULL
10316 };
10317
10318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10320 if (!SWIG_IsOK(res1)) {
10321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10322 }
10323 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10324 ecode2 = SWIG_AsVal_int(obj1, &val2);
10325 if (!SWIG_IsOK(ecode2)) {
10326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10327 }
10328 arg2 = static_cast< int >(val2);
10329 ecode3 = SWIG_AsVal_int(obj2, &val3);
10330 if (!SWIG_IsOK(ecode3)) {
10331 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10332 }
10333 arg3 = static_cast< int >(val3);
10334 {
10335 PyThreadState* __tstate = wxPyBeginAllowThreads();
10336 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10337 wxPyEndAllowThreads(__tstate);
10338 if (PyErr_Occurred()) SWIG_fail;
10339 }
10340 {
10341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10342 }
10343 return resultobj;
10344 fail:
10345 return NULL;
10346 }
10347
10348
10349 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10350 PyObject *resultobj = 0;
10351 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10352 int result;
10353 void *argp1 = 0 ;
10354 int res1 = 0 ;
10355 PyObject *swig_obj[1] ;
10356
10357 if (!args) SWIG_fail;
10358 swig_obj[0] = args;
10359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10360 if (!SWIG_IsOK(res1)) {
10361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10362 }
10363 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10364 {
10365 PyThreadState* __tstate = wxPyBeginAllowThreads();
10366 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10367 wxPyEndAllowThreads(__tstate);
10368 if (PyErr_Occurred()) SWIG_fail;
10369 }
10370 resultobj = SWIG_From_int(static_cast< int >(result));
10371 return resultobj;
10372 fail:
10373 return NULL;
10374 }
10375
10376
10377 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10378 PyObject *resultobj = 0;
10379 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10380 int result;
10381 void *argp1 = 0 ;
10382 int res1 = 0 ;
10383 PyObject *swig_obj[1] ;
10384
10385 if (!args) SWIG_fail;
10386 swig_obj[0] = args;
10387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10388 if (!SWIG_IsOK(res1)) {
10389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10390 }
10391 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10392 {
10393 PyThreadState* __tstate = wxPyBeginAllowThreads();
10394 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10395 wxPyEndAllowThreads(__tstate);
10396 if (PyErr_Occurred()) SWIG_fail;
10397 }
10398 resultobj = SWIG_From_int(static_cast< int >(result));
10399 return resultobj;
10400 fail:
10401 return NULL;
10402 }
10403
10404
10405 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10406 PyObject *resultobj = 0;
10407 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10408 int arg2 ;
10409 int arg3 ;
10410 bool result;
10411 void *argp1 = 0 ;
10412 int res1 = 0 ;
10413 int val2 ;
10414 int ecode2 = 0 ;
10415 int val3 ;
10416 int ecode3 = 0 ;
10417 PyObject * obj0 = 0 ;
10418 PyObject * obj1 = 0 ;
10419 PyObject * obj2 = 0 ;
10420 char * kwnames[] = {
10421 (char *) "self",(char *) "major",(char *) "minor", NULL
10422 };
10423
10424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10426 if (!SWIG_IsOK(res1)) {
10427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10428 }
10429 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10430 ecode2 = SWIG_AsVal_int(obj1, &val2);
10431 if (!SWIG_IsOK(ecode2)) {
10432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10433 }
10434 arg2 = static_cast< int >(val2);
10435 ecode3 = SWIG_AsVal_int(obj2, &val3);
10436 if (!SWIG_IsOK(ecode3)) {
10437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10438 }
10439 arg3 = static_cast< int >(val3);
10440 {
10441 PyThreadState* __tstate = wxPyBeginAllowThreads();
10442 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10443 wxPyEndAllowThreads(__tstate);
10444 if (PyErr_Occurred()) SWIG_fail;
10445 }
10446 {
10447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10448 }
10449 return resultobj;
10450 fail:
10451 return NULL;
10452 }
10453
10454
10455 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10456 PyObject *resultobj = 0;
10457 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10458 bool result;
10459 void *argp1 = 0 ;
10460 int res1 = 0 ;
10461 PyObject *swig_obj[1] ;
10462
10463 if (!args) SWIG_fail;
10464 swig_obj[0] = args;
10465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10466 if (!SWIG_IsOK(res1)) {
10467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10468 }
10469 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10470 {
10471 PyThreadState* __tstate = wxPyBeginAllowThreads();
10472 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10473 wxPyEndAllowThreads(__tstate);
10474 if (PyErr_Occurred()) SWIG_fail;
10475 }
10476 {
10477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10478 }
10479 return resultobj;
10480 fail:
10481 return NULL;
10482 }
10483
10484
10485 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10486 PyObject *resultobj = 0;
10487 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10488 wxOperatingSystemId result;
10489 void *argp1 = 0 ;
10490 int res1 = 0 ;
10491 PyObject *swig_obj[1] ;
10492
10493 if (!args) SWIG_fail;
10494 swig_obj[0] = args;
10495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10496 if (!SWIG_IsOK(res1)) {
10497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10498 }
10499 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10500 {
10501 PyThreadState* __tstate = wxPyBeginAllowThreads();
10502 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10503 wxPyEndAllowThreads(__tstate);
10504 if (PyErr_Occurred()) SWIG_fail;
10505 }
10506 resultobj = SWIG_From_int(static_cast< int >(result));
10507 return resultobj;
10508 fail:
10509 return NULL;
10510 }
10511
10512
10513 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10514 PyObject *resultobj = 0;
10515 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10516 wxPortId result;
10517 void *argp1 = 0 ;
10518 int res1 = 0 ;
10519 PyObject *swig_obj[1] ;
10520
10521 if (!args) SWIG_fail;
10522 swig_obj[0] = args;
10523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10524 if (!SWIG_IsOK(res1)) {
10525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10526 }
10527 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10528 {
10529 PyThreadState* __tstate = wxPyBeginAllowThreads();
10530 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10531 wxPyEndAllowThreads(__tstate);
10532 if (PyErr_Occurred()) SWIG_fail;
10533 }
10534 resultobj = SWIG_From_int(static_cast< int >(result));
10535 return resultobj;
10536 fail:
10537 return NULL;
10538 }
10539
10540
10541 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10542 PyObject *resultobj = 0;
10543 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10544 wxArchitecture result;
10545 void *argp1 = 0 ;
10546 int res1 = 0 ;
10547 PyObject *swig_obj[1] ;
10548
10549 if (!args) SWIG_fail;
10550 swig_obj[0] = args;
10551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10552 if (!SWIG_IsOK(res1)) {
10553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10554 }
10555 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10556 {
10557 PyThreadState* __tstate = wxPyBeginAllowThreads();
10558 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10559 wxPyEndAllowThreads(__tstate);
10560 if (PyErr_Occurred()) SWIG_fail;
10561 }
10562 resultobj = SWIG_From_int(static_cast< int >(result));
10563 return resultobj;
10564 fail:
10565 return NULL;
10566 }
10567
10568
10569 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10570 PyObject *resultobj = 0;
10571 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10572 wxEndianness result;
10573 void *argp1 = 0 ;
10574 int res1 = 0 ;
10575 PyObject *swig_obj[1] ;
10576
10577 if (!args) SWIG_fail;
10578 swig_obj[0] = args;
10579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10580 if (!SWIG_IsOK(res1)) {
10581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10582 }
10583 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10584 {
10585 PyThreadState* __tstate = wxPyBeginAllowThreads();
10586 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10587 wxPyEndAllowThreads(__tstate);
10588 if (PyErr_Occurred()) SWIG_fail;
10589 }
10590 resultobj = SWIG_From_int(static_cast< int >(result));
10591 return resultobj;
10592 fail:
10593 return NULL;
10594 }
10595
10596
10597 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10598 PyObject *resultobj = 0;
10599 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10600 wxString result;
10601 void *argp1 = 0 ;
10602 int res1 = 0 ;
10603 PyObject *swig_obj[1] ;
10604
10605 if (!args) SWIG_fail;
10606 swig_obj[0] = args;
10607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10608 if (!SWIG_IsOK(res1)) {
10609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10610 }
10611 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10612 {
10613 PyThreadState* __tstate = wxPyBeginAllowThreads();
10614 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10615 wxPyEndAllowThreads(__tstate);
10616 if (PyErr_Occurred()) SWIG_fail;
10617 }
10618 {
10619 #if wxUSE_UNICODE
10620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10621 #else
10622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10623 #endif
10624 }
10625 return resultobj;
10626 fail:
10627 return NULL;
10628 }
10629
10630
10631 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10632 PyObject *resultobj = 0;
10633 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10634 wxString result;
10635 void *argp1 = 0 ;
10636 int res1 = 0 ;
10637 PyObject *swig_obj[1] ;
10638
10639 if (!args) SWIG_fail;
10640 swig_obj[0] = args;
10641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10642 if (!SWIG_IsOK(res1)) {
10643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10644 }
10645 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10646 {
10647 PyThreadState* __tstate = wxPyBeginAllowThreads();
10648 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10649 wxPyEndAllowThreads(__tstate);
10650 if (PyErr_Occurred()) SWIG_fail;
10651 }
10652 {
10653 #if wxUSE_UNICODE
10654 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10655 #else
10656 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10657 #endif
10658 }
10659 return resultobj;
10660 fail:
10661 return NULL;
10662 }
10663
10664
10665 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10666 PyObject *resultobj = 0;
10667 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10668 wxString result;
10669 void *argp1 = 0 ;
10670 int res1 = 0 ;
10671 PyObject *swig_obj[1] ;
10672
10673 if (!args) SWIG_fail;
10674 swig_obj[0] = args;
10675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10676 if (!SWIG_IsOK(res1)) {
10677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10678 }
10679 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10680 {
10681 PyThreadState* __tstate = wxPyBeginAllowThreads();
10682 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10683 wxPyEndAllowThreads(__tstate);
10684 if (PyErr_Occurred()) SWIG_fail;
10685 }
10686 {
10687 #if wxUSE_UNICODE
10688 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10689 #else
10690 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10691 #endif
10692 }
10693 return resultobj;
10694 fail:
10695 return NULL;
10696 }
10697
10698
10699 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10700 PyObject *resultobj = 0;
10701 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10702 wxString result;
10703 void *argp1 = 0 ;
10704 int res1 = 0 ;
10705 PyObject *swig_obj[1] ;
10706
10707 if (!args) SWIG_fail;
10708 swig_obj[0] = args;
10709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10710 if (!SWIG_IsOK(res1)) {
10711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10712 }
10713 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10714 {
10715 PyThreadState* __tstate = wxPyBeginAllowThreads();
10716 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10717 wxPyEndAllowThreads(__tstate);
10718 if (PyErr_Occurred()) SWIG_fail;
10719 }
10720 {
10721 #if wxUSE_UNICODE
10722 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10723 #else
10724 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10725 #endif
10726 }
10727 return resultobj;
10728 fail:
10729 return NULL;
10730 }
10731
10732
10733 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10734 PyObject *resultobj = 0;
10735 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10736 wxString result;
10737 void *argp1 = 0 ;
10738 int res1 = 0 ;
10739 PyObject *swig_obj[1] ;
10740
10741 if (!args) SWIG_fail;
10742 swig_obj[0] = args;
10743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10744 if (!SWIG_IsOK(res1)) {
10745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10746 }
10747 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10748 {
10749 PyThreadState* __tstate = wxPyBeginAllowThreads();
10750 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10751 wxPyEndAllowThreads(__tstate);
10752 if (PyErr_Occurred()) SWIG_fail;
10753 }
10754 {
10755 #if wxUSE_UNICODE
10756 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10757 #else
10758 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10759 #endif
10760 }
10761 return resultobj;
10762 fail:
10763 return NULL;
10764 }
10765
10766
10767 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10768 PyObject *resultobj = 0;
10769 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10770 wxString result;
10771 void *argp1 = 0 ;
10772 int res1 = 0 ;
10773 PyObject *swig_obj[1] ;
10774
10775 if (!args) SWIG_fail;
10776 swig_obj[0] = args;
10777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10778 if (!SWIG_IsOK(res1)) {
10779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10780 }
10781 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10782 {
10783 PyThreadState* __tstate = wxPyBeginAllowThreads();
10784 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10785 wxPyEndAllowThreads(__tstate);
10786 if (PyErr_Occurred()) SWIG_fail;
10787 }
10788 {
10789 #if wxUSE_UNICODE
10790 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10791 #else
10792 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10793 #endif
10794 }
10795 return resultobj;
10796 fail:
10797 return NULL;
10798 }
10799
10800
10801 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10802 PyObject *resultobj = 0;
10803 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10804 int arg2 ;
10805 int arg3 ;
10806 void *argp1 = 0 ;
10807 int res1 = 0 ;
10808 int val2 ;
10809 int ecode2 = 0 ;
10810 int val3 ;
10811 int ecode3 = 0 ;
10812 PyObject * obj0 = 0 ;
10813 PyObject * obj1 = 0 ;
10814 PyObject * obj2 = 0 ;
10815 char * kwnames[] = {
10816 (char *) "self",(char *) "major",(char *) "minor", NULL
10817 };
10818
10819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10821 if (!SWIG_IsOK(res1)) {
10822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10823 }
10824 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10825 ecode2 = SWIG_AsVal_int(obj1, &val2);
10826 if (!SWIG_IsOK(ecode2)) {
10827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10828 }
10829 arg2 = static_cast< int >(val2);
10830 ecode3 = SWIG_AsVal_int(obj2, &val3);
10831 if (!SWIG_IsOK(ecode3)) {
10832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10833 }
10834 arg3 = static_cast< int >(val3);
10835 {
10836 PyThreadState* __tstate = wxPyBeginAllowThreads();
10837 (arg1)->SetOSVersion(arg2,arg3);
10838 wxPyEndAllowThreads(__tstate);
10839 if (PyErr_Occurred()) SWIG_fail;
10840 }
10841 resultobj = SWIG_Py_Void();
10842 return resultobj;
10843 fail:
10844 return NULL;
10845 }
10846
10847
10848 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10849 PyObject *resultobj = 0;
10850 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10851 int arg2 ;
10852 int arg3 ;
10853 void *argp1 = 0 ;
10854 int res1 = 0 ;
10855 int val2 ;
10856 int ecode2 = 0 ;
10857 int val3 ;
10858 int ecode3 = 0 ;
10859 PyObject * obj0 = 0 ;
10860 PyObject * obj1 = 0 ;
10861 PyObject * obj2 = 0 ;
10862 char * kwnames[] = {
10863 (char *) "self",(char *) "major",(char *) "minor", NULL
10864 };
10865
10866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10868 if (!SWIG_IsOK(res1)) {
10869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10870 }
10871 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10872 ecode2 = SWIG_AsVal_int(obj1, &val2);
10873 if (!SWIG_IsOK(ecode2)) {
10874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10875 }
10876 arg2 = static_cast< int >(val2);
10877 ecode3 = SWIG_AsVal_int(obj2, &val3);
10878 if (!SWIG_IsOK(ecode3)) {
10879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10880 }
10881 arg3 = static_cast< int >(val3);
10882 {
10883 PyThreadState* __tstate = wxPyBeginAllowThreads();
10884 (arg1)->SetToolkitVersion(arg2,arg3);
10885 wxPyEndAllowThreads(__tstate);
10886 if (PyErr_Occurred()) SWIG_fail;
10887 }
10888 resultobj = SWIG_Py_Void();
10889 return resultobj;
10890 fail:
10891 return NULL;
10892 }
10893
10894
10895 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10896 PyObject *resultobj = 0;
10897 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10898 wxOperatingSystemId arg2 ;
10899 void *argp1 = 0 ;
10900 int res1 = 0 ;
10901 int val2 ;
10902 int ecode2 = 0 ;
10903 PyObject * obj0 = 0 ;
10904 PyObject * obj1 = 0 ;
10905 char * kwnames[] = {
10906 (char *) "self",(char *) "n", NULL
10907 };
10908
10909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10911 if (!SWIG_IsOK(res1)) {
10912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10913 }
10914 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10915 ecode2 = SWIG_AsVal_int(obj1, &val2);
10916 if (!SWIG_IsOK(ecode2)) {
10917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10918 }
10919 arg2 = static_cast< wxOperatingSystemId >(val2);
10920 {
10921 PyThreadState* __tstate = wxPyBeginAllowThreads();
10922 (arg1)->SetOperatingSystemId(arg2);
10923 wxPyEndAllowThreads(__tstate);
10924 if (PyErr_Occurred()) SWIG_fail;
10925 }
10926 resultobj = SWIG_Py_Void();
10927 return resultobj;
10928 fail:
10929 return NULL;
10930 }
10931
10932
10933 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10934 PyObject *resultobj = 0;
10935 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10936 wxPortId arg2 ;
10937 void *argp1 = 0 ;
10938 int res1 = 0 ;
10939 int val2 ;
10940 int ecode2 = 0 ;
10941 PyObject * obj0 = 0 ;
10942 PyObject * obj1 = 0 ;
10943 char * kwnames[] = {
10944 (char *) "self",(char *) "n", NULL
10945 };
10946
10947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10949 if (!SWIG_IsOK(res1)) {
10950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10951 }
10952 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10953 ecode2 = SWIG_AsVal_int(obj1, &val2);
10954 if (!SWIG_IsOK(ecode2)) {
10955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10956 }
10957 arg2 = static_cast< wxPortId >(val2);
10958 {
10959 PyThreadState* __tstate = wxPyBeginAllowThreads();
10960 (arg1)->SetPortId(arg2);
10961 wxPyEndAllowThreads(__tstate);
10962 if (PyErr_Occurred()) SWIG_fail;
10963 }
10964 resultobj = SWIG_Py_Void();
10965 return resultobj;
10966 fail:
10967 return NULL;
10968 }
10969
10970
10971 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10972 PyObject *resultobj = 0;
10973 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10974 wxArchitecture arg2 ;
10975 void *argp1 = 0 ;
10976 int res1 = 0 ;
10977 int val2 ;
10978 int ecode2 = 0 ;
10979 PyObject * obj0 = 0 ;
10980 PyObject * obj1 = 0 ;
10981 char * kwnames[] = {
10982 (char *) "self",(char *) "n", NULL
10983 };
10984
10985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10987 if (!SWIG_IsOK(res1)) {
10988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10989 }
10990 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10991 ecode2 = SWIG_AsVal_int(obj1, &val2);
10992 if (!SWIG_IsOK(ecode2)) {
10993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
10994 }
10995 arg2 = static_cast< wxArchitecture >(val2);
10996 {
10997 PyThreadState* __tstate = wxPyBeginAllowThreads();
10998 (arg1)->SetArchitecture(arg2);
10999 wxPyEndAllowThreads(__tstate);
11000 if (PyErr_Occurred()) SWIG_fail;
11001 }
11002 resultobj = SWIG_Py_Void();
11003 return resultobj;
11004 fail:
11005 return NULL;
11006 }
11007
11008
11009 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11010 PyObject *resultobj = 0;
11011 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11012 wxEndianness arg2 ;
11013 void *argp1 = 0 ;
11014 int res1 = 0 ;
11015 int val2 ;
11016 int ecode2 = 0 ;
11017 PyObject * obj0 = 0 ;
11018 PyObject * obj1 = 0 ;
11019 char * kwnames[] = {
11020 (char *) "self",(char *) "n", NULL
11021 };
11022
11023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11025 if (!SWIG_IsOK(res1)) {
11026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11027 }
11028 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11029 ecode2 = SWIG_AsVal_int(obj1, &val2);
11030 if (!SWIG_IsOK(ecode2)) {
11031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11032 }
11033 arg2 = static_cast< wxEndianness >(val2);
11034 {
11035 PyThreadState* __tstate = wxPyBeginAllowThreads();
11036 (arg1)->SetEndianness(arg2);
11037 wxPyEndAllowThreads(__tstate);
11038 if (PyErr_Occurred()) SWIG_fail;
11039 }
11040 resultobj = SWIG_Py_Void();
11041 return resultobj;
11042 fail:
11043 return NULL;
11044 }
11045
11046
11047 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11048 PyObject *resultobj = 0;
11049 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11050 bool result;
11051 void *argp1 = 0 ;
11052 int res1 = 0 ;
11053 PyObject *swig_obj[1] ;
11054
11055 if (!args) SWIG_fail;
11056 swig_obj[0] = args;
11057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11058 if (!SWIG_IsOK(res1)) {
11059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11060 }
11061 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11062 {
11063 PyThreadState* __tstate = wxPyBeginAllowThreads();
11064 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11065 wxPyEndAllowThreads(__tstate);
11066 if (PyErr_Occurred()) SWIG_fail;
11067 }
11068 {
11069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11070 }
11071 return resultobj;
11072 fail:
11073 return NULL;
11074 }
11075
11076
11077 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11078 PyObject *obj;
11079 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11080 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11081 return SWIG_Py_Void();
11082 }
11083
11084 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11085 return SWIG_Python_InitShadowInstance(args);
11086 }
11087
11088 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11089 PyObject *resultobj = 0;
11090 wxWindow *arg1 = (wxWindow *) 0 ;
11091 wxDC *arg2 = 0 ;
11092 bool result;
11093 void *argp1 = 0 ;
11094 int res1 = 0 ;
11095 void *argp2 = 0 ;
11096 int res2 = 0 ;
11097 PyObject * obj0 = 0 ;
11098 PyObject * obj1 = 0 ;
11099 char * kwnames[] = {
11100 (char *) "window",(char *) "dc", NULL
11101 };
11102
11103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11105 if (!SWIG_IsOK(res1)) {
11106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11107 }
11108 arg1 = reinterpret_cast< wxWindow * >(argp1);
11109 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11110 if (!SWIG_IsOK(res2)) {
11111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11112 }
11113 if (!argp2) {
11114 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11115 }
11116 arg2 = reinterpret_cast< wxDC * >(argp2);
11117 {
11118 PyThreadState* __tstate = wxPyBeginAllowThreads();
11119 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11120 wxPyEndAllowThreads(__tstate);
11121 if (PyErr_Occurred()) SWIG_fail;
11122 }
11123 {
11124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11125 }
11126 return resultobj;
11127 fail:
11128 return NULL;
11129 }
11130
11131
11132 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11133 PyObject *resultobj = 0;
11134 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11135 void *argp1 = 0 ;
11136 int res1 = 0 ;
11137 PyObject *swig_obj[1] ;
11138
11139 if (!args) SWIG_fail;
11140 swig_obj[0] = args;
11141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11142 if (!SWIG_IsOK(res1)) {
11143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11144 }
11145 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11146 {
11147 PyThreadState* __tstate = wxPyBeginAllowThreads();
11148 delete arg1;
11149
11150 wxPyEndAllowThreads(__tstate);
11151 if (PyErr_Occurred()) SWIG_fail;
11152 }
11153 resultobj = SWIG_Py_Void();
11154 return resultobj;
11155 fail:
11156 return NULL;
11157 }
11158
11159
11160 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11161 PyObject *resultobj = 0;
11162 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11163 wxString result;
11164 void *argp1 = 0 ;
11165 int res1 = 0 ;
11166 PyObject *swig_obj[1] ;
11167
11168 if (!args) SWIG_fail;
11169 swig_obj[0] = args;
11170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11171 if (!SWIG_IsOK(res1)) {
11172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11173 }
11174 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11175 {
11176 PyThreadState* __tstate = wxPyBeginAllowThreads();
11177 result = (arg1)->GetTip();
11178 wxPyEndAllowThreads(__tstate);
11179 if (PyErr_Occurred()) SWIG_fail;
11180 }
11181 {
11182 #if wxUSE_UNICODE
11183 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11184 #else
11185 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11186 #endif
11187 }
11188 return resultobj;
11189 fail:
11190 return NULL;
11191 }
11192
11193
11194 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11195 PyObject *resultobj = 0;
11196 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11197 size_t result;
11198 void *argp1 = 0 ;
11199 int res1 = 0 ;
11200 PyObject *swig_obj[1] ;
11201
11202 if (!args) SWIG_fail;
11203 swig_obj[0] = args;
11204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11205 if (!SWIG_IsOK(res1)) {
11206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11207 }
11208 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11209 {
11210 PyThreadState* __tstate = wxPyBeginAllowThreads();
11211 result = (size_t)(arg1)->GetCurrentTip();
11212 wxPyEndAllowThreads(__tstate);
11213 if (PyErr_Occurred()) SWIG_fail;
11214 }
11215 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11216 return resultobj;
11217 fail:
11218 return NULL;
11219 }
11220
11221
11222 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11223 PyObject *resultobj = 0;
11224 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11225 wxString *arg2 = 0 ;
11226 wxString result;
11227 void *argp1 = 0 ;
11228 int res1 = 0 ;
11229 bool temp2 = false ;
11230 PyObject * obj0 = 0 ;
11231 PyObject * obj1 = 0 ;
11232 char * kwnames[] = {
11233 (char *) "self",(char *) "tip", NULL
11234 };
11235
11236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11238 if (!SWIG_IsOK(res1)) {
11239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11240 }
11241 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11242 {
11243 arg2 = wxString_in_helper(obj1);
11244 if (arg2 == NULL) SWIG_fail;
11245 temp2 = true;
11246 }
11247 {
11248 PyThreadState* __tstate = wxPyBeginAllowThreads();
11249 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11250 wxPyEndAllowThreads(__tstate);
11251 if (PyErr_Occurred()) SWIG_fail;
11252 }
11253 {
11254 #if wxUSE_UNICODE
11255 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11256 #else
11257 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11258 #endif
11259 }
11260 {
11261 if (temp2)
11262 delete arg2;
11263 }
11264 return resultobj;
11265 fail:
11266 {
11267 if (temp2)
11268 delete arg2;
11269 }
11270 return NULL;
11271 }
11272
11273
11274 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11275 PyObject *obj;
11276 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11277 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11278 return SWIG_Py_Void();
11279 }
11280
11281 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11282 PyObject *resultobj = 0;
11283 size_t arg1 ;
11284 wxPyTipProvider *result = 0 ;
11285 size_t val1 ;
11286 int ecode1 = 0 ;
11287 PyObject * obj0 = 0 ;
11288 char * kwnames[] = {
11289 (char *) "currentTip", NULL
11290 };
11291
11292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11293 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11294 if (!SWIG_IsOK(ecode1)) {
11295 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11296 }
11297 arg1 = static_cast< size_t >(val1);
11298 {
11299 PyThreadState* __tstate = wxPyBeginAllowThreads();
11300 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11301 wxPyEndAllowThreads(__tstate);
11302 if (PyErr_Occurred()) SWIG_fail;
11303 }
11304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11305 return resultobj;
11306 fail:
11307 return NULL;
11308 }
11309
11310
11311 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11312 PyObject *resultobj = 0;
11313 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11314 PyObject *arg2 = (PyObject *) 0 ;
11315 PyObject *arg3 = (PyObject *) 0 ;
11316 void *argp1 = 0 ;
11317 int res1 = 0 ;
11318 PyObject * obj0 = 0 ;
11319 PyObject * obj1 = 0 ;
11320 PyObject * obj2 = 0 ;
11321 char * kwnames[] = {
11322 (char *) "self",(char *) "self",(char *) "_class", NULL
11323 };
11324
11325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11327 if (!SWIG_IsOK(res1)) {
11328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11329 }
11330 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11331 arg2 = obj1;
11332 arg3 = obj2;
11333 {
11334 PyThreadState* __tstate = wxPyBeginAllowThreads();
11335 (arg1)->_setCallbackInfo(arg2,arg3);
11336 wxPyEndAllowThreads(__tstate);
11337 if (PyErr_Occurred()) SWIG_fail;
11338 }
11339 resultobj = SWIG_Py_Void();
11340 return resultobj;
11341 fail:
11342 return NULL;
11343 }
11344
11345
11346 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11347 PyObject *obj;
11348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11349 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11350 return SWIG_Py_Void();
11351 }
11352
11353 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11354 return SWIG_Python_InitShadowInstance(args);
11355 }
11356
11357 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11358 PyObject *resultobj = 0;
11359 wxWindow *arg1 = (wxWindow *) 0 ;
11360 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11361 bool arg3 = (bool) true ;
11362 bool result;
11363 void *argp1 = 0 ;
11364 int res1 = 0 ;
11365 void *argp2 = 0 ;
11366 int res2 = 0 ;
11367 bool val3 ;
11368 int ecode3 = 0 ;
11369 PyObject * obj0 = 0 ;
11370 PyObject * obj1 = 0 ;
11371 PyObject * obj2 = 0 ;
11372 char * kwnames[] = {
11373 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11374 };
11375
11376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11378 if (!SWIG_IsOK(res1)) {
11379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11380 }
11381 arg1 = reinterpret_cast< wxWindow * >(argp1);
11382 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11383 if (!SWIG_IsOK(res2)) {
11384 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11385 }
11386 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11387 if (obj2) {
11388 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11389 if (!SWIG_IsOK(ecode3)) {
11390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11391 }
11392 arg3 = static_cast< bool >(val3);
11393 }
11394 {
11395 if (!wxPyCheckForApp()) SWIG_fail;
11396 PyThreadState* __tstate = wxPyBeginAllowThreads();
11397 result = (bool)wxShowTip(arg1,arg2,arg3);
11398 wxPyEndAllowThreads(__tstate);
11399 if (PyErr_Occurred()) SWIG_fail;
11400 }
11401 {
11402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11403 }
11404 return resultobj;
11405 fail:
11406 return NULL;
11407 }
11408
11409
11410 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11411 PyObject *resultobj = 0;
11412 wxString *arg1 = 0 ;
11413 size_t arg2 ;
11414 wxTipProvider *result = 0 ;
11415 bool temp1 = false ;
11416 size_t val2 ;
11417 int ecode2 = 0 ;
11418 PyObject * obj0 = 0 ;
11419 PyObject * obj1 = 0 ;
11420 char * kwnames[] = {
11421 (char *) "filename",(char *) "currentTip", NULL
11422 };
11423
11424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11425 {
11426 arg1 = wxString_in_helper(obj0);
11427 if (arg1 == NULL) SWIG_fail;
11428 temp1 = true;
11429 }
11430 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11431 if (!SWIG_IsOK(ecode2)) {
11432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11433 }
11434 arg2 = static_cast< size_t >(val2);
11435 {
11436 if (!wxPyCheckForApp()) SWIG_fail;
11437 PyThreadState* __tstate = wxPyBeginAllowThreads();
11438 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11439 wxPyEndAllowThreads(__tstate);
11440 if (PyErr_Occurred()) SWIG_fail;
11441 }
11442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11443 {
11444 if (temp1)
11445 delete arg1;
11446 }
11447 return resultobj;
11448 fail:
11449 {
11450 if (temp1)
11451 delete arg1;
11452 }
11453 return NULL;
11454 }
11455
11456
11457 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11458 PyObject *resultobj = 0;
11459 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11460 int arg2 = (int) wxID_ANY ;
11461 wxPyTimer *result = 0 ;
11462 void *argp1 = 0 ;
11463 int res1 = 0 ;
11464 int val2 ;
11465 int ecode2 = 0 ;
11466 PyObject * obj0 = 0 ;
11467 PyObject * obj1 = 0 ;
11468 char * kwnames[] = {
11469 (char *) "owner",(char *) "id", NULL
11470 };
11471
11472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11473 if (obj0) {
11474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11475 if (!SWIG_IsOK(res1)) {
11476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11477 }
11478 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11479 }
11480 if (obj1) {
11481 ecode2 = SWIG_AsVal_int(obj1, &val2);
11482 if (!SWIG_IsOK(ecode2)) {
11483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11484 }
11485 arg2 = static_cast< int >(val2);
11486 }
11487 {
11488 if (!wxPyCheckForApp()) SWIG_fail;
11489 PyThreadState* __tstate = wxPyBeginAllowThreads();
11490 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11491 wxPyEndAllowThreads(__tstate);
11492 if (PyErr_Occurred()) SWIG_fail;
11493 }
11494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11495 return resultobj;
11496 fail:
11497 return NULL;
11498 }
11499
11500
11501 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11502 PyObject *resultobj = 0;
11503 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11504 void *argp1 = 0 ;
11505 int res1 = 0 ;
11506 PyObject *swig_obj[1] ;
11507
11508 if (!args) SWIG_fail;
11509 swig_obj[0] = args;
11510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11511 if (!SWIG_IsOK(res1)) {
11512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11513 }
11514 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11515 {
11516 PyThreadState* __tstate = wxPyBeginAllowThreads();
11517 delete arg1;
11518
11519 wxPyEndAllowThreads(__tstate);
11520 if (PyErr_Occurred()) SWIG_fail;
11521 }
11522 resultobj = SWIG_Py_Void();
11523 return resultobj;
11524 fail:
11525 return NULL;
11526 }
11527
11528
11529 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11530 PyObject *resultobj = 0;
11531 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11532 PyObject *arg2 = (PyObject *) 0 ;
11533 PyObject *arg3 = (PyObject *) 0 ;
11534 int arg4 = (int) 1 ;
11535 void *argp1 = 0 ;
11536 int res1 = 0 ;
11537 int val4 ;
11538 int ecode4 = 0 ;
11539 PyObject * obj0 = 0 ;
11540 PyObject * obj1 = 0 ;
11541 PyObject * obj2 = 0 ;
11542 PyObject * obj3 = 0 ;
11543 char * kwnames[] = {
11544 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11545 };
11546
11547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11549 if (!SWIG_IsOK(res1)) {
11550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11551 }
11552 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11553 arg2 = obj1;
11554 arg3 = obj2;
11555 if (obj3) {
11556 ecode4 = SWIG_AsVal_int(obj3, &val4);
11557 if (!SWIG_IsOK(ecode4)) {
11558 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11559 }
11560 arg4 = static_cast< int >(val4);
11561 }
11562 {
11563 PyThreadState* __tstate = wxPyBeginAllowThreads();
11564 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11565 wxPyEndAllowThreads(__tstate);
11566 if (PyErr_Occurred()) SWIG_fail;
11567 }
11568 resultobj = SWIG_Py_Void();
11569 return resultobj;
11570 fail:
11571 return NULL;
11572 }
11573
11574
11575 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11576 PyObject *resultobj = 0;
11577 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11578 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11579 int arg3 = (int) wxID_ANY ;
11580 void *argp1 = 0 ;
11581 int res1 = 0 ;
11582 void *argp2 = 0 ;
11583 int res2 = 0 ;
11584 int val3 ;
11585 int ecode3 = 0 ;
11586 PyObject * obj0 = 0 ;
11587 PyObject * obj1 = 0 ;
11588 PyObject * obj2 = 0 ;
11589 char * kwnames[] = {
11590 (char *) "self",(char *) "owner",(char *) "id", NULL
11591 };
11592
11593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11595 if (!SWIG_IsOK(res1)) {
11596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11597 }
11598 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11599 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11600 if (!SWIG_IsOK(res2)) {
11601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11602 }
11603 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11604 if (obj2) {
11605 ecode3 = SWIG_AsVal_int(obj2, &val3);
11606 if (!SWIG_IsOK(ecode3)) {
11607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11608 }
11609 arg3 = static_cast< int >(val3);
11610 }
11611 {
11612 PyThreadState* __tstate = wxPyBeginAllowThreads();
11613 (arg1)->SetOwner(arg2,arg3);
11614 wxPyEndAllowThreads(__tstate);
11615 if (PyErr_Occurred()) SWIG_fail;
11616 }
11617 resultobj = SWIG_Py_Void();
11618 return resultobj;
11619 fail:
11620 return NULL;
11621 }
11622
11623
11624 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11625 PyObject *resultobj = 0;
11626 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11627 wxEvtHandler *result = 0 ;
11628 void *argp1 = 0 ;
11629 int res1 = 0 ;
11630 PyObject *swig_obj[1] ;
11631
11632 if (!args) SWIG_fail;
11633 swig_obj[0] = args;
11634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11635 if (!SWIG_IsOK(res1)) {
11636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11637 }
11638 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11639 {
11640 PyThreadState* __tstate = wxPyBeginAllowThreads();
11641 result = (wxEvtHandler *)(arg1)->GetOwner();
11642 wxPyEndAllowThreads(__tstate);
11643 if (PyErr_Occurred()) SWIG_fail;
11644 }
11645 {
11646 resultobj = wxPyMake_wxObject(result, 0);
11647 }
11648 return resultobj;
11649 fail:
11650 return NULL;
11651 }
11652
11653
11654 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11655 PyObject *resultobj = 0;
11656 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11657 int arg2 = (int) -1 ;
11658 bool arg3 = (bool) false ;
11659 bool result;
11660 void *argp1 = 0 ;
11661 int res1 = 0 ;
11662 int val2 ;
11663 int ecode2 = 0 ;
11664 bool val3 ;
11665 int ecode3 = 0 ;
11666 PyObject * obj0 = 0 ;
11667 PyObject * obj1 = 0 ;
11668 PyObject * obj2 = 0 ;
11669 char * kwnames[] = {
11670 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11671 };
11672
11673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11675 if (!SWIG_IsOK(res1)) {
11676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11677 }
11678 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11679 if (obj1) {
11680 ecode2 = SWIG_AsVal_int(obj1, &val2);
11681 if (!SWIG_IsOK(ecode2)) {
11682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11683 }
11684 arg2 = static_cast< int >(val2);
11685 }
11686 if (obj2) {
11687 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11688 if (!SWIG_IsOK(ecode3)) {
11689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11690 }
11691 arg3 = static_cast< bool >(val3);
11692 }
11693 {
11694 PyThreadState* __tstate = wxPyBeginAllowThreads();
11695 result = (bool)(arg1)->Start(arg2,arg3);
11696 wxPyEndAllowThreads(__tstate);
11697 if (PyErr_Occurred()) SWIG_fail;
11698 }
11699 {
11700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11701 }
11702 return resultobj;
11703 fail:
11704 return NULL;
11705 }
11706
11707
11708 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11709 PyObject *resultobj = 0;
11710 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11711 void *argp1 = 0 ;
11712 int res1 = 0 ;
11713 PyObject *swig_obj[1] ;
11714
11715 if (!args) SWIG_fail;
11716 swig_obj[0] = args;
11717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11718 if (!SWIG_IsOK(res1)) {
11719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11720 }
11721 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11722 {
11723 PyThreadState* __tstate = wxPyBeginAllowThreads();
11724 (arg1)->Stop();
11725 wxPyEndAllowThreads(__tstate);
11726 if (PyErr_Occurred()) SWIG_fail;
11727 }
11728 resultobj = SWIG_Py_Void();
11729 return resultobj;
11730 fail:
11731 return NULL;
11732 }
11733
11734
11735 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11736 PyObject *resultobj = 0;
11737 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11738 void *argp1 = 0 ;
11739 int res1 = 0 ;
11740 PyObject *swig_obj[1] ;
11741
11742 if (!args) SWIG_fail;
11743 swig_obj[0] = args;
11744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11745 if (!SWIG_IsOK(res1)) {
11746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11747 }
11748 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11749 {
11750 PyThreadState* __tstate = wxPyBeginAllowThreads();
11751 (arg1)->Notify();
11752 wxPyEndAllowThreads(__tstate);
11753 if (PyErr_Occurred()) SWIG_fail;
11754 }
11755 resultobj = SWIG_Py_Void();
11756 return resultobj;
11757 fail:
11758 return NULL;
11759 }
11760
11761
11762 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11763 PyObject *resultobj = 0;
11764 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11765 bool result;
11766 void *argp1 = 0 ;
11767 int res1 = 0 ;
11768 PyObject *swig_obj[1] ;
11769
11770 if (!args) SWIG_fail;
11771 swig_obj[0] = args;
11772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11773 if (!SWIG_IsOK(res1)) {
11774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11775 }
11776 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11777 {
11778 PyThreadState* __tstate = wxPyBeginAllowThreads();
11779 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11780 wxPyEndAllowThreads(__tstate);
11781 if (PyErr_Occurred()) SWIG_fail;
11782 }
11783 {
11784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11785 }
11786 return resultobj;
11787 fail:
11788 return NULL;
11789 }
11790
11791
11792 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11793 PyObject *resultobj = 0;
11794 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11795 int result;
11796 void *argp1 = 0 ;
11797 int res1 = 0 ;
11798 PyObject *swig_obj[1] ;
11799
11800 if (!args) SWIG_fail;
11801 swig_obj[0] = args;
11802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11803 if (!SWIG_IsOK(res1)) {
11804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11805 }
11806 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11807 {
11808 PyThreadState* __tstate = wxPyBeginAllowThreads();
11809 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11810 wxPyEndAllowThreads(__tstate);
11811 if (PyErr_Occurred()) SWIG_fail;
11812 }
11813 resultobj = SWIG_From_int(static_cast< int >(result));
11814 return resultobj;
11815 fail:
11816 return NULL;
11817 }
11818
11819
11820 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11821 PyObject *resultobj = 0;
11822 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11823 int result;
11824 void *argp1 = 0 ;
11825 int res1 = 0 ;
11826 PyObject *swig_obj[1] ;
11827
11828 if (!args) SWIG_fail;
11829 swig_obj[0] = args;
11830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11831 if (!SWIG_IsOK(res1)) {
11832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11833 }
11834 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11835 {
11836 PyThreadState* __tstate = wxPyBeginAllowThreads();
11837 result = (int)((wxPyTimer const *)arg1)->GetId();
11838 wxPyEndAllowThreads(__tstate);
11839 if (PyErr_Occurred()) SWIG_fail;
11840 }
11841 resultobj = SWIG_From_int(static_cast< int >(result));
11842 return resultobj;
11843 fail:
11844 return NULL;
11845 }
11846
11847
11848 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11849 PyObject *resultobj = 0;
11850 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11851 bool result;
11852 void *argp1 = 0 ;
11853 int res1 = 0 ;
11854 PyObject *swig_obj[1] ;
11855
11856 if (!args) SWIG_fail;
11857 swig_obj[0] = args;
11858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11859 if (!SWIG_IsOK(res1)) {
11860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11861 }
11862 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11863 {
11864 PyThreadState* __tstate = wxPyBeginAllowThreads();
11865 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11866 wxPyEndAllowThreads(__tstate);
11867 if (PyErr_Occurred()) SWIG_fail;
11868 }
11869 {
11870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11871 }
11872 return resultobj;
11873 fail:
11874 return NULL;
11875 }
11876
11877
11878 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11879 PyObject *obj;
11880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11881 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11882 return SWIG_Py_Void();
11883 }
11884
11885 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11886 return SWIG_Python_InitShadowInstance(args);
11887 }
11888
11889 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11890 PyObject *resultobj = 0;
11891 int arg1 = (int) 0 ;
11892 int arg2 = (int) 0 ;
11893 wxTimerEvent *result = 0 ;
11894 int val1 ;
11895 int ecode1 = 0 ;
11896 int val2 ;
11897 int ecode2 = 0 ;
11898 PyObject * obj0 = 0 ;
11899 PyObject * obj1 = 0 ;
11900 char * kwnames[] = {
11901 (char *) "timerid",(char *) "interval", NULL
11902 };
11903
11904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11905 if (obj0) {
11906 ecode1 = SWIG_AsVal_int(obj0, &val1);
11907 if (!SWIG_IsOK(ecode1)) {
11908 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11909 }
11910 arg1 = static_cast< int >(val1);
11911 }
11912 if (obj1) {
11913 ecode2 = SWIG_AsVal_int(obj1, &val2);
11914 if (!SWIG_IsOK(ecode2)) {
11915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11916 }
11917 arg2 = static_cast< int >(val2);
11918 }
11919 {
11920 PyThreadState* __tstate = wxPyBeginAllowThreads();
11921 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11922 wxPyEndAllowThreads(__tstate);
11923 if (PyErr_Occurred()) SWIG_fail;
11924 }
11925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11926 return resultobj;
11927 fail:
11928 return NULL;
11929 }
11930
11931
11932 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11933 PyObject *resultobj = 0;
11934 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11935 int result;
11936 void *argp1 = 0 ;
11937 int res1 = 0 ;
11938 PyObject *swig_obj[1] ;
11939
11940 if (!args) SWIG_fail;
11941 swig_obj[0] = args;
11942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11943 if (!SWIG_IsOK(res1)) {
11944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11945 }
11946 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11947 {
11948 PyThreadState* __tstate = wxPyBeginAllowThreads();
11949 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11950 wxPyEndAllowThreads(__tstate);
11951 if (PyErr_Occurred()) SWIG_fail;
11952 }
11953 resultobj = SWIG_From_int(static_cast< int >(result));
11954 return resultobj;
11955 fail:
11956 return NULL;
11957 }
11958
11959
11960 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11961 PyObject *obj;
11962 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11963 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11964 return SWIG_Py_Void();
11965 }
11966
11967 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11968 return SWIG_Python_InitShadowInstance(args);
11969 }
11970
11971 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11972 PyObject *resultobj = 0;
11973 wxTimer *arg1 = 0 ;
11974 wxTimerRunner *result = 0 ;
11975 void *argp1 = 0 ;
11976 int res1 = 0 ;
11977
11978 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11980 if (!SWIG_IsOK(res1)) {
11981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11982 }
11983 if (!argp1) {
11984 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11985 }
11986 arg1 = reinterpret_cast< wxTimer * >(argp1);
11987 {
11988 if (!wxPyCheckForApp()) SWIG_fail;
11989 PyThreadState* __tstate = wxPyBeginAllowThreads();
11990 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11991 wxPyEndAllowThreads(__tstate);
11992 if (PyErr_Occurred()) SWIG_fail;
11993 }
11994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11995 return resultobj;
11996 fail:
11997 return NULL;
11998 }
11999
12000
12001 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12002 PyObject *resultobj = 0;
12003 wxTimer *arg1 = 0 ;
12004 int arg2 ;
12005 bool arg3 = (bool) false ;
12006 wxTimerRunner *result = 0 ;
12007 void *argp1 = 0 ;
12008 int res1 = 0 ;
12009 int val2 ;
12010 int ecode2 = 0 ;
12011 bool val3 ;
12012 int ecode3 = 0 ;
12013
12014 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12016 if (!SWIG_IsOK(res1)) {
12017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12018 }
12019 if (!argp1) {
12020 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12021 }
12022 arg1 = reinterpret_cast< wxTimer * >(argp1);
12023 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12024 if (!SWIG_IsOK(ecode2)) {
12025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12026 }
12027 arg2 = static_cast< int >(val2);
12028 if (swig_obj[2]) {
12029 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12030 if (!SWIG_IsOK(ecode3)) {
12031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12032 }
12033 arg3 = static_cast< bool >(val3);
12034 }
12035 {
12036 if (!wxPyCheckForApp()) SWIG_fail;
12037 PyThreadState* __tstate = wxPyBeginAllowThreads();
12038 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12039 wxPyEndAllowThreads(__tstate);
12040 if (PyErr_Occurred()) SWIG_fail;
12041 }
12042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12043 return resultobj;
12044 fail:
12045 return NULL;
12046 }
12047
12048
12049 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12050 int argc;
12051 PyObject *argv[4];
12052
12053 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12054 --argc;
12055 if (argc == 1) {
12056 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12057 }
12058 if ((argc >= 2) && (argc <= 3)) {
12059 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12060 }
12061
12062 fail:
12063 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12064 return NULL;
12065 }
12066
12067
12068 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12069 PyObject *resultobj = 0;
12070 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12071 void *argp1 = 0 ;
12072 int res1 = 0 ;
12073 PyObject *swig_obj[1] ;
12074
12075 if (!args) SWIG_fail;
12076 swig_obj[0] = args;
12077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12078 if (!SWIG_IsOK(res1)) {
12079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12080 }
12081 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12082 {
12083 PyThreadState* __tstate = wxPyBeginAllowThreads();
12084 delete arg1;
12085
12086 wxPyEndAllowThreads(__tstate);
12087 if (PyErr_Occurred()) SWIG_fail;
12088 }
12089 resultobj = SWIG_Py_Void();
12090 return resultobj;
12091 fail:
12092 return NULL;
12093 }
12094
12095
12096 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12097 PyObject *resultobj = 0;
12098 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12099 int arg2 ;
12100 bool arg3 = (bool) false ;
12101 void *argp1 = 0 ;
12102 int res1 = 0 ;
12103 int val2 ;
12104 int ecode2 = 0 ;
12105 bool val3 ;
12106 int ecode3 = 0 ;
12107 PyObject * obj0 = 0 ;
12108 PyObject * obj1 = 0 ;
12109 PyObject * obj2 = 0 ;
12110 char * kwnames[] = {
12111 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12112 };
12113
12114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12116 if (!SWIG_IsOK(res1)) {
12117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12118 }
12119 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12120 ecode2 = SWIG_AsVal_int(obj1, &val2);
12121 if (!SWIG_IsOK(ecode2)) {
12122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12123 }
12124 arg2 = static_cast< int >(val2);
12125 if (obj2) {
12126 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12127 if (!SWIG_IsOK(ecode3)) {
12128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12129 }
12130 arg3 = static_cast< bool >(val3);
12131 }
12132 {
12133 PyThreadState* __tstate = wxPyBeginAllowThreads();
12134 (arg1)->Start(arg2,arg3);
12135 wxPyEndAllowThreads(__tstate);
12136 if (PyErr_Occurred()) SWIG_fail;
12137 }
12138 resultobj = SWIG_Py_Void();
12139 return resultobj;
12140 fail:
12141 return NULL;
12142 }
12143
12144
12145 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12146 PyObject *obj;
12147 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12148 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12149 return SWIG_Py_Void();
12150 }
12151
12152 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12153 return SWIG_Python_InitShadowInstance(args);
12154 }
12155
12156 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12157 PyObject *resultobj = 0;
12158 wxLog *result = 0 ;
12159
12160 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12161 {
12162 PyThreadState* __tstate = wxPyBeginAllowThreads();
12163 result = (wxLog *)new wxLog();
12164 wxPyEndAllowThreads(__tstate);
12165 if (PyErr_Occurred()) SWIG_fail;
12166 }
12167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12168 return resultobj;
12169 fail:
12170 return NULL;
12171 }
12172
12173
12174 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12175 PyObject *resultobj = 0;
12176 wxLog *arg1 = (wxLog *) 0 ;
12177 void *argp1 = 0 ;
12178 int res1 = 0 ;
12179 PyObject *swig_obj[1] ;
12180
12181 if (!args) SWIG_fail;
12182 swig_obj[0] = args;
12183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12184 if (!SWIG_IsOK(res1)) {
12185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12186 }
12187 arg1 = reinterpret_cast< wxLog * >(argp1);
12188 {
12189 PyThreadState* __tstate = wxPyBeginAllowThreads();
12190 delete arg1;
12191
12192 wxPyEndAllowThreads(__tstate);
12193 if (PyErr_Occurred()) SWIG_fail;
12194 }
12195 resultobj = SWIG_Py_Void();
12196 return resultobj;
12197 fail:
12198 return NULL;
12199 }
12200
12201
12202 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12203 PyObject *resultobj = 0;
12204 bool result;
12205
12206 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12207 {
12208 PyThreadState* __tstate = wxPyBeginAllowThreads();
12209 result = (bool)wxLog::IsEnabled();
12210 wxPyEndAllowThreads(__tstate);
12211 if (PyErr_Occurred()) SWIG_fail;
12212 }
12213 {
12214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12215 }
12216 return resultobj;
12217 fail:
12218 return NULL;
12219 }
12220
12221
12222 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12223 PyObject *resultobj = 0;
12224 bool arg1 = (bool) true ;
12225 bool result;
12226 bool val1 ;
12227 int ecode1 = 0 ;
12228 PyObject * obj0 = 0 ;
12229 char * kwnames[] = {
12230 (char *) "doIt", NULL
12231 };
12232
12233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12234 if (obj0) {
12235 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12236 if (!SWIG_IsOK(ecode1)) {
12237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12238 }
12239 arg1 = static_cast< bool >(val1);
12240 }
12241 {
12242 PyThreadState* __tstate = wxPyBeginAllowThreads();
12243 result = (bool)wxLog::EnableLogging(arg1);
12244 wxPyEndAllowThreads(__tstate);
12245 if (PyErr_Occurred()) SWIG_fail;
12246 }
12247 {
12248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12249 }
12250 return resultobj;
12251 fail:
12252 return NULL;
12253 }
12254
12255
12256 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12257 PyObject *resultobj = 0;
12258 wxLogLevel arg1 ;
12259 wxChar *arg2 = (wxChar *) 0 ;
12260 time_t arg3 ;
12261 unsigned long val1 ;
12262 int ecode1 = 0 ;
12263 void *argp2 = 0 ;
12264 int res2 = 0 ;
12265 unsigned int val3 ;
12266 int ecode3 = 0 ;
12267 PyObject * obj0 = 0 ;
12268 PyObject * obj1 = 0 ;
12269 PyObject * obj2 = 0 ;
12270 char * kwnames[] = {
12271 (char *) "level",(char *) "szString",(char *) "t", NULL
12272 };
12273
12274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12275 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12276 if (!SWIG_IsOK(ecode1)) {
12277 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12278 }
12279 arg1 = static_cast< wxLogLevel >(val1);
12280 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12281 if (!SWIG_IsOK(res2)) {
12282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12283 }
12284 arg2 = reinterpret_cast< wxChar * >(argp2);
12285 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12286 if (!SWIG_IsOK(ecode3)) {
12287 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12288 }
12289 arg3 = static_cast< time_t >(val3);
12290 {
12291 PyThreadState* __tstate = wxPyBeginAllowThreads();
12292 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12293 wxPyEndAllowThreads(__tstate);
12294 if (PyErr_Occurred()) SWIG_fail;
12295 }
12296 resultobj = SWIG_Py_Void();
12297 return resultobj;
12298 fail:
12299 return NULL;
12300 }
12301
12302
12303 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12304 PyObject *resultobj = 0;
12305 wxLog *arg1 = (wxLog *) 0 ;
12306 void *argp1 = 0 ;
12307 int res1 = 0 ;
12308 PyObject *swig_obj[1] ;
12309
12310 if (!args) SWIG_fail;
12311 swig_obj[0] = args;
12312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12313 if (!SWIG_IsOK(res1)) {
12314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12315 }
12316 arg1 = reinterpret_cast< wxLog * >(argp1);
12317 {
12318 PyThreadState* __tstate = wxPyBeginAllowThreads();
12319 (arg1)->Flush();
12320 wxPyEndAllowThreads(__tstate);
12321 if (PyErr_Occurred()) SWIG_fail;
12322 }
12323 resultobj = SWIG_Py_Void();
12324 return resultobj;
12325 fail:
12326 return NULL;
12327 }
12328
12329
12330 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12331 PyObject *resultobj = 0;
12332
12333 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12334 {
12335 PyThreadState* __tstate = wxPyBeginAllowThreads();
12336 wxLog::FlushActive();
12337 wxPyEndAllowThreads(__tstate);
12338 if (PyErr_Occurred()) SWIG_fail;
12339 }
12340 resultobj = SWIG_Py_Void();
12341 return resultobj;
12342 fail:
12343 return NULL;
12344 }
12345
12346
12347 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12348 PyObject *resultobj = 0;
12349 wxLog *result = 0 ;
12350
12351 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12352 {
12353 PyThreadState* __tstate = wxPyBeginAllowThreads();
12354 result = (wxLog *)wxLog::GetActiveTarget();
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12359 return resultobj;
12360 fail:
12361 return NULL;
12362 }
12363
12364
12365 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12366 PyObject *resultobj = 0;
12367 wxLog *arg1 = (wxLog *) 0 ;
12368 wxLog *result = 0 ;
12369 int res1 = 0 ;
12370 PyObject * obj0 = 0 ;
12371 char * kwnames[] = {
12372 (char *) "pLogger", NULL
12373 };
12374
12375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12376 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12377 if (!SWIG_IsOK(res1)) {
12378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12379 }
12380 {
12381 PyThreadState* __tstate = wxPyBeginAllowThreads();
12382 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12383 wxPyEndAllowThreads(__tstate);
12384 if (PyErr_Occurred()) SWIG_fail;
12385 }
12386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12387 return resultobj;
12388 fail:
12389 return NULL;
12390 }
12391
12392
12393 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12394 PyObject *resultobj = 0;
12395
12396 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12397 {
12398 PyThreadState* __tstate = wxPyBeginAllowThreads();
12399 wxLog::Suspend();
12400 wxPyEndAllowThreads(__tstate);
12401 if (PyErr_Occurred()) SWIG_fail;
12402 }
12403 resultobj = SWIG_Py_Void();
12404 return resultobj;
12405 fail:
12406 return NULL;
12407 }
12408
12409
12410 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12411 PyObject *resultobj = 0;
12412
12413 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12414 {
12415 PyThreadState* __tstate = wxPyBeginAllowThreads();
12416 wxLog::Resume();
12417 wxPyEndAllowThreads(__tstate);
12418 if (PyErr_Occurred()) SWIG_fail;
12419 }
12420 resultobj = SWIG_Py_Void();
12421 return resultobj;
12422 fail:
12423 return NULL;
12424 }
12425
12426
12427 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12428 PyObject *resultobj = 0;
12429 bool arg1 = (bool) true ;
12430 bool val1 ;
12431 int ecode1 = 0 ;
12432 PyObject * obj0 = 0 ;
12433 char * kwnames[] = {
12434 (char *) "bVerbose", NULL
12435 };
12436
12437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12438 if (obj0) {
12439 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12440 if (!SWIG_IsOK(ecode1)) {
12441 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12442 }
12443 arg1 = static_cast< bool >(val1);
12444 }
12445 {
12446 PyThreadState* __tstate = wxPyBeginAllowThreads();
12447 wxLog::SetVerbose(arg1);
12448 wxPyEndAllowThreads(__tstate);
12449 if (PyErr_Occurred()) SWIG_fail;
12450 }
12451 resultobj = SWIG_Py_Void();
12452 return resultobj;
12453 fail:
12454 return NULL;
12455 }
12456
12457
12458 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12459 PyObject *resultobj = 0;
12460 wxLogLevel arg1 ;
12461 unsigned long val1 ;
12462 int ecode1 = 0 ;
12463 PyObject * obj0 = 0 ;
12464 char * kwnames[] = {
12465 (char *) "logLevel", NULL
12466 };
12467
12468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12469 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12470 if (!SWIG_IsOK(ecode1)) {
12471 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12472 }
12473 arg1 = static_cast< wxLogLevel >(val1);
12474 {
12475 PyThreadState* __tstate = wxPyBeginAllowThreads();
12476 wxLog::SetLogLevel(arg1);
12477 wxPyEndAllowThreads(__tstate);
12478 if (PyErr_Occurred()) SWIG_fail;
12479 }
12480 resultobj = SWIG_Py_Void();
12481 return resultobj;
12482 fail:
12483 return NULL;
12484 }
12485
12486
12487 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12488 PyObject *resultobj = 0;
12489
12490 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12491 {
12492 PyThreadState* __tstate = wxPyBeginAllowThreads();
12493 wxLog::DontCreateOnDemand();
12494 wxPyEndAllowThreads(__tstate);
12495 if (PyErr_Occurred()) SWIG_fail;
12496 }
12497 resultobj = SWIG_Py_Void();
12498 return resultobj;
12499 fail:
12500 return NULL;
12501 }
12502
12503
12504 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12505 PyObject *resultobj = 0;
12506 bool arg1 = (bool) true ;
12507 bool val1 ;
12508 int ecode1 = 0 ;
12509 PyObject * obj0 = 0 ;
12510 char * kwnames[] = {
12511 (char *) "bRepetCounting", NULL
12512 };
12513
12514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12515 if (obj0) {
12516 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12517 if (!SWIG_IsOK(ecode1)) {
12518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12519 }
12520 arg1 = static_cast< bool >(val1);
12521 }
12522 {
12523 PyThreadState* __tstate = wxPyBeginAllowThreads();
12524 wxLog::SetRepetitionCounting(arg1);
12525 wxPyEndAllowThreads(__tstate);
12526 if (PyErr_Occurred()) SWIG_fail;
12527 }
12528 resultobj = SWIG_Py_Void();
12529 return resultobj;
12530 fail:
12531 return NULL;
12532 }
12533
12534
12535 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12536 PyObject *resultobj = 0;
12537 bool result;
12538
12539 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12540 {
12541 PyThreadState* __tstate = wxPyBeginAllowThreads();
12542 result = (bool)wxLog::GetRepetitionCounting();
12543 wxPyEndAllowThreads(__tstate);
12544 if (PyErr_Occurred()) SWIG_fail;
12545 }
12546 {
12547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12548 }
12549 return resultobj;
12550 fail:
12551 return NULL;
12552 }
12553
12554
12555 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12556 PyObject *resultobj = 0;
12557 wxTraceMask arg1 ;
12558 unsigned long val1 ;
12559 int ecode1 = 0 ;
12560 PyObject * obj0 = 0 ;
12561 char * kwnames[] = {
12562 (char *) "ulMask", NULL
12563 };
12564
12565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12566 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12567 if (!SWIG_IsOK(ecode1)) {
12568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12569 }
12570 arg1 = static_cast< wxTraceMask >(val1);
12571 {
12572 PyThreadState* __tstate = wxPyBeginAllowThreads();
12573 wxLog::SetTraceMask(arg1);
12574 wxPyEndAllowThreads(__tstate);
12575 if (PyErr_Occurred()) SWIG_fail;
12576 }
12577 resultobj = SWIG_Py_Void();
12578 return resultobj;
12579 fail:
12580 return NULL;
12581 }
12582
12583
12584 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12585 PyObject *resultobj = 0;
12586 wxString *arg1 = 0 ;
12587 bool temp1 = false ;
12588 PyObject * obj0 = 0 ;
12589 char * kwnames[] = {
12590 (char *) "str", NULL
12591 };
12592
12593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12594 {
12595 arg1 = wxString_in_helper(obj0);
12596 if (arg1 == NULL) SWIG_fail;
12597 temp1 = true;
12598 }
12599 {
12600 PyThreadState* __tstate = wxPyBeginAllowThreads();
12601 wxLog::AddTraceMask((wxString const &)*arg1);
12602 wxPyEndAllowThreads(__tstate);
12603 if (PyErr_Occurred()) SWIG_fail;
12604 }
12605 resultobj = SWIG_Py_Void();
12606 {
12607 if (temp1)
12608 delete arg1;
12609 }
12610 return resultobj;
12611 fail:
12612 {
12613 if (temp1)
12614 delete arg1;
12615 }
12616 return NULL;
12617 }
12618
12619
12620 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12621 PyObject *resultobj = 0;
12622 wxString *arg1 = 0 ;
12623 bool temp1 = false ;
12624 PyObject * obj0 = 0 ;
12625 char * kwnames[] = {
12626 (char *) "str", NULL
12627 };
12628
12629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12630 {
12631 arg1 = wxString_in_helper(obj0);
12632 if (arg1 == NULL) SWIG_fail;
12633 temp1 = true;
12634 }
12635 {
12636 PyThreadState* __tstate = wxPyBeginAllowThreads();
12637 wxLog::RemoveTraceMask((wxString const &)*arg1);
12638 wxPyEndAllowThreads(__tstate);
12639 if (PyErr_Occurred()) SWIG_fail;
12640 }
12641 resultobj = SWIG_Py_Void();
12642 {
12643 if (temp1)
12644 delete arg1;
12645 }
12646 return resultobj;
12647 fail:
12648 {
12649 if (temp1)
12650 delete arg1;
12651 }
12652 return NULL;
12653 }
12654
12655
12656 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12657 PyObject *resultobj = 0;
12658
12659 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12660 {
12661 PyThreadState* __tstate = wxPyBeginAllowThreads();
12662 wxLog::ClearTraceMasks();
12663 wxPyEndAllowThreads(__tstate);
12664 if (PyErr_Occurred()) SWIG_fail;
12665 }
12666 resultobj = SWIG_Py_Void();
12667 return resultobj;
12668 fail:
12669 return NULL;
12670 }
12671
12672
12673 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12674 PyObject *resultobj = 0;
12675 wxArrayString *result = 0 ;
12676
12677 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12678 {
12679 PyThreadState* __tstate = wxPyBeginAllowThreads();
12680 {
12681 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12682 result = (wxArrayString *) &_result_ref;
12683 }
12684 wxPyEndAllowThreads(__tstate);
12685 if (PyErr_Occurred()) SWIG_fail;
12686 }
12687 {
12688 resultobj = wxArrayString2PyList_helper(*result);
12689 }
12690 return resultobj;
12691 fail:
12692 return NULL;
12693 }
12694
12695
12696 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12697 PyObject *resultobj = 0;
12698 wxChar *arg1 = (wxChar *) 0 ;
12699 void *argp1 = 0 ;
12700 int res1 = 0 ;
12701 PyObject * obj0 = 0 ;
12702 char * kwnames[] = {
12703 (char *) "ts", NULL
12704 };
12705
12706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12708 if (!SWIG_IsOK(res1)) {
12709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12710 }
12711 arg1 = reinterpret_cast< wxChar * >(argp1);
12712 {
12713 PyThreadState* __tstate = wxPyBeginAllowThreads();
12714 wxLog::SetTimestamp((wxChar const *)arg1);
12715 wxPyEndAllowThreads(__tstate);
12716 if (PyErr_Occurred()) SWIG_fail;
12717 }
12718 resultobj = SWIG_Py_Void();
12719 return resultobj;
12720 fail:
12721 return NULL;
12722 }
12723
12724
12725 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12726 PyObject *resultobj = 0;
12727 bool result;
12728
12729 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12730 {
12731 PyThreadState* __tstate = wxPyBeginAllowThreads();
12732 result = (bool)wxLog::GetVerbose();
12733 wxPyEndAllowThreads(__tstate);
12734 if (PyErr_Occurred()) SWIG_fail;
12735 }
12736 {
12737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12738 }
12739 return resultobj;
12740 fail:
12741 return NULL;
12742 }
12743
12744
12745 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12746 PyObject *resultobj = 0;
12747 wxTraceMask result;
12748
12749 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12750 {
12751 PyThreadState* __tstate = wxPyBeginAllowThreads();
12752 result = (wxTraceMask)wxLog::GetTraceMask();
12753 wxPyEndAllowThreads(__tstate);
12754 if (PyErr_Occurred()) SWIG_fail;
12755 }
12756 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12757 return resultobj;
12758 fail:
12759 return NULL;
12760 }
12761
12762
12763 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12764 PyObject *resultobj = 0;
12765 wxChar *arg1 = (wxChar *) 0 ;
12766 bool result;
12767 void *argp1 = 0 ;
12768 int res1 = 0 ;
12769 PyObject * obj0 = 0 ;
12770 char * kwnames[] = {
12771 (char *) "mask", NULL
12772 };
12773
12774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12776 if (!SWIG_IsOK(res1)) {
12777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12778 }
12779 arg1 = reinterpret_cast< wxChar * >(argp1);
12780 {
12781 PyThreadState* __tstate = wxPyBeginAllowThreads();
12782 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12783 wxPyEndAllowThreads(__tstate);
12784 if (PyErr_Occurred()) SWIG_fail;
12785 }
12786 {
12787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12788 }
12789 return resultobj;
12790 fail:
12791 return NULL;
12792 }
12793
12794
12795 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12796 PyObject *resultobj = 0;
12797 wxLogLevel result;
12798
12799 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12800 {
12801 PyThreadState* __tstate = wxPyBeginAllowThreads();
12802 result = (wxLogLevel)wxLog::GetLogLevel();
12803 wxPyEndAllowThreads(__tstate);
12804 if (PyErr_Occurred()) SWIG_fail;
12805 }
12806 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12807 return resultobj;
12808 fail:
12809 return NULL;
12810 }
12811
12812
12813 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12814 PyObject *resultobj = 0;
12815 wxChar *result = 0 ;
12816
12817 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12818 {
12819 PyThreadState* __tstate = wxPyBeginAllowThreads();
12820 result = (wxChar *)wxLog::GetTimestamp();
12821 wxPyEndAllowThreads(__tstate);
12822 if (PyErr_Occurred()) SWIG_fail;
12823 }
12824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12825 return resultobj;
12826 fail:
12827 return NULL;
12828 }
12829
12830
12831 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12832 PyObject *resultobj = 0;
12833 wxString result;
12834
12835 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12836 {
12837 PyThreadState* __tstate = wxPyBeginAllowThreads();
12838 result = wxLog_TimeStamp();
12839 wxPyEndAllowThreads(__tstate);
12840 if (PyErr_Occurred()) SWIG_fail;
12841 }
12842 {
12843 #if wxUSE_UNICODE
12844 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12845 #else
12846 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12847 #endif
12848 }
12849 return resultobj;
12850 fail:
12851 return NULL;
12852 }
12853
12854
12855 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12856 PyObject *resultobj = 0;
12857 wxLog *arg1 = (wxLog *) 0 ;
12858 void *argp1 = 0 ;
12859 int res1 = 0 ;
12860 PyObject *swig_obj[1] ;
12861
12862 if (!args) SWIG_fail;
12863 swig_obj[0] = args;
12864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12865 if (!SWIG_IsOK(res1)) {
12866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12867 }
12868 arg1 = reinterpret_cast< wxLog * >(argp1);
12869 {
12870 PyThreadState* __tstate = wxPyBeginAllowThreads();
12871 wxLog_Destroy(arg1);
12872 wxPyEndAllowThreads(__tstate);
12873 if (PyErr_Occurred()) SWIG_fail;
12874 }
12875 resultobj = SWIG_Py_Void();
12876 return resultobj;
12877 fail:
12878 return NULL;
12879 }
12880
12881
12882 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12883 PyObject *obj;
12884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12885 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12886 return SWIG_Py_Void();
12887 }
12888
12889 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12890 return SWIG_Python_InitShadowInstance(args);
12891 }
12892
12893 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12894 PyObject *resultobj = 0;
12895 wxLogStderr *result = 0 ;
12896
12897 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12898 {
12899 PyThreadState* __tstate = wxPyBeginAllowThreads();
12900 result = (wxLogStderr *)new wxLogStderr();
12901 wxPyEndAllowThreads(__tstate);
12902 if (PyErr_Occurred()) SWIG_fail;
12903 }
12904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12905 return resultobj;
12906 fail:
12907 return NULL;
12908 }
12909
12910
12911 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12912 PyObject *obj;
12913 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12914 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12915 return SWIG_Py_Void();
12916 }
12917
12918 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12919 return SWIG_Python_InitShadowInstance(args);
12920 }
12921
12922 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12923 PyObject *resultobj = 0;
12924 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12925 wxLogTextCtrl *result = 0 ;
12926 void *argp1 = 0 ;
12927 int res1 = 0 ;
12928 PyObject * obj0 = 0 ;
12929 char * kwnames[] = {
12930 (char *) "pTextCtrl", NULL
12931 };
12932
12933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12935 if (!SWIG_IsOK(res1)) {
12936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12937 }
12938 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12939 {
12940 PyThreadState* __tstate = wxPyBeginAllowThreads();
12941 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12942 wxPyEndAllowThreads(__tstate);
12943 if (PyErr_Occurred()) SWIG_fail;
12944 }
12945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12946 return resultobj;
12947 fail:
12948 return NULL;
12949 }
12950
12951
12952 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12953 PyObject *obj;
12954 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12955 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12956 return SWIG_Py_Void();
12957 }
12958
12959 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12960 return SWIG_Python_InitShadowInstance(args);
12961 }
12962
12963 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12964 PyObject *resultobj = 0;
12965 wxLogGui *result = 0 ;
12966
12967 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12968 {
12969 PyThreadState* __tstate = wxPyBeginAllowThreads();
12970 result = (wxLogGui *)new wxLogGui();
12971 wxPyEndAllowThreads(__tstate);
12972 if (PyErr_Occurred()) SWIG_fail;
12973 }
12974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12975 return resultobj;
12976 fail:
12977 return NULL;
12978 }
12979
12980
12981 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12982 PyObject *obj;
12983 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12984 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12985 return SWIG_Py_Void();
12986 }
12987
12988 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12989 return SWIG_Python_InitShadowInstance(args);
12990 }
12991
12992 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12993 PyObject *resultobj = 0;
12994 wxFrame *arg1 = (wxFrame *) 0 ;
12995 wxString *arg2 = 0 ;
12996 bool arg3 = (bool) true ;
12997 bool arg4 = (bool) true ;
12998 wxLogWindow *result = 0 ;
12999 void *argp1 = 0 ;
13000 int res1 = 0 ;
13001 bool temp2 = false ;
13002 bool val3 ;
13003 int ecode3 = 0 ;
13004 bool val4 ;
13005 int ecode4 = 0 ;
13006 PyObject * obj0 = 0 ;
13007 PyObject * obj1 = 0 ;
13008 PyObject * obj2 = 0 ;
13009 PyObject * obj3 = 0 ;
13010 char * kwnames[] = {
13011 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13012 };
13013
13014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13016 if (!SWIG_IsOK(res1)) {
13017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13018 }
13019 arg1 = reinterpret_cast< wxFrame * >(argp1);
13020 {
13021 arg2 = wxString_in_helper(obj1);
13022 if (arg2 == NULL) SWIG_fail;
13023 temp2 = true;
13024 }
13025 if (obj2) {
13026 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13027 if (!SWIG_IsOK(ecode3)) {
13028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13029 }
13030 arg3 = static_cast< bool >(val3);
13031 }
13032 if (obj3) {
13033 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13034 if (!SWIG_IsOK(ecode4)) {
13035 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13036 }
13037 arg4 = static_cast< bool >(val4);
13038 }
13039 {
13040 PyThreadState* __tstate = wxPyBeginAllowThreads();
13041 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13042 wxPyEndAllowThreads(__tstate);
13043 if (PyErr_Occurred()) SWIG_fail;
13044 }
13045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13046 {
13047 if (temp2)
13048 delete arg2;
13049 }
13050 return resultobj;
13051 fail:
13052 {
13053 if (temp2)
13054 delete arg2;
13055 }
13056 return NULL;
13057 }
13058
13059
13060 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13061 PyObject *resultobj = 0;
13062 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13063 bool arg2 = (bool) true ;
13064 void *argp1 = 0 ;
13065 int res1 = 0 ;
13066 bool val2 ;
13067 int ecode2 = 0 ;
13068 PyObject * obj0 = 0 ;
13069 PyObject * obj1 = 0 ;
13070 char * kwnames[] = {
13071 (char *) "self",(char *) "bShow", NULL
13072 };
13073
13074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13076 if (!SWIG_IsOK(res1)) {
13077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13078 }
13079 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13080 if (obj1) {
13081 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13082 if (!SWIG_IsOK(ecode2)) {
13083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13084 }
13085 arg2 = static_cast< bool >(val2);
13086 }
13087 {
13088 PyThreadState* __tstate = wxPyBeginAllowThreads();
13089 (arg1)->Show(arg2);
13090 wxPyEndAllowThreads(__tstate);
13091 if (PyErr_Occurred()) SWIG_fail;
13092 }
13093 resultobj = SWIG_Py_Void();
13094 return resultobj;
13095 fail:
13096 return NULL;
13097 }
13098
13099
13100 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13101 PyObject *resultobj = 0;
13102 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13103 wxFrame *result = 0 ;
13104 void *argp1 = 0 ;
13105 int res1 = 0 ;
13106 PyObject *swig_obj[1] ;
13107
13108 if (!args) SWIG_fail;
13109 swig_obj[0] = args;
13110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13111 if (!SWIG_IsOK(res1)) {
13112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13113 }
13114 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13115 {
13116 PyThreadState* __tstate = wxPyBeginAllowThreads();
13117 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13118 wxPyEndAllowThreads(__tstate);
13119 if (PyErr_Occurred()) SWIG_fail;
13120 }
13121 {
13122 resultobj = wxPyMake_wxObject(result, (bool)0);
13123 }
13124 return resultobj;
13125 fail:
13126 return NULL;
13127 }
13128
13129
13130 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13131 PyObject *resultobj = 0;
13132 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13133 wxLog *result = 0 ;
13134 void *argp1 = 0 ;
13135 int res1 = 0 ;
13136 PyObject *swig_obj[1] ;
13137
13138 if (!args) SWIG_fail;
13139 swig_obj[0] = args;
13140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13141 if (!SWIG_IsOK(res1)) {
13142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13143 }
13144 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13145 {
13146 PyThreadState* __tstate = wxPyBeginAllowThreads();
13147 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13148 wxPyEndAllowThreads(__tstate);
13149 if (PyErr_Occurred()) SWIG_fail;
13150 }
13151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13152 return resultobj;
13153 fail:
13154 return NULL;
13155 }
13156
13157
13158 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13159 PyObject *resultobj = 0;
13160 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13161 bool result;
13162 void *argp1 = 0 ;
13163 int res1 = 0 ;
13164 PyObject *swig_obj[1] ;
13165
13166 if (!args) SWIG_fail;
13167 swig_obj[0] = args;
13168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13169 if (!SWIG_IsOK(res1)) {
13170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13171 }
13172 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13173 {
13174 PyThreadState* __tstate = wxPyBeginAllowThreads();
13175 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13176 wxPyEndAllowThreads(__tstate);
13177 if (PyErr_Occurred()) SWIG_fail;
13178 }
13179 {
13180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13181 }
13182 return resultobj;
13183 fail:
13184 return NULL;
13185 }
13186
13187
13188 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13189 PyObject *resultobj = 0;
13190 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13191 bool arg2 ;
13192 void *argp1 = 0 ;
13193 int res1 = 0 ;
13194 bool val2 ;
13195 int ecode2 = 0 ;
13196 PyObject * obj0 = 0 ;
13197 PyObject * obj1 = 0 ;
13198 char * kwnames[] = {
13199 (char *) "self",(char *) "bDoPass", NULL
13200 };
13201
13202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13204 if (!SWIG_IsOK(res1)) {
13205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13206 }
13207 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13208 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13209 if (!SWIG_IsOK(ecode2)) {
13210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13211 }
13212 arg2 = static_cast< bool >(val2);
13213 {
13214 PyThreadState* __tstate = wxPyBeginAllowThreads();
13215 (arg1)->PassMessages(arg2);
13216 wxPyEndAllowThreads(__tstate);
13217 if (PyErr_Occurred()) SWIG_fail;
13218 }
13219 resultobj = SWIG_Py_Void();
13220 return resultobj;
13221 fail:
13222 return NULL;
13223 }
13224
13225
13226 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13227 PyObject *obj;
13228 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13229 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13230 return SWIG_Py_Void();
13231 }
13232
13233 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13234 return SWIG_Python_InitShadowInstance(args);
13235 }
13236
13237 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13238 PyObject *resultobj = 0;
13239 wxLog *arg1 = (wxLog *) 0 ;
13240 wxLogChain *result = 0 ;
13241 void *argp1 = 0 ;
13242 int res1 = 0 ;
13243 PyObject * obj0 = 0 ;
13244 char * kwnames[] = {
13245 (char *) "logger", NULL
13246 };
13247
13248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13250 if (!SWIG_IsOK(res1)) {
13251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13252 }
13253 arg1 = reinterpret_cast< wxLog * >(argp1);
13254 {
13255 PyThreadState* __tstate = wxPyBeginAllowThreads();
13256 result = (wxLogChain *)new wxLogChain(arg1);
13257 wxPyEndAllowThreads(__tstate);
13258 if (PyErr_Occurred()) SWIG_fail;
13259 }
13260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13261 return resultobj;
13262 fail:
13263 return NULL;
13264 }
13265
13266
13267 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13268 PyObject *resultobj = 0;
13269 wxLogChain *arg1 = (wxLogChain *) 0 ;
13270 wxLog *arg2 = (wxLog *) 0 ;
13271 void *argp1 = 0 ;
13272 int res1 = 0 ;
13273 void *argp2 = 0 ;
13274 int res2 = 0 ;
13275 PyObject * obj0 = 0 ;
13276 PyObject * obj1 = 0 ;
13277 char * kwnames[] = {
13278 (char *) "self",(char *) "logger", NULL
13279 };
13280
13281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13283 if (!SWIG_IsOK(res1)) {
13284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13285 }
13286 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13287 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13288 if (!SWIG_IsOK(res2)) {
13289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13290 }
13291 arg2 = reinterpret_cast< wxLog * >(argp2);
13292 {
13293 PyThreadState* __tstate = wxPyBeginAllowThreads();
13294 (arg1)->SetLog(arg2);
13295 wxPyEndAllowThreads(__tstate);
13296 if (PyErr_Occurred()) SWIG_fail;
13297 }
13298 resultobj = SWIG_Py_Void();
13299 return resultobj;
13300 fail:
13301 return NULL;
13302 }
13303
13304
13305 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13306 PyObject *resultobj = 0;
13307 wxLogChain *arg1 = (wxLogChain *) 0 ;
13308 bool arg2 ;
13309 void *argp1 = 0 ;
13310 int res1 = 0 ;
13311 bool val2 ;
13312 int ecode2 = 0 ;
13313 PyObject * obj0 = 0 ;
13314 PyObject * obj1 = 0 ;
13315 char * kwnames[] = {
13316 (char *) "self",(char *) "bDoPass", NULL
13317 };
13318
13319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13321 if (!SWIG_IsOK(res1)) {
13322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13323 }
13324 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13325 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13326 if (!SWIG_IsOK(ecode2)) {
13327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13328 }
13329 arg2 = static_cast< bool >(val2);
13330 {
13331 PyThreadState* __tstate = wxPyBeginAllowThreads();
13332 (arg1)->PassMessages(arg2);
13333 wxPyEndAllowThreads(__tstate);
13334 if (PyErr_Occurred()) SWIG_fail;
13335 }
13336 resultobj = SWIG_Py_Void();
13337 return resultobj;
13338 fail:
13339 return NULL;
13340 }
13341
13342
13343 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13344 PyObject *resultobj = 0;
13345 wxLogChain *arg1 = (wxLogChain *) 0 ;
13346 bool result;
13347 void *argp1 = 0 ;
13348 int res1 = 0 ;
13349 PyObject *swig_obj[1] ;
13350
13351 if (!args) SWIG_fail;
13352 swig_obj[0] = args;
13353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13354 if (!SWIG_IsOK(res1)) {
13355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13356 }
13357 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13358 {
13359 PyThreadState* __tstate = wxPyBeginAllowThreads();
13360 result = (bool)(arg1)->IsPassingMessages();
13361 wxPyEndAllowThreads(__tstate);
13362 if (PyErr_Occurred()) SWIG_fail;
13363 }
13364 {
13365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13366 }
13367 return resultobj;
13368 fail:
13369 return NULL;
13370 }
13371
13372
13373 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13374 PyObject *resultobj = 0;
13375 wxLogChain *arg1 = (wxLogChain *) 0 ;
13376 wxLog *result = 0 ;
13377 void *argp1 = 0 ;
13378 int res1 = 0 ;
13379 PyObject *swig_obj[1] ;
13380
13381 if (!args) SWIG_fail;
13382 swig_obj[0] = args;
13383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13384 if (!SWIG_IsOK(res1)) {
13385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13386 }
13387 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13388 {
13389 PyThreadState* __tstate = wxPyBeginAllowThreads();
13390 result = (wxLog *)(arg1)->GetOldLog();
13391 wxPyEndAllowThreads(__tstate);
13392 if (PyErr_Occurred()) SWIG_fail;
13393 }
13394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13395 return resultobj;
13396 fail:
13397 return NULL;
13398 }
13399
13400
13401 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13402 PyObject *obj;
13403 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13404 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13405 return SWIG_Py_Void();
13406 }
13407
13408 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13409 return SWIG_Python_InitShadowInstance(args);
13410 }
13411
13412 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13413 PyObject *resultobj = 0;
13414 wxLogBuffer *result = 0 ;
13415
13416 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13417 {
13418 PyThreadState* __tstate = wxPyBeginAllowThreads();
13419 result = (wxLogBuffer *)new wxLogBuffer();
13420 wxPyEndAllowThreads(__tstate);
13421 if (PyErr_Occurred()) SWIG_fail;
13422 }
13423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13424 return resultobj;
13425 fail:
13426 return NULL;
13427 }
13428
13429
13430 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13431 PyObject *resultobj = 0;
13432 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13433 wxString *result = 0 ;
13434 void *argp1 = 0 ;
13435 int res1 = 0 ;
13436 PyObject *swig_obj[1] ;
13437
13438 if (!args) SWIG_fail;
13439 swig_obj[0] = args;
13440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13441 if (!SWIG_IsOK(res1)) {
13442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13443 }
13444 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13445 {
13446 PyThreadState* __tstate = wxPyBeginAllowThreads();
13447 {
13448 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13449 result = (wxString *) &_result_ref;
13450 }
13451 wxPyEndAllowThreads(__tstate);
13452 if (PyErr_Occurred()) SWIG_fail;
13453 }
13454 {
13455 #if wxUSE_UNICODE
13456 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13457 #else
13458 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13459 #endif
13460 }
13461 return resultobj;
13462 fail:
13463 return NULL;
13464 }
13465
13466
13467 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13468 PyObject *obj;
13469 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13470 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13471 return SWIG_Py_Void();
13472 }
13473
13474 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13475 return SWIG_Python_InitShadowInstance(args);
13476 }
13477
13478 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13479 PyObject *resultobj = 0;
13480 unsigned long result;
13481
13482 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13483 {
13484 PyThreadState* __tstate = wxPyBeginAllowThreads();
13485 result = (unsigned long)wxSysErrorCode();
13486 wxPyEndAllowThreads(__tstate);
13487 if (PyErr_Occurred()) SWIG_fail;
13488 }
13489 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13490 return resultobj;
13491 fail:
13492 return NULL;
13493 }
13494
13495
13496 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13497 PyObject *resultobj = 0;
13498 unsigned long arg1 = (unsigned long) 0 ;
13499 wxString result;
13500 unsigned long val1 ;
13501 int ecode1 = 0 ;
13502 PyObject * obj0 = 0 ;
13503 char * kwnames[] = {
13504 (char *) "nErrCode", NULL
13505 };
13506
13507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13508 if (obj0) {
13509 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13510 if (!SWIG_IsOK(ecode1)) {
13511 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13512 }
13513 arg1 = static_cast< unsigned long >(val1);
13514 }
13515 {
13516 PyThreadState* __tstate = wxPyBeginAllowThreads();
13517 result = wxSysErrorMsg(arg1);
13518 wxPyEndAllowThreads(__tstate);
13519 if (PyErr_Occurred()) SWIG_fail;
13520 }
13521 {
13522 #if wxUSE_UNICODE
13523 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13524 #else
13525 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13526 #endif
13527 }
13528 return resultobj;
13529 fail:
13530 return NULL;
13531 }
13532
13533
13534 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13535 PyObject *resultobj = 0;
13536 wxString *arg1 = 0 ;
13537 bool temp1 = false ;
13538 PyObject * obj0 = 0 ;
13539 char * kwnames[] = {
13540 (char *) "msg", NULL
13541 };
13542
13543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13544 {
13545 arg1 = wxString_in_helper(obj0);
13546 if (arg1 == NULL) SWIG_fail;
13547 temp1 = true;
13548 }
13549 {
13550 PyThreadState* __tstate = wxPyBeginAllowThreads();
13551 wxPyLogFatalError((wxString const &)*arg1);
13552 wxPyEndAllowThreads(__tstate);
13553 if (PyErr_Occurred()) SWIG_fail;
13554 }
13555 resultobj = SWIG_Py_Void();
13556 {
13557 if (temp1)
13558 delete arg1;
13559 }
13560 return resultobj;
13561 fail:
13562 {
13563 if (temp1)
13564 delete arg1;
13565 }
13566 return NULL;
13567 }
13568
13569
13570 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13571 PyObject *resultobj = 0;
13572 wxString *arg1 = 0 ;
13573 bool temp1 = false ;
13574 PyObject * obj0 = 0 ;
13575 char * kwnames[] = {
13576 (char *) "msg", NULL
13577 };
13578
13579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13580 {
13581 arg1 = wxString_in_helper(obj0);
13582 if (arg1 == NULL) SWIG_fail;
13583 temp1 = true;
13584 }
13585 {
13586 PyThreadState* __tstate = wxPyBeginAllowThreads();
13587 wxPyLogError((wxString const &)*arg1);
13588 wxPyEndAllowThreads(__tstate);
13589 if (PyErr_Occurred()) SWIG_fail;
13590 }
13591 resultobj = SWIG_Py_Void();
13592 {
13593 if (temp1)
13594 delete arg1;
13595 }
13596 return resultobj;
13597 fail:
13598 {
13599 if (temp1)
13600 delete arg1;
13601 }
13602 return NULL;
13603 }
13604
13605
13606 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13607 PyObject *resultobj = 0;
13608 wxString *arg1 = 0 ;
13609 bool temp1 = false ;
13610 PyObject * obj0 = 0 ;
13611 char * kwnames[] = {
13612 (char *) "msg", NULL
13613 };
13614
13615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13616 {
13617 arg1 = wxString_in_helper(obj0);
13618 if (arg1 == NULL) SWIG_fail;
13619 temp1 = true;
13620 }
13621 {
13622 PyThreadState* __tstate = wxPyBeginAllowThreads();
13623 wxPyLogWarning((wxString const &)*arg1);
13624 wxPyEndAllowThreads(__tstate);
13625 if (PyErr_Occurred()) SWIG_fail;
13626 }
13627 resultobj = SWIG_Py_Void();
13628 {
13629 if (temp1)
13630 delete arg1;
13631 }
13632 return resultobj;
13633 fail:
13634 {
13635 if (temp1)
13636 delete arg1;
13637 }
13638 return NULL;
13639 }
13640
13641
13642 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13643 PyObject *resultobj = 0;
13644 wxString *arg1 = 0 ;
13645 bool temp1 = false ;
13646 PyObject * obj0 = 0 ;
13647 char * kwnames[] = {
13648 (char *) "msg", NULL
13649 };
13650
13651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13652 {
13653 arg1 = wxString_in_helper(obj0);
13654 if (arg1 == NULL) SWIG_fail;
13655 temp1 = true;
13656 }
13657 {
13658 PyThreadState* __tstate = wxPyBeginAllowThreads();
13659 wxPyLogMessage((wxString const &)*arg1);
13660 wxPyEndAllowThreads(__tstate);
13661 if (PyErr_Occurred()) SWIG_fail;
13662 }
13663 resultobj = SWIG_Py_Void();
13664 {
13665 if (temp1)
13666 delete arg1;
13667 }
13668 return resultobj;
13669 fail:
13670 {
13671 if (temp1)
13672 delete arg1;
13673 }
13674 return NULL;
13675 }
13676
13677
13678 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13679 PyObject *resultobj = 0;
13680 wxString *arg1 = 0 ;
13681 bool temp1 = false ;
13682 PyObject * obj0 = 0 ;
13683 char * kwnames[] = {
13684 (char *) "msg", NULL
13685 };
13686
13687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13688 {
13689 arg1 = wxString_in_helper(obj0);
13690 if (arg1 == NULL) SWIG_fail;
13691 temp1 = true;
13692 }
13693 {
13694 PyThreadState* __tstate = wxPyBeginAllowThreads();
13695 wxPyLogInfo((wxString const &)*arg1);
13696 wxPyEndAllowThreads(__tstate);
13697 if (PyErr_Occurred()) SWIG_fail;
13698 }
13699 resultobj = SWIG_Py_Void();
13700 {
13701 if (temp1)
13702 delete arg1;
13703 }
13704 return resultobj;
13705 fail:
13706 {
13707 if (temp1)
13708 delete arg1;
13709 }
13710 return NULL;
13711 }
13712
13713
13714 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13715 PyObject *resultobj = 0;
13716 wxString *arg1 = 0 ;
13717 bool temp1 = false ;
13718 PyObject * obj0 = 0 ;
13719 char * kwnames[] = {
13720 (char *) "msg", NULL
13721 };
13722
13723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13724 {
13725 arg1 = wxString_in_helper(obj0);
13726 if (arg1 == NULL) SWIG_fail;
13727 temp1 = true;
13728 }
13729 {
13730 PyThreadState* __tstate = wxPyBeginAllowThreads();
13731 wxPyLogDebug((wxString const &)*arg1);
13732 wxPyEndAllowThreads(__tstate);
13733 if (PyErr_Occurred()) SWIG_fail;
13734 }
13735 resultobj = SWIG_Py_Void();
13736 {
13737 if (temp1)
13738 delete arg1;
13739 }
13740 return resultobj;
13741 fail:
13742 {
13743 if (temp1)
13744 delete arg1;
13745 }
13746 return NULL;
13747 }
13748
13749
13750 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13751 PyObject *resultobj = 0;
13752 wxString *arg1 = 0 ;
13753 bool temp1 = false ;
13754 PyObject * obj0 = 0 ;
13755 char * kwnames[] = {
13756 (char *) "msg", NULL
13757 };
13758
13759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13760 {
13761 arg1 = wxString_in_helper(obj0);
13762 if (arg1 == NULL) SWIG_fail;
13763 temp1 = true;
13764 }
13765 {
13766 PyThreadState* __tstate = wxPyBeginAllowThreads();
13767 wxPyLogVerbose((wxString const &)*arg1);
13768 wxPyEndAllowThreads(__tstate);
13769 if (PyErr_Occurred()) SWIG_fail;
13770 }
13771 resultobj = SWIG_Py_Void();
13772 {
13773 if (temp1)
13774 delete arg1;
13775 }
13776 return resultobj;
13777 fail:
13778 {
13779 if (temp1)
13780 delete arg1;
13781 }
13782 return NULL;
13783 }
13784
13785
13786 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13787 PyObject *resultobj = 0;
13788 wxString *arg1 = 0 ;
13789 bool temp1 = false ;
13790 PyObject * obj0 = 0 ;
13791 char * kwnames[] = {
13792 (char *) "msg", NULL
13793 };
13794
13795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13796 {
13797 arg1 = wxString_in_helper(obj0);
13798 if (arg1 == NULL) SWIG_fail;
13799 temp1 = true;
13800 }
13801 {
13802 PyThreadState* __tstate = wxPyBeginAllowThreads();
13803 wxPyLogStatus((wxString const &)*arg1);
13804 wxPyEndAllowThreads(__tstate);
13805 if (PyErr_Occurred()) SWIG_fail;
13806 }
13807 resultobj = SWIG_Py_Void();
13808 {
13809 if (temp1)
13810 delete arg1;
13811 }
13812 return resultobj;
13813 fail:
13814 {
13815 if (temp1)
13816 delete arg1;
13817 }
13818 return NULL;
13819 }
13820
13821
13822 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13823 PyObject *resultobj = 0;
13824 wxFrame *arg1 = (wxFrame *) 0 ;
13825 wxString *arg2 = 0 ;
13826 void *argp1 = 0 ;
13827 int res1 = 0 ;
13828 bool temp2 = false ;
13829 PyObject * obj0 = 0 ;
13830 PyObject * obj1 = 0 ;
13831 char * kwnames[] = {
13832 (char *) "pFrame",(char *) "msg", NULL
13833 };
13834
13835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13837 if (!SWIG_IsOK(res1)) {
13838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13839 }
13840 arg1 = reinterpret_cast< wxFrame * >(argp1);
13841 {
13842 arg2 = wxString_in_helper(obj1);
13843 if (arg2 == NULL) SWIG_fail;
13844 temp2 = true;
13845 }
13846 {
13847 PyThreadState* __tstate = wxPyBeginAllowThreads();
13848 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13849 wxPyEndAllowThreads(__tstate);
13850 if (PyErr_Occurred()) SWIG_fail;
13851 }
13852 resultobj = SWIG_Py_Void();
13853 {
13854 if (temp2)
13855 delete arg2;
13856 }
13857 return resultobj;
13858 fail:
13859 {
13860 if (temp2)
13861 delete arg2;
13862 }
13863 return NULL;
13864 }
13865
13866
13867 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13868 PyObject *resultobj = 0;
13869 wxString *arg1 = 0 ;
13870 bool temp1 = false ;
13871 PyObject * obj0 = 0 ;
13872 char * kwnames[] = {
13873 (char *) "msg", NULL
13874 };
13875
13876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13877 {
13878 arg1 = wxString_in_helper(obj0);
13879 if (arg1 == NULL) SWIG_fail;
13880 temp1 = true;
13881 }
13882 {
13883 PyThreadState* __tstate = wxPyBeginAllowThreads();
13884 wxPyLogSysError((wxString const &)*arg1);
13885 wxPyEndAllowThreads(__tstate);
13886 if (PyErr_Occurred()) SWIG_fail;
13887 }
13888 resultobj = SWIG_Py_Void();
13889 {
13890 if (temp1)
13891 delete arg1;
13892 }
13893 return resultobj;
13894 fail:
13895 {
13896 if (temp1)
13897 delete arg1;
13898 }
13899 return NULL;
13900 }
13901
13902
13903 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13904 PyObject *resultobj = 0;
13905 unsigned long arg1 ;
13906 wxString *arg2 = 0 ;
13907 unsigned long val1 ;
13908 int ecode1 = 0 ;
13909 bool temp2 = false ;
13910 PyObject * obj0 = 0 ;
13911 PyObject * obj1 = 0 ;
13912 char * kwnames[] = {
13913 (char *) "level",(char *) "msg", NULL
13914 };
13915
13916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13917 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13918 if (!SWIG_IsOK(ecode1)) {
13919 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13920 }
13921 arg1 = static_cast< unsigned long >(val1);
13922 {
13923 arg2 = wxString_in_helper(obj1);
13924 if (arg2 == NULL) SWIG_fail;
13925 temp2 = true;
13926 }
13927 {
13928 PyThreadState* __tstate = wxPyBeginAllowThreads();
13929 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13930 wxPyEndAllowThreads(__tstate);
13931 if (PyErr_Occurred()) SWIG_fail;
13932 }
13933 resultobj = SWIG_Py_Void();
13934 {
13935 if (temp2)
13936 delete arg2;
13937 }
13938 return resultobj;
13939 fail:
13940 {
13941 if (temp2)
13942 delete arg2;
13943 }
13944 return NULL;
13945 }
13946
13947
13948 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13949 PyObject *resultobj = 0;
13950 unsigned long arg1 ;
13951 wxString *arg2 = 0 ;
13952 unsigned long val1 ;
13953 int ecode1 = 0 ;
13954 bool temp2 = false ;
13955
13956 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13957 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13958 if (!SWIG_IsOK(ecode1)) {
13959 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13960 }
13961 arg1 = static_cast< unsigned long >(val1);
13962 {
13963 arg2 = wxString_in_helper(swig_obj[1]);
13964 if (arg2 == NULL) SWIG_fail;
13965 temp2 = true;
13966 }
13967 {
13968 PyThreadState* __tstate = wxPyBeginAllowThreads();
13969 wxPyLogTrace(arg1,(wxString const &)*arg2);
13970 wxPyEndAllowThreads(__tstate);
13971 if (PyErr_Occurred()) SWIG_fail;
13972 }
13973 resultobj = SWIG_Py_Void();
13974 {
13975 if (temp2)
13976 delete arg2;
13977 }
13978 return resultobj;
13979 fail:
13980 {
13981 if (temp2)
13982 delete arg2;
13983 }
13984 return NULL;
13985 }
13986
13987
13988 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13989 PyObject *resultobj = 0;
13990 wxString *arg1 = 0 ;
13991 wxString *arg2 = 0 ;
13992 bool temp1 = false ;
13993 bool temp2 = false ;
13994
13995 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13996 {
13997 arg1 = wxString_in_helper(swig_obj[0]);
13998 if (arg1 == NULL) SWIG_fail;
13999 temp1 = true;
14000 }
14001 {
14002 arg2 = wxString_in_helper(swig_obj[1]);
14003 if (arg2 == NULL) SWIG_fail;
14004 temp2 = true;
14005 }
14006 {
14007 PyThreadState* __tstate = wxPyBeginAllowThreads();
14008 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14009 wxPyEndAllowThreads(__tstate);
14010 if (PyErr_Occurred()) SWIG_fail;
14011 }
14012 resultobj = SWIG_Py_Void();
14013 {
14014 if (temp1)
14015 delete arg1;
14016 }
14017 {
14018 if (temp2)
14019 delete arg2;
14020 }
14021 return resultobj;
14022 fail:
14023 {
14024 if (temp1)
14025 delete arg1;
14026 }
14027 {
14028 if (temp2)
14029 delete arg2;
14030 }
14031 return NULL;
14032 }
14033
14034
14035 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14036 int argc;
14037 PyObject *argv[3];
14038
14039 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14040 --argc;
14041 if (argc == 2) {
14042 int _v = 0;
14043 {
14044 {
14045 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14046 }
14047 }
14048 if (!_v) goto check_1;
14049 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14050 }
14051 check_1:
14052
14053 if (argc == 2) {
14054 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14055 }
14056
14057 fail:
14058 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14059 return NULL;
14060 }
14061
14062
14063 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14064 PyObject *resultobj = 0;
14065 wxString *arg1 = 0 ;
14066 wxString *arg2 = 0 ;
14067 bool temp1 = false ;
14068 bool temp2 = false ;
14069 PyObject * obj0 = 0 ;
14070 PyObject * obj1 = 0 ;
14071 char * kwnames[] = {
14072 (char *) "title",(char *) "text", NULL
14073 };
14074
14075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14076 {
14077 arg1 = wxString_in_helper(obj0);
14078 if (arg1 == NULL) SWIG_fail;
14079 temp1 = true;
14080 }
14081 {
14082 arg2 = wxString_in_helper(obj1);
14083 if (arg2 == NULL) SWIG_fail;
14084 temp2 = true;
14085 }
14086 {
14087 PyThreadState* __tstate = wxPyBeginAllowThreads();
14088 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14089 wxPyEndAllowThreads(__tstate);
14090 if (PyErr_Occurred()) SWIG_fail;
14091 }
14092 resultobj = SWIG_Py_Void();
14093 {
14094 if (temp1)
14095 delete arg1;
14096 }
14097 {
14098 if (temp2)
14099 delete arg2;
14100 }
14101 return resultobj;
14102 fail:
14103 {
14104 if (temp1)
14105 delete arg1;
14106 }
14107 {
14108 if (temp2)
14109 delete arg2;
14110 }
14111 return NULL;
14112 }
14113
14114
14115 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14116 PyObject *resultobj = 0;
14117 wxLogNull *result = 0 ;
14118
14119 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14120 {
14121 PyThreadState* __tstate = wxPyBeginAllowThreads();
14122 result = (wxLogNull *)new wxLogNull();
14123 wxPyEndAllowThreads(__tstate);
14124 if (PyErr_Occurred()) SWIG_fail;
14125 }
14126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14127 return resultobj;
14128 fail:
14129 return NULL;
14130 }
14131
14132
14133 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14134 PyObject *resultobj = 0;
14135 wxLogNull *arg1 = (wxLogNull *) 0 ;
14136 void *argp1 = 0 ;
14137 int res1 = 0 ;
14138 PyObject *swig_obj[1] ;
14139
14140 if (!args) SWIG_fail;
14141 swig_obj[0] = args;
14142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14143 if (!SWIG_IsOK(res1)) {
14144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14145 }
14146 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14147 {
14148 PyThreadState* __tstate = wxPyBeginAllowThreads();
14149 delete arg1;
14150
14151 wxPyEndAllowThreads(__tstate);
14152 if (PyErr_Occurred()) SWIG_fail;
14153 }
14154 resultobj = SWIG_Py_Void();
14155 return resultobj;
14156 fail:
14157 return NULL;
14158 }
14159
14160
14161 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14162 PyObject *obj;
14163 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14164 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14165 return SWIG_Py_Void();
14166 }
14167
14168 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14169 return SWIG_Python_InitShadowInstance(args);
14170 }
14171
14172 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14173 PyObject *resultobj = 0;
14174 wxPyLog *result = 0 ;
14175
14176 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14177 {
14178 PyThreadState* __tstate = wxPyBeginAllowThreads();
14179 result = (wxPyLog *)new wxPyLog();
14180 wxPyEndAllowThreads(__tstate);
14181 if (PyErr_Occurred()) SWIG_fail;
14182 }
14183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14184 return resultobj;
14185 fail:
14186 return NULL;
14187 }
14188
14189
14190 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14191 PyObject *resultobj = 0;
14192 wxPyLog *arg1 = (wxPyLog *) 0 ;
14193 PyObject *arg2 = (PyObject *) 0 ;
14194 PyObject *arg3 = (PyObject *) 0 ;
14195 void *argp1 = 0 ;
14196 int res1 = 0 ;
14197 PyObject * obj0 = 0 ;
14198 PyObject * obj1 = 0 ;
14199 PyObject * obj2 = 0 ;
14200 char * kwnames[] = {
14201 (char *) "self",(char *) "self",(char *) "_class", NULL
14202 };
14203
14204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14206 if (!SWIG_IsOK(res1)) {
14207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14208 }
14209 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14210 arg2 = obj1;
14211 arg3 = obj2;
14212 {
14213 PyThreadState* __tstate = wxPyBeginAllowThreads();
14214 (arg1)->_setCallbackInfo(arg2,arg3);
14215 wxPyEndAllowThreads(__tstate);
14216 if (PyErr_Occurred()) SWIG_fail;
14217 }
14218 resultobj = SWIG_Py_Void();
14219 return resultobj;
14220 fail:
14221 return NULL;
14222 }
14223
14224
14225 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14226 PyObject *obj;
14227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14228 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14229 return SWIG_Py_Void();
14230 }
14231
14232 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14233 return SWIG_Python_InitShadowInstance(args);
14234 }
14235
14236 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14237 PyObject *resultobj = 0;
14238 int arg1 ;
14239 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14240 int arg3 = (int) wxKILL_NOCHILDREN ;
14241 wxKillError result;
14242 int val1 ;
14243 int ecode1 = 0 ;
14244 int val2 ;
14245 int ecode2 = 0 ;
14246 int val3 ;
14247 int ecode3 = 0 ;
14248 PyObject * obj0 = 0 ;
14249 PyObject * obj1 = 0 ;
14250 PyObject * obj2 = 0 ;
14251 char * kwnames[] = {
14252 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14253 };
14254
14255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14256 ecode1 = SWIG_AsVal_int(obj0, &val1);
14257 if (!SWIG_IsOK(ecode1)) {
14258 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14259 }
14260 arg1 = static_cast< int >(val1);
14261 if (obj1) {
14262 ecode2 = SWIG_AsVal_int(obj1, &val2);
14263 if (!SWIG_IsOK(ecode2)) {
14264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14265 }
14266 arg2 = static_cast< wxSignal >(val2);
14267 }
14268 if (obj2) {
14269 ecode3 = SWIG_AsVal_int(obj2, &val3);
14270 if (!SWIG_IsOK(ecode3)) {
14271 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14272 }
14273 arg3 = static_cast< int >(val3);
14274 }
14275 {
14276 PyThreadState* __tstate = wxPyBeginAllowThreads();
14277 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14278 wxPyEndAllowThreads(__tstate);
14279 if (PyErr_Occurred()) SWIG_fail;
14280 }
14281 resultobj = SWIG_From_int(static_cast< int >(result));
14282 return resultobj;
14283 fail:
14284 return NULL;
14285 }
14286
14287
14288 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14289 PyObject *resultobj = 0;
14290 int arg1 ;
14291 bool result;
14292 int val1 ;
14293 int ecode1 = 0 ;
14294 PyObject * obj0 = 0 ;
14295 char * kwnames[] = {
14296 (char *) "pid", NULL
14297 };
14298
14299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14300 ecode1 = SWIG_AsVal_int(obj0, &val1);
14301 if (!SWIG_IsOK(ecode1)) {
14302 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14303 }
14304 arg1 = static_cast< int >(val1);
14305 {
14306 PyThreadState* __tstate = wxPyBeginAllowThreads();
14307 result = (bool)wxPyProcess::Exists(arg1);
14308 wxPyEndAllowThreads(__tstate);
14309 if (PyErr_Occurred()) SWIG_fail;
14310 }
14311 {
14312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14313 }
14314 return resultobj;
14315 fail:
14316 return NULL;
14317 }
14318
14319
14320 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14321 PyObject *resultobj = 0;
14322 wxString *arg1 = 0 ;
14323 int arg2 = (int) wxEXEC_ASYNC ;
14324 wxPyProcess *result = 0 ;
14325 bool temp1 = false ;
14326 int val2 ;
14327 int ecode2 = 0 ;
14328 PyObject * obj0 = 0 ;
14329 PyObject * obj1 = 0 ;
14330 char * kwnames[] = {
14331 (char *) "cmd",(char *) "flags", NULL
14332 };
14333
14334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14335 {
14336 arg1 = wxString_in_helper(obj0);
14337 if (arg1 == NULL) SWIG_fail;
14338 temp1 = true;
14339 }
14340 if (obj1) {
14341 ecode2 = SWIG_AsVal_int(obj1, &val2);
14342 if (!SWIG_IsOK(ecode2)) {
14343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14344 }
14345 arg2 = static_cast< int >(val2);
14346 }
14347 {
14348 PyThreadState* __tstate = wxPyBeginAllowThreads();
14349 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14350 wxPyEndAllowThreads(__tstate);
14351 if (PyErr_Occurred()) SWIG_fail;
14352 }
14353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14354 {
14355 if (temp1)
14356 delete arg1;
14357 }
14358 return resultobj;
14359 fail:
14360 {
14361 if (temp1)
14362 delete arg1;
14363 }
14364 return NULL;
14365 }
14366
14367
14368 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14369 PyObject *resultobj = 0;
14370 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14371 int arg2 = (int) -1 ;
14372 wxPyProcess *result = 0 ;
14373 void *argp1 = 0 ;
14374 int res1 = 0 ;
14375 int val2 ;
14376 int ecode2 = 0 ;
14377 PyObject * obj0 = 0 ;
14378 PyObject * obj1 = 0 ;
14379 char * kwnames[] = {
14380 (char *) "parent",(char *) "id", NULL
14381 };
14382
14383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14384 if (obj0) {
14385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14386 if (!SWIG_IsOK(res1)) {
14387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14388 }
14389 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14390 }
14391 if (obj1) {
14392 ecode2 = SWIG_AsVal_int(obj1, &val2);
14393 if (!SWIG_IsOK(ecode2)) {
14394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14395 }
14396 arg2 = static_cast< int >(val2);
14397 }
14398 {
14399 PyThreadState* __tstate = wxPyBeginAllowThreads();
14400 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14401 wxPyEndAllowThreads(__tstate);
14402 if (PyErr_Occurred()) SWIG_fail;
14403 }
14404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14405 return resultobj;
14406 fail:
14407 return NULL;
14408 }
14409
14410
14411 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14412 PyObject *resultobj = 0;
14413 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14414 void *argp1 = 0 ;
14415 int res1 = 0 ;
14416 PyObject *swig_obj[1] ;
14417
14418 if (!args) SWIG_fail;
14419 swig_obj[0] = args;
14420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14421 if (!SWIG_IsOK(res1)) {
14422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14423 }
14424 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14425 {
14426 PyThreadState* __tstate = wxPyBeginAllowThreads();
14427 delete arg1;
14428
14429 wxPyEndAllowThreads(__tstate);
14430 if (PyErr_Occurred()) SWIG_fail;
14431 }
14432 resultobj = SWIG_Py_Void();
14433 return resultobj;
14434 fail:
14435 return NULL;
14436 }
14437
14438
14439 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14440 PyObject *resultobj = 0;
14441 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14442 long result;
14443 void *argp1 = 0 ;
14444 int res1 = 0 ;
14445 PyObject *swig_obj[1] ;
14446
14447 if (!args) SWIG_fail;
14448 swig_obj[0] = args;
14449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14450 if (!SWIG_IsOK(res1)) {
14451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14452 }
14453 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14454 {
14455 PyThreadState* __tstate = wxPyBeginAllowThreads();
14456 result = (long)((wxPyProcess const *)arg1)->GetPid();
14457 wxPyEndAllowThreads(__tstate);
14458 if (PyErr_Occurred()) SWIG_fail;
14459 }
14460 resultobj = SWIG_From_long(static_cast< long >(result));
14461 return resultobj;
14462 fail:
14463 return NULL;
14464 }
14465
14466
14467 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14468 PyObject *resultobj = 0;
14469 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14470 PyObject *arg2 = (PyObject *) 0 ;
14471 PyObject *arg3 = (PyObject *) 0 ;
14472 void *argp1 = 0 ;
14473 int res1 = 0 ;
14474 PyObject * obj0 = 0 ;
14475 PyObject * obj1 = 0 ;
14476 PyObject * obj2 = 0 ;
14477 char * kwnames[] = {
14478 (char *) "self",(char *) "self",(char *) "_class", NULL
14479 };
14480
14481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14483 if (!SWIG_IsOK(res1)) {
14484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14485 }
14486 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14487 arg2 = obj1;
14488 arg3 = obj2;
14489 {
14490 PyThreadState* __tstate = wxPyBeginAllowThreads();
14491 (arg1)->_setCallbackInfo(arg2,arg3);
14492 wxPyEndAllowThreads(__tstate);
14493 if (PyErr_Occurred()) SWIG_fail;
14494 }
14495 resultobj = SWIG_Py_Void();
14496 return resultobj;
14497 fail:
14498 return NULL;
14499 }
14500
14501
14502 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14503 PyObject *resultobj = 0;
14504 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14505 int arg2 ;
14506 int arg3 ;
14507 void *argp1 = 0 ;
14508 int res1 = 0 ;
14509 int val2 ;
14510 int ecode2 = 0 ;
14511 int val3 ;
14512 int ecode3 = 0 ;
14513 PyObject * obj0 = 0 ;
14514 PyObject * obj1 = 0 ;
14515 PyObject * obj2 = 0 ;
14516 char * kwnames[] = {
14517 (char *) "self",(char *) "pid",(char *) "status", NULL
14518 };
14519
14520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14522 if (!SWIG_IsOK(res1)) {
14523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14524 }
14525 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14526 ecode2 = SWIG_AsVal_int(obj1, &val2);
14527 if (!SWIG_IsOK(ecode2)) {
14528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14529 }
14530 arg2 = static_cast< int >(val2);
14531 ecode3 = SWIG_AsVal_int(obj2, &val3);
14532 if (!SWIG_IsOK(ecode3)) {
14533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14534 }
14535 arg3 = static_cast< int >(val3);
14536 {
14537 PyThreadState* __tstate = wxPyBeginAllowThreads();
14538 (arg1)->OnTerminate(arg2,arg3);
14539 wxPyEndAllowThreads(__tstate);
14540 if (PyErr_Occurred()) SWIG_fail;
14541 }
14542 resultobj = SWIG_Py_Void();
14543 return resultobj;
14544 fail:
14545 return NULL;
14546 }
14547
14548
14549 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14550 PyObject *resultobj = 0;
14551 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14552 void *argp1 = 0 ;
14553 int res1 = 0 ;
14554 PyObject *swig_obj[1] ;
14555
14556 if (!args) SWIG_fail;
14557 swig_obj[0] = args;
14558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14559 if (!SWIG_IsOK(res1)) {
14560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14561 }
14562 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14563 {
14564 PyThreadState* __tstate = wxPyBeginAllowThreads();
14565 (arg1)->Redirect();
14566 wxPyEndAllowThreads(__tstate);
14567 if (PyErr_Occurred()) SWIG_fail;
14568 }
14569 resultobj = SWIG_Py_Void();
14570 return resultobj;
14571 fail:
14572 return NULL;
14573 }
14574
14575
14576 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14577 PyObject *resultobj = 0;
14578 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14579 bool result;
14580 void *argp1 = 0 ;
14581 int res1 = 0 ;
14582 PyObject *swig_obj[1] ;
14583
14584 if (!args) SWIG_fail;
14585 swig_obj[0] = args;
14586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14587 if (!SWIG_IsOK(res1)) {
14588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14589 }
14590 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14591 {
14592 PyThreadState* __tstate = wxPyBeginAllowThreads();
14593 result = (bool)(arg1)->IsRedirected();
14594 wxPyEndAllowThreads(__tstate);
14595 if (PyErr_Occurred()) SWIG_fail;
14596 }
14597 {
14598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14599 }
14600 return resultobj;
14601 fail:
14602 return NULL;
14603 }
14604
14605
14606 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14607 PyObject *resultobj = 0;
14608 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14609 void *argp1 = 0 ;
14610 int res1 = 0 ;
14611 PyObject *swig_obj[1] ;
14612
14613 if (!args) SWIG_fail;
14614 swig_obj[0] = args;
14615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14616 if (!SWIG_IsOK(res1)) {
14617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14618 }
14619 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14620 {
14621 PyThreadState* __tstate = wxPyBeginAllowThreads();
14622 (arg1)->Detach();
14623 wxPyEndAllowThreads(__tstate);
14624 if (PyErr_Occurred()) SWIG_fail;
14625 }
14626 resultobj = SWIG_Py_Void();
14627 return resultobj;
14628 fail:
14629 return NULL;
14630 }
14631
14632
14633 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14634 PyObject *resultobj = 0;
14635 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14636 wxInputStream *result = 0 ;
14637 void *argp1 = 0 ;
14638 int res1 = 0 ;
14639 PyObject *swig_obj[1] ;
14640
14641 if (!args) SWIG_fail;
14642 swig_obj[0] = args;
14643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14644 if (!SWIG_IsOK(res1)) {
14645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14646 }
14647 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14648 {
14649 PyThreadState* __tstate = wxPyBeginAllowThreads();
14650 result = (wxInputStream *)(arg1)->GetInputStream();
14651 wxPyEndAllowThreads(__tstate);
14652 if (PyErr_Occurred()) SWIG_fail;
14653 }
14654 {
14655 wxPyInputStream * _ptr = NULL;
14656
14657 if (result) {
14658 _ptr = new wxPyInputStream(result);
14659 }
14660 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14661 }
14662 return resultobj;
14663 fail:
14664 return NULL;
14665 }
14666
14667
14668 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14669 PyObject *resultobj = 0;
14670 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14671 wxInputStream *result = 0 ;
14672 void *argp1 = 0 ;
14673 int res1 = 0 ;
14674 PyObject *swig_obj[1] ;
14675
14676 if (!args) SWIG_fail;
14677 swig_obj[0] = args;
14678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14679 if (!SWIG_IsOK(res1)) {
14680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14681 }
14682 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14683 {
14684 PyThreadState* __tstate = wxPyBeginAllowThreads();
14685 result = (wxInputStream *)(arg1)->GetErrorStream();
14686 wxPyEndAllowThreads(__tstate);
14687 if (PyErr_Occurred()) SWIG_fail;
14688 }
14689 {
14690 wxPyInputStream * _ptr = NULL;
14691
14692 if (result) {
14693 _ptr = new wxPyInputStream(result);
14694 }
14695 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14696 }
14697 return resultobj;
14698 fail:
14699 return NULL;
14700 }
14701
14702
14703 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14704 PyObject *resultobj = 0;
14705 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14706 wxOutputStream *result = 0 ;
14707 void *argp1 = 0 ;
14708 int res1 = 0 ;
14709 PyObject *swig_obj[1] ;
14710
14711 if (!args) SWIG_fail;
14712 swig_obj[0] = args;
14713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14714 if (!SWIG_IsOK(res1)) {
14715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14716 }
14717 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14718 {
14719 PyThreadState* __tstate = wxPyBeginAllowThreads();
14720 result = (wxOutputStream *)(arg1)->GetOutputStream();
14721 wxPyEndAllowThreads(__tstate);
14722 if (PyErr_Occurred()) SWIG_fail;
14723 }
14724 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14725 return resultobj;
14726 fail:
14727 return NULL;
14728 }
14729
14730
14731 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14732 PyObject *resultobj = 0;
14733 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14734 void *argp1 = 0 ;
14735 int res1 = 0 ;
14736 PyObject *swig_obj[1] ;
14737
14738 if (!args) SWIG_fail;
14739 swig_obj[0] = args;
14740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14741 if (!SWIG_IsOK(res1)) {
14742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14743 }
14744 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14745 {
14746 PyThreadState* __tstate = wxPyBeginAllowThreads();
14747 (arg1)->CloseOutput();
14748 wxPyEndAllowThreads(__tstate);
14749 if (PyErr_Occurred()) SWIG_fail;
14750 }
14751 resultobj = SWIG_Py_Void();
14752 return resultobj;
14753 fail:
14754 return NULL;
14755 }
14756
14757
14758 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14759 PyObject *resultobj = 0;
14760 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14761 bool result;
14762 void *argp1 = 0 ;
14763 int res1 = 0 ;
14764 PyObject *swig_obj[1] ;
14765
14766 if (!args) SWIG_fail;
14767 swig_obj[0] = args;
14768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14769 if (!SWIG_IsOK(res1)) {
14770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14771 }
14772 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14773 {
14774 PyThreadState* __tstate = wxPyBeginAllowThreads();
14775 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14776 wxPyEndAllowThreads(__tstate);
14777 if (PyErr_Occurred()) SWIG_fail;
14778 }
14779 {
14780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14781 }
14782 return resultobj;
14783 fail:
14784 return NULL;
14785 }
14786
14787
14788 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14789 PyObject *resultobj = 0;
14790 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14791 bool result;
14792 void *argp1 = 0 ;
14793 int res1 = 0 ;
14794 PyObject *swig_obj[1] ;
14795
14796 if (!args) SWIG_fail;
14797 swig_obj[0] = args;
14798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14799 if (!SWIG_IsOK(res1)) {
14800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14801 }
14802 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14803 {
14804 PyThreadState* __tstate = wxPyBeginAllowThreads();
14805 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14806 wxPyEndAllowThreads(__tstate);
14807 if (PyErr_Occurred()) SWIG_fail;
14808 }
14809 {
14810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14811 }
14812 return resultobj;
14813 fail:
14814 return NULL;
14815 }
14816
14817
14818 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14819 PyObject *resultobj = 0;
14820 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14821 bool result;
14822 void *argp1 = 0 ;
14823 int res1 = 0 ;
14824 PyObject *swig_obj[1] ;
14825
14826 if (!args) SWIG_fail;
14827 swig_obj[0] = args;
14828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14829 if (!SWIG_IsOK(res1)) {
14830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14831 }
14832 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14833 {
14834 PyThreadState* __tstate = wxPyBeginAllowThreads();
14835 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14836 wxPyEndAllowThreads(__tstate);
14837 if (PyErr_Occurred()) SWIG_fail;
14838 }
14839 {
14840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14841 }
14842 return resultobj;
14843 fail:
14844 return NULL;
14845 }
14846
14847
14848 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14849 PyObject *obj;
14850 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14851 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14852 return SWIG_Py_Void();
14853 }
14854
14855 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14856 return SWIG_Python_InitShadowInstance(args);
14857 }
14858
14859 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14860 PyObject *resultobj = 0;
14861 int arg1 = (int) 0 ;
14862 int arg2 = (int) 0 ;
14863 int arg3 = (int) 0 ;
14864 wxProcessEvent *result = 0 ;
14865 int val1 ;
14866 int ecode1 = 0 ;
14867 int val2 ;
14868 int ecode2 = 0 ;
14869 int val3 ;
14870 int ecode3 = 0 ;
14871 PyObject * obj0 = 0 ;
14872 PyObject * obj1 = 0 ;
14873 PyObject * obj2 = 0 ;
14874 char * kwnames[] = {
14875 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14876 };
14877
14878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14879 if (obj0) {
14880 ecode1 = SWIG_AsVal_int(obj0, &val1);
14881 if (!SWIG_IsOK(ecode1)) {
14882 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14883 }
14884 arg1 = static_cast< int >(val1);
14885 }
14886 if (obj1) {
14887 ecode2 = SWIG_AsVal_int(obj1, &val2);
14888 if (!SWIG_IsOK(ecode2)) {
14889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14890 }
14891 arg2 = static_cast< int >(val2);
14892 }
14893 if (obj2) {
14894 ecode3 = SWIG_AsVal_int(obj2, &val3);
14895 if (!SWIG_IsOK(ecode3)) {
14896 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14897 }
14898 arg3 = static_cast< int >(val3);
14899 }
14900 {
14901 PyThreadState* __tstate = wxPyBeginAllowThreads();
14902 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14903 wxPyEndAllowThreads(__tstate);
14904 if (PyErr_Occurred()) SWIG_fail;
14905 }
14906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14907 return resultobj;
14908 fail:
14909 return NULL;
14910 }
14911
14912
14913 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14914 PyObject *resultobj = 0;
14915 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14916 int result;
14917 void *argp1 = 0 ;
14918 int res1 = 0 ;
14919 PyObject *swig_obj[1] ;
14920
14921 if (!args) SWIG_fail;
14922 swig_obj[0] = args;
14923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14924 if (!SWIG_IsOK(res1)) {
14925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14926 }
14927 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14928 {
14929 PyThreadState* __tstate = wxPyBeginAllowThreads();
14930 result = (int)(arg1)->GetPid();
14931 wxPyEndAllowThreads(__tstate);
14932 if (PyErr_Occurred()) SWIG_fail;
14933 }
14934 resultobj = SWIG_From_int(static_cast< int >(result));
14935 return resultobj;
14936 fail:
14937 return NULL;
14938 }
14939
14940
14941 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14942 PyObject *resultobj = 0;
14943 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14944 int result;
14945 void *argp1 = 0 ;
14946 int res1 = 0 ;
14947 PyObject *swig_obj[1] ;
14948
14949 if (!args) SWIG_fail;
14950 swig_obj[0] = args;
14951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14952 if (!SWIG_IsOK(res1)) {
14953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14954 }
14955 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14956 {
14957 PyThreadState* __tstate = wxPyBeginAllowThreads();
14958 result = (int)(arg1)->GetExitCode();
14959 wxPyEndAllowThreads(__tstate);
14960 if (PyErr_Occurred()) SWIG_fail;
14961 }
14962 resultobj = SWIG_From_int(static_cast< int >(result));
14963 return resultobj;
14964 fail:
14965 return NULL;
14966 }
14967
14968
14969 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14970 PyObject *resultobj = 0;
14971 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14972 int arg2 ;
14973 void *argp1 = 0 ;
14974 int res1 = 0 ;
14975 int val2 ;
14976 int ecode2 = 0 ;
14977 PyObject *swig_obj[2] ;
14978
14979 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14981 if (!SWIG_IsOK(res1)) {
14982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14983 }
14984 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14985 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14986 if (!SWIG_IsOK(ecode2)) {
14987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14988 }
14989 arg2 = static_cast< int >(val2);
14990 if (arg1) (arg1)->m_pid = arg2;
14991
14992 resultobj = SWIG_Py_Void();
14993 return resultobj;
14994 fail:
14995 return NULL;
14996 }
14997
14998
14999 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15000 PyObject *resultobj = 0;
15001 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15002 int result;
15003 void *argp1 = 0 ;
15004 int res1 = 0 ;
15005 PyObject *swig_obj[1] ;
15006
15007 if (!args) SWIG_fail;
15008 swig_obj[0] = args;
15009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15010 if (!SWIG_IsOK(res1)) {
15011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15012 }
15013 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15014 result = (int) ((arg1)->m_pid);
15015 resultobj = SWIG_From_int(static_cast< int >(result));
15016 return resultobj;
15017 fail:
15018 return NULL;
15019 }
15020
15021
15022 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15023 PyObject *resultobj = 0;
15024 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15025 int arg2 ;
15026 void *argp1 = 0 ;
15027 int res1 = 0 ;
15028 int val2 ;
15029 int ecode2 = 0 ;
15030 PyObject *swig_obj[2] ;
15031
15032 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15034 if (!SWIG_IsOK(res1)) {
15035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15036 }
15037 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15038 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15039 if (!SWIG_IsOK(ecode2)) {
15040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15041 }
15042 arg2 = static_cast< int >(val2);
15043 if (arg1) (arg1)->m_exitcode = arg2;
15044
15045 resultobj = SWIG_Py_Void();
15046 return resultobj;
15047 fail:
15048 return NULL;
15049 }
15050
15051
15052 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15053 PyObject *resultobj = 0;
15054 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15055 int result;
15056 void *argp1 = 0 ;
15057 int res1 = 0 ;
15058 PyObject *swig_obj[1] ;
15059
15060 if (!args) SWIG_fail;
15061 swig_obj[0] = args;
15062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15063 if (!SWIG_IsOK(res1)) {
15064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15065 }
15066 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15067 result = (int) ((arg1)->m_exitcode);
15068 resultobj = SWIG_From_int(static_cast< int >(result));
15069 return resultobj;
15070 fail:
15071 return NULL;
15072 }
15073
15074
15075 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15076 PyObject *obj;
15077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15078 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15079 return SWIG_Py_Void();
15080 }
15081
15082 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15083 return SWIG_Python_InitShadowInstance(args);
15084 }
15085
15086 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15087 PyObject *resultobj = 0;
15088 wxString *arg1 = 0 ;
15089 int arg2 = (int) wxEXEC_ASYNC ;
15090 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15091 long result;
15092 bool temp1 = false ;
15093 int val2 ;
15094 int ecode2 = 0 ;
15095 void *argp3 = 0 ;
15096 int res3 = 0 ;
15097 PyObject * obj0 = 0 ;
15098 PyObject * obj1 = 0 ;
15099 PyObject * obj2 = 0 ;
15100 char * kwnames[] = {
15101 (char *) "command",(char *) "flags",(char *) "process", NULL
15102 };
15103
15104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15105 {
15106 arg1 = wxString_in_helper(obj0);
15107 if (arg1 == NULL) SWIG_fail;
15108 temp1 = true;
15109 }
15110 if (obj1) {
15111 ecode2 = SWIG_AsVal_int(obj1, &val2);
15112 if (!SWIG_IsOK(ecode2)) {
15113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15114 }
15115 arg2 = static_cast< int >(val2);
15116 }
15117 if (obj2) {
15118 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15119 if (!SWIG_IsOK(res3)) {
15120 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15121 }
15122 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15123 }
15124 {
15125 if (!wxPyCheckForApp()) SWIG_fail;
15126 PyThreadState* __tstate = wxPyBeginAllowThreads();
15127 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15128 wxPyEndAllowThreads(__tstate);
15129 if (PyErr_Occurred()) SWIG_fail;
15130 }
15131 resultobj = SWIG_From_long(static_cast< long >(result));
15132 {
15133 if (temp1)
15134 delete arg1;
15135 }
15136 return resultobj;
15137 fail:
15138 {
15139 if (temp1)
15140 delete arg1;
15141 }
15142 return NULL;
15143 }
15144
15145
15146 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15147 PyObject *resultobj = 0;
15148 long arg1 ;
15149 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15150 wxKillError *arg3 = (wxKillError *) 0 ;
15151 int arg4 = (int) wxKILL_NOCHILDREN ;
15152 int result;
15153 long val1 ;
15154 int ecode1 = 0 ;
15155 int val2 ;
15156 int ecode2 = 0 ;
15157 wxKillError temp3 ;
15158 int val4 ;
15159 int ecode4 = 0 ;
15160 PyObject * obj0 = 0 ;
15161 PyObject * obj1 = 0 ;
15162 PyObject * obj2 = 0 ;
15163 char * kwnames[] = {
15164 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15165 };
15166
15167 {
15168 arg3 = &temp3;
15169 }
15170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15171 ecode1 = SWIG_AsVal_long(obj0, &val1);
15172 if (!SWIG_IsOK(ecode1)) {
15173 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15174 }
15175 arg1 = static_cast< long >(val1);
15176 if (obj1) {
15177 ecode2 = SWIG_AsVal_int(obj1, &val2);
15178 if (!SWIG_IsOK(ecode2)) {
15179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15180 }
15181 arg2 = static_cast< wxSignal >(val2);
15182 }
15183 if (obj2) {
15184 ecode4 = SWIG_AsVal_int(obj2, &val4);
15185 if (!SWIG_IsOK(ecode4)) {
15186 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15187 }
15188 arg4 = static_cast< int >(val4);
15189 }
15190 {
15191 PyThreadState* __tstate = wxPyBeginAllowThreads();
15192 result = (int)wxKill(arg1,arg2,arg3,arg4);
15193 wxPyEndAllowThreads(__tstate);
15194 if (PyErr_Occurred()) SWIG_fail;
15195 }
15196 resultobj = SWIG_From_int(static_cast< int >(result));
15197 {
15198 PyObject* o;
15199 o = PyInt_FromLong((long) (*arg3));
15200
15201
15202
15203 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15204
15205 }
15206 return resultobj;
15207 fail:
15208 return NULL;
15209 }
15210
15211
15212 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15213 PyObject *resultobj = 0;
15214 int arg1 = (int) wxJOYSTICK1 ;
15215 wxJoystick *result = 0 ;
15216 int val1 ;
15217 int ecode1 = 0 ;
15218 PyObject * obj0 = 0 ;
15219 char * kwnames[] = {
15220 (char *) "joystick", NULL
15221 };
15222
15223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15224 if (obj0) {
15225 ecode1 = SWIG_AsVal_int(obj0, &val1);
15226 if (!SWIG_IsOK(ecode1)) {
15227 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15228 }
15229 arg1 = static_cast< int >(val1);
15230 }
15231 {
15232 if (!wxPyCheckForApp()) SWIG_fail;
15233 PyThreadState* __tstate = wxPyBeginAllowThreads();
15234 result = (wxJoystick *)new wxJoystick(arg1);
15235 wxPyEndAllowThreads(__tstate);
15236 if (PyErr_Occurred()) SWIG_fail;
15237 }
15238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15239 return resultobj;
15240 fail:
15241 return NULL;
15242 }
15243
15244
15245 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15246 PyObject *resultobj = 0;
15247 wxJoystick *arg1 = (wxJoystick *) 0 ;
15248 void *argp1 = 0 ;
15249 int res1 = 0 ;
15250 PyObject *swig_obj[1] ;
15251
15252 if (!args) SWIG_fail;
15253 swig_obj[0] = args;
15254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15255 if (!SWIG_IsOK(res1)) {
15256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15257 }
15258 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15259 {
15260 PyThreadState* __tstate = wxPyBeginAllowThreads();
15261 delete arg1;
15262
15263 wxPyEndAllowThreads(__tstate);
15264 if (PyErr_Occurred()) SWIG_fail;
15265 }
15266 resultobj = SWIG_Py_Void();
15267 return resultobj;
15268 fail:
15269 return NULL;
15270 }
15271
15272
15273 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15274 PyObject *resultobj = 0;
15275 wxJoystick *arg1 = (wxJoystick *) 0 ;
15276 wxPoint result;
15277 void *argp1 = 0 ;
15278 int res1 = 0 ;
15279 PyObject *swig_obj[1] ;
15280
15281 if (!args) SWIG_fail;
15282 swig_obj[0] = args;
15283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15284 if (!SWIG_IsOK(res1)) {
15285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15286 }
15287 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15288 {
15289 PyThreadState* __tstate = wxPyBeginAllowThreads();
15290 result = (arg1)->GetPosition();
15291 wxPyEndAllowThreads(__tstate);
15292 if (PyErr_Occurred()) SWIG_fail;
15293 }
15294 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15295 return resultobj;
15296 fail:
15297 return NULL;
15298 }
15299
15300
15301 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15302 PyObject *resultobj = 0;
15303 wxJoystick *arg1 = (wxJoystick *) 0 ;
15304 int result;
15305 void *argp1 = 0 ;
15306 int res1 = 0 ;
15307 PyObject *swig_obj[1] ;
15308
15309 if (!args) SWIG_fail;
15310 swig_obj[0] = args;
15311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15312 if (!SWIG_IsOK(res1)) {
15313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15314 }
15315 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15316 {
15317 PyThreadState* __tstate = wxPyBeginAllowThreads();
15318 result = (int)(arg1)->GetZPosition();
15319 wxPyEndAllowThreads(__tstate);
15320 if (PyErr_Occurred()) SWIG_fail;
15321 }
15322 resultobj = SWIG_From_int(static_cast< int >(result));
15323 return resultobj;
15324 fail:
15325 return NULL;
15326 }
15327
15328
15329 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15330 PyObject *resultobj = 0;
15331 wxJoystick *arg1 = (wxJoystick *) 0 ;
15332 int result;
15333 void *argp1 = 0 ;
15334 int res1 = 0 ;
15335 PyObject *swig_obj[1] ;
15336
15337 if (!args) SWIG_fail;
15338 swig_obj[0] = args;
15339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15340 if (!SWIG_IsOK(res1)) {
15341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15342 }
15343 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15344 {
15345 PyThreadState* __tstate = wxPyBeginAllowThreads();
15346 result = (int)(arg1)->GetButtonState();
15347 wxPyEndAllowThreads(__tstate);
15348 if (PyErr_Occurred()) SWIG_fail;
15349 }
15350 resultobj = SWIG_From_int(static_cast< int >(result));
15351 return resultobj;
15352 fail:
15353 return NULL;
15354 }
15355
15356
15357 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15358 PyObject *resultobj = 0;
15359 wxJoystick *arg1 = (wxJoystick *) 0 ;
15360 int result;
15361 void *argp1 = 0 ;
15362 int res1 = 0 ;
15363 PyObject *swig_obj[1] ;
15364
15365 if (!args) SWIG_fail;
15366 swig_obj[0] = args;
15367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15368 if (!SWIG_IsOK(res1)) {
15369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15370 }
15371 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15372 {
15373 PyThreadState* __tstate = wxPyBeginAllowThreads();
15374 result = (int)(arg1)->GetPOVPosition();
15375 wxPyEndAllowThreads(__tstate);
15376 if (PyErr_Occurred()) SWIG_fail;
15377 }
15378 resultobj = SWIG_From_int(static_cast< int >(result));
15379 return resultobj;
15380 fail:
15381 return NULL;
15382 }
15383
15384
15385 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15386 PyObject *resultobj = 0;
15387 wxJoystick *arg1 = (wxJoystick *) 0 ;
15388 int result;
15389 void *argp1 = 0 ;
15390 int res1 = 0 ;
15391 PyObject *swig_obj[1] ;
15392
15393 if (!args) SWIG_fail;
15394 swig_obj[0] = args;
15395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15396 if (!SWIG_IsOK(res1)) {
15397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15398 }
15399 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15400 {
15401 PyThreadState* __tstate = wxPyBeginAllowThreads();
15402 result = (int)(arg1)->GetPOVCTSPosition();
15403 wxPyEndAllowThreads(__tstate);
15404 if (PyErr_Occurred()) SWIG_fail;
15405 }
15406 resultobj = SWIG_From_int(static_cast< int >(result));
15407 return resultobj;
15408 fail:
15409 return NULL;
15410 }
15411
15412
15413 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15414 PyObject *resultobj = 0;
15415 wxJoystick *arg1 = (wxJoystick *) 0 ;
15416 int result;
15417 void *argp1 = 0 ;
15418 int res1 = 0 ;
15419 PyObject *swig_obj[1] ;
15420
15421 if (!args) SWIG_fail;
15422 swig_obj[0] = args;
15423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15424 if (!SWIG_IsOK(res1)) {
15425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15426 }
15427 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15428 {
15429 PyThreadState* __tstate = wxPyBeginAllowThreads();
15430 result = (int)(arg1)->GetRudderPosition();
15431 wxPyEndAllowThreads(__tstate);
15432 if (PyErr_Occurred()) SWIG_fail;
15433 }
15434 resultobj = SWIG_From_int(static_cast< int >(result));
15435 return resultobj;
15436 fail:
15437 return NULL;
15438 }
15439
15440
15441 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15442 PyObject *resultobj = 0;
15443 wxJoystick *arg1 = (wxJoystick *) 0 ;
15444 int result;
15445 void *argp1 = 0 ;
15446 int res1 = 0 ;
15447 PyObject *swig_obj[1] ;
15448
15449 if (!args) SWIG_fail;
15450 swig_obj[0] = args;
15451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15452 if (!SWIG_IsOK(res1)) {
15453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15454 }
15455 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15456 {
15457 PyThreadState* __tstate = wxPyBeginAllowThreads();
15458 result = (int)(arg1)->GetUPosition();
15459 wxPyEndAllowThreads(__tstate);
15460 if (PyErr_Occurred()) SWIG_fail;
15461 }
15462 resultobj = SWIG_From_int(static_cast< int >(result));
15463 return resultobj;
15464 fail:
15465 return NULL;
15466 }
15467
15468
15469 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15470 PyObject *resultobj = 0;
15471 wxJoystick *arg1 = (wxJoystick *) 0 ;
15472 int result;
15473 void *argp1 = 0 ;
15474 int res1 = 0 ;
15475 PyObject *swig_obj[1] ;
15476
15477 if (!args) SWIG_fail;
15478 swig_obj[0] = args;
15479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15480 if (!SWIG_IsOK(res1)) {
15481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15482 }
15483 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15484 {
15485 PyThreadState* __tstate = wxPyBeginAllowThreads();
15486 result = (int)(arg1)->GetVPosition();
15487 wxPyEndAllowThreads(__tstate);
15488 if (PyErr_Occurred()) SWIG_fail;
15489 }
15490 resultobj = SWIG_From_int(static_cast< int >(result));
15491 return resultobj;
15492 fail:
15493 return NULL;
15494 }
15495
15496
15497 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15498 PyObject *resultobj = 0;
15499 wxJoystick *arg1 = (wxJoystick *) 0 ;
15500 int result;
15501 void *argp1 = 0 ;
15502 int res1 = 0 ;
15503 PyObject *swig_obj[1] ;
15504
15505 if (!args) SWIG_fail;
15506 swig_obj[0] = args;
15507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15508 if (!SWIG_IsOK(res1)) {
15509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15510 }
15511 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15512 {
15513 PyThreadState* __tstate = wxPyBeginAllowThreads();
15514 result = (int)(arg1)->GetMovementThreshold();
15515 wxPyEndAllowThreads(__tstate);
15516 if (PyErr_Occurred()) SWIG_fail;
15517 }
15518 resultobj = SWIG_From_int(static_cast< int >(result));
15519 return resultobj;
15520 fail:
15521 return NULL;
15522 }
15523
15524
15525 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15526 PyObject *resultobj = 0;
15527 wxJoystick *arg1 = (wxJoystick *) 0 ;
15528 int arg2 ;
15529 void *argp1 = 0 ;
15530 int res1 = 0 ;
15531 int val2 ;
15532 int ecode2 = 0 ;
15533 PyObject * obj0 = 0 ;
15534 PyObject * obj1 = 0 ;
15535 char * kwnames[] = {
15536 (char *) "self",(char *) "threshold", NULL
15537 };
15538
15539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15541 if (!SWIG_IsOK(res1)) {
15542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15543 }
15544 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15545 ecode2 = SWIG_AsVal_int(obj1, &val2);
15546 if (!SWIG_IsOK(ecode2)) {
15547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15548 }
15549 arg2 = static_cast< int >(val2);
15550 {
15551 PyThreadState* __tstate = wxPyBeginAllowThreads();
15552 (arg1)->SetMovementThreshold(arg2);
15553 wxPyEndAllowThreads(__tstate);
15554 if (PyErr_Occurred()) SWIG_fail;
15555 }
15556 resultobj = SWIG_Py_Void();
15557 return resultobj;
15558 fail:
15559 return NULL;
15560 }
15561
15562
15563 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15564 PyObject *resultobj = 0;
15565 wxJoystick *arg1 = (wxJoystick *) 0 ;
15566 bool result;
15567 void *argp1 = 0 ;
15568 int res1 = 0 ;
15569 PyObject *swig_obj[1] ;
15570
15571 if (!args) SWIG_fail;
15572 swig_obj[0] = args;
15573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15574 if (!SWIG_IsOK(res1)) {
15575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15576 }
15577 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15578 {
15579 PyThreadState* __tstate = wxPyBeginAllowThreads();
15580 result = (bool)(arg1)->IsOk();
15581 wxPyEndAllowThreads(__tstate);
15582 if (PyErr_Occurred()) SWIG_fail;
15583 }
15584 {
15585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15586 }
15587 return resultobj;
15588 fail:
15589 return NULL;
15590 }
15591
15592
15593 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15594 PyObject *resultobj = 0;
15595 wxJoystick *arg1 = (wxJoystick *) 0 ;
15596 int result;
15597 void *argp1 = 0 ;
15598 int res1 = 0 ;
15599 PyObject *swig_obj[1] ;
15600
15601 if (!args) SWIG_fail;
15602 swig_obj[0] = args;
15603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15604 if (!SWIG_IsOK(res1)) {
15605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15606 }
15607 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15608 {
15609 PyThreadState* __tstate = wxPyBeginAllowThreads();
15610 result = (int)(arg1)->GetNumberJoysticks();
15611 wxPyEndAllowThreads(__tstate);
15612 if (PyErr_Occurred()) SWIG_fail;
15613 }
15614 resultobj = SWIG_From_int(static_cast< int >(result));
15615 return resultobj;
15616 fail:
15617 return NULL;
15618 }
15619
15620
15621 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15622 PyObject *resultobj = 0;
15623 wxJoystick *arg1 = (wxJoystick *) 0 ;
15624 int result;
15625 void *argp1 = 0 ;
15626 int res1 = 0 ;
15627 PyObject *swig_obj[1] ;
15628
15629 if (!args) SWIG_fail;
15630 swig_obj[0] = args;
15631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15632 if (!SWIG_IsOK(res1)) {
15633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15634 }
15635 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15636 {
15637 PyThreadState* __tstate = wxPyBeginAllowThreads();
15638 result = (int)(arg1)->GetManufacturerId();
15639 wxPyEndAllowThreads(__tstate);
15640 if (PyErr_Occurred()) SWIG_fail;
15641 }
15642 resultobj = SWIG_From_int(static_cast< int >(result));
15643 return resultobj;
15644 fail:
15645 return NULL;
15646 }
15647
15648
15649 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15650 PyObject *resultobj = 0;
15651 wxJoystick *arg1 = (wxJoystick *) 0 ;
15652 int result;
15653 void *argp1 = 0 ;
15654 int res1 = 0 ;
15655 PyObject *swig_obj[1] ;
15656
15657 if (!args) SWIG_fail;
15658 swig_obj[0] = args;
15659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15660 if (!SWIG_IsOK(res1)) {
15661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15662 }
15663 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15664 {
15665 PyThreadState* __tstate = wxPyBeginAllowThreads();
15666 result = (int)(arg1)->GetProductId();
15667 wxPyEndAllowThreads(__tstate);
15668 if (PyErr_Occurred()) SWIG_fail;
15669 }
15670 resultobj = SWIG_From_int(static_cast< int >(result));
15671 return resultobj;
15672 fail:
15673 return NULL;
15674 }
15675
15676
15677 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15678 PyObject *resultobj = 0;
15679 wxJoystick *arg1 = (wxJoystick *) 0 ;
15680 wxString result;
15681 void *argp1 = 0 ;
15682 int res1 = 0 ;
15683 PyObject *swig_obj[1] ;
15684
15685 if (!args) SWIG_fail;
15686 swig_obj[0] = args;
15687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15688 if (!SWIG_IsOK(res1)) {
15689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15690 }
15691 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15692 {
15693 PyThreadState* __tstate = wxPyBeginAllowThreads();
15694 result = (arg1)->GetProductName();
15695 wxPyEndAllowThreads(__tstate);
15696 if (PyErr_Occurred()) SWIG_fail;
15697 }
15698 {
15699 #if wxUSE_UNICODE
15700 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15701 #else
15702 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15703 #endif
15704 }
15705 return resultobj;
15706 fail:
15707 return NULL;
15708 }
15709
15710
15711 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15712 PyObject *resultobj = 0;
15713 wxJoystick *arg1 = (wxJoystick *) 0 ;
15714 int result;
15715 void *argp1 = 0 ;
15716 int res1 = 0 ;
15717 PyObject *swig_obj[1] ;
15718
15719 if (!args) SWIG_fail;
15720 swig_obj[0] = args;
15721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15722 if (!SWIG_IsOK(res1)) {
15723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15724 }
15725 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15726 {
15727 PyThreadState* __tstate = wxPyBeginAllowThreads();
15728 result = (int)(arg1)->GetXMin();
15729 wxPyEndAllowThreads(__tstate);
15730 if (PyErr_Occurred()) SWIG_fail;
15731 }
15732 resultobj = SWIG_From_int(static_cast< int >(result));
15733 return resultobj;
15734 fail:
15735 return NULL;
15736 }
15737
15738
15739 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15740 PyObject *resultobj = 0;
15741 wxJoystick *arg1 = (wxJoystick *) 0 ;
15742 int result;
15743 void *argp1 = 0 ;
15744 int res1 = 0 ;
15745 PyObject *swig_obj[1] ;
15746
15747 if (!args) SWIG_fail;
15748 swig_obj[0] = args;
15749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15750 if (!SWIG_IsOK(res1)) {
15751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15752 }
15753 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15754 {
15755 PyThreadState* __tstate = wxPyBeginAllowThreads();
15756 result = (int)(arg1)->GetYMin();
15757 wxPyEndAllowThreads(__tstate);
15758 if (PyErr_Occurred()) SWIG_fail;
15759 }
15760 resultobj = SWIG_From_int(static_cast< int >(result));
15761 return resultobj;
15762 fail:
15763 return NULL;
15764 }
15765
15766
15767 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15768 PyObject *resultobj = 0;
15769 wxJoystick *arg1 = (wxJoystick *) 0 ;
15770 int result;
15771 void *argp1 = 0 ;
15772 int res1 = 0 ;
15773 PyObject *swig_obj[1] ;
15774
15775 if (!args) SWIG_fail;
15776 swig_obj[0] = args;
15777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15778 if (!SWIG_IsOK(res1)) {
15779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15780 }
15781 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15782 {
15783 PyThreadState* __tstate = wxPyBeginAllowThreads();
15784 result = (int)(arg1)->GetZMin();
15785 wxPyEndAllowThreads(__tstate);
15786 if (PyErr_Occurred()) SWIG_fail;
15787 }
15788 resultobj = SWIG_From_int(static_cast< int >(result));
15789 return resultobj;
15790 fail:
15791 return NULL;
15792 }
15793
15794
15795 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15796 PyObject *resultobj = 0;
15797 wxJoystick *arg1 = (wxJoystick *) 0 ;
15798 int result;
15799 void *argp1 = 0 ;
15800 int res1 = 0 ;
15801 PyObject *swig_obj[1] ;
15802
15803 if (!args) SWIG_fail;
15804 swig_obj[0] = args;
15805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15806 if (!SWIG_IsOK(res1)) {
15807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15808 }
15809 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15810 {
15811 PyThreadState* __tstate = wxPyBeginAllowThreads();
15812 result = (int)(arg1)->GetXMax();
15813 wxPyEndAllowThreads(__tstate);
15814 if (PyErr_Occurred()) SWIG_fail;
15815 }
15816 resultobj = SWIG_From_int(static_cast< int >(result));
15817 return resultobj;
15818 fail:
15819 return NULL;
15820 }
15821
15822
15823 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15824 PyObject *resultobj = 0;
15825 wxJoystick *arg1 = (wxJoystick *) 0 ;
15826 int result;
15827 void *argp1 = 0 ;
15828 int res1 = 0 ;
15829 PyObject *swig_obj[1] ;
15830
15831 if (!args) SWIG_fail;
15832 swig_obj[0] = args;
15833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15834 if (!SWIG_IsOK(res1)) {
15835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15836 }
15837 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15838 {
15839 PyThreadState* __tstate = wxPyBeginAllowThreads();
15840 result = (int)(arg1)->GetYMax();
15841 wxPyEndAllowThreads(__tstate);
15842 if (PyErr_Occurred()) SWIG_fail;
15843 }
15844 resultobj = SWIG_From_int(static_cast< int >(result));
15845 return resultobj;
15846 fail:
15847 return NULL;
15848 }
15849
15850
15851 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15852 PyObject *resultobj = 0;
15853 wxJoystick *arg1 = (wxJoystick *) 0 ;
15854 int result;
15855 void *argp1 = 0 ;
15856 int res1 = 0 ;
15857 PyObject *swig_obj[1] ;
15858
15859 if (!args) SWIG_fail;
15860 swig_obj[0] = args;
15861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15862 if (!SWIG_IsOK(res1)) {
15863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15864 }
15865 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15866 {
15867 PyThreadState* __tstate = wxPyBeginAllowThreads();
15868 result = (int)(arg1)->GetZMax();
15869 wxPyEndAllowThreads(__tstate);
15870 if (PyErr_Occurred()) SWIG_fail;
15871 }
15872 resultobj = SWIG_From_int(static_cast< int >(result));
15873 return resultobj;
15874 fail:
15875 return NULL;
15876 }
15877
15878
15879 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15880 PyObject *resultobj = 0;
15881 wxJoystick *arg1 = (wxJoystick *) 0 ;
15882 int result;
15883 void *argp1 = 0 ;
15884 int res1 = 0 ;
15885 PyObject *swig_obj[1] ;
15886
15887 if (!args) SWIG_fail;
15888 swig_obj[0] = args;
15889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15890 if (!SWIG_IsOK(res1)) {
15891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15892 }
15893 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15894 {
15895 PyThreadState* __tstate = wxPyBeginAllowThreads();
15896 result = (int)(arg1)->GetNumberButtons();
15897 wxPyEndAllowThreads(__tstate);
15898 if (PyErr_Occurred()) SWIG_fail;
15899 }
15900 resultobj = SWIG_From_int(static_cast< int >(result));
15901 return resultobj;
15902 fail:
15903 return NULL;
15904 }
15905
15906
15907 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15908 PyObject *resultobj = 0;
15909 wxJoystick *arg1 = (wxJoystick *) 0 ;
15910 int result;
15911 void *argp1 = 0 ;
15912 int res1 = 0 ;
15913 PyObject *swig_obj[1] ;
15914
15915 if (!args) SWIG_fail;
15916 swig_obj[0] = args;
15917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15918 if (!SWIG_IsOK(res1)) {
15919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15920 }
15921 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15922 {
15923 PyThreadState* __tstate = wxPyBeginAllowThreads();
15924 result = (int)(arg1)->GetNumberAxes();
15925 wxPyEndAllowThreads(__tstate);
15926 if (PyErr_Occurred()) SWIG_fail;
15927 }
15928 resultobj = SWIG_From_int(static_cast< int >(result));
15929 return resultobj;
15930 fail:
15931 return NULL;
15932 }
15933
15934
15935 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15936 PyObject *resultobj = 0;
15937 wxJoystick *arg1 = (wxJoystick *) 0 ;
15938 int result;
15939 void *argp1 = 0 ;
15940 int res1 = 0 ;
15941 PyObject *swig_obj[1] ;
15942
15943 if (!args) SWIG_fail;
15944 swig_obj[0] = args;
15945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15946 if (!SWIG_IsOK(res1)) {
15947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15948 }
15949 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15950 {
15951 PyThreadState* __tstate = wxPyBeginAllowThreads();
15952 result = (int)(arg1)->GetMaxButtons();
15953 wxPyEndAllowThreads(__tstate);
15954 if (PyErr_Occurred()) SWIG_fail;
15955 }
15956 resultobj = SWIG_From_int(static_cast< int >(result));
15957 return resultobj;
15958 fail:
15959 return NULL;
15960 }
15961
15962
15963 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15964 PyObject *resultobj = 0;
15965 wxJoystick *arg1 = (wxJoystick *) 0 ;
15966 int result;
15967 void *argp1 = 0 ;
15968 int res1 = 0 ;
15969 PyObject *swig_obj[1] ;
15970
15971 if (!args) SWIG_fail;
15972 swig_obj[0] = args;
15973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15974 if (!SWIG_IsOK(res1)) {
15975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15976 }
15977 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15978 {
15979 PyThreadState* __tstate = wxPyBeginAllowThreads();
15980 result = (int)(arg1)->GetMaxAxes();
15981 wxPyEndAllowThreads(__tstate);
15982 if (PyErr_Occurred()) SWIG_fail;
15983 }
15984 resultobj = SWIG_From_int(static_cast< int >(result));
15985 return resultobj;
15986 fail:
15987 return NULL;
15988 }
15989
15990
15991 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15992 PyObject *resultobj = 0;
15993 wxJoystick *arg1 = (wxJoystick *) 0 ;
15994 int result;
15995 void *argp1 = 0 ;
15996 int res1 = 0 ;
15997 PyObject *swig_obj[1] ;
15998
15999 if (!args) SWIG_fail;
16000 swig_obj[0] = args;
16001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16002 if (!SWIG_IsOK(res1)) {
16003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16004 }
16005 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16006 {
16007 PyThreadState* __tstate = wxPyBeginAllowThreads();
16008 result = (int)(arg1)->GetPollingMin();
16009 wxPyEndAllowThreads(__tstate);
16010 if (PyErr_Occurred()) SWIG_fail;
16011 }
16012 resultobj = SWIG_From_int(static_cast< int >(result));
16013 return resultobj;
16014 fail:
16015 return NULL;
16016 }
16017
16018
16019 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16020 PyObject *resultobj = 0;
16021 wxJoystick *arg1 = (wxJoystick *) 0 ;
16022 int result;
16023 void *argp1 = 0 ;
16024 int res1 = 0 ;
16025 PyObject *swig_obj[1] ;
16026
16027 if (!args) SWIG_fail;
16028 swig_obj[0] = args;
16029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16030 if (!SWIG_IsOK(res1)) {
16031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16032 }
16033 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16034 {
16035 PyThreadState* __tstate = wxPyBeginAllowThreads();
16036 result = (int)(arg1)->GetPollingMax();
16037 wxPyEndAllowThreads(__tstate);
16038 if (PyErr_Occurred()) SWIG_fail;
16039 }
16040 resultobj = SWIG_From_int(static_cast< int >(result));
16041 return resultobj;
16042 fail:
16043 return NULL;
16044 }
16045
16046
16047 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16048 PyObject *resultobj = 0;
16049 wxJoystick *arg1 = (wxJoystick *) 0 ;
16050 int result;
16051 void *argp1 = 0 ;
16052 int res1 = 0 ;
16053 PyObject *swig_obj[1] ;
16054
16055 if (!args) SWIG_fail;
16056 swig_obj[0] = args;
16057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16058 if (!SWIG_IsOK(res1)) {
16059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16060 }
16061 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16062 {
16063 PyThreadState* __tstate = wxPyBeginAllowThreads();
16064 result = (int)(arg1)->GetRudderMin();
16065 wxPyEndAllowThreads(__tstate);
16066 if (PyErr_Occurred()) SWIG_fail;
16067 }
16068 resultobj = SWIG_From_int(static_cast< int >(result));
16069 return resultobj;
16070 fail:
16071 return NULL;
16072 }
16073
16074
16075 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16076 PyObject *resultobj = 0;
16077 wxJoystick *arg1 = (wxJoystick *) 0 ;
16078 int result;
16079 void *argp1 = 0 ;
16080 int res1 = 0 ;
16081 PyObject *swig_obj[1] ;
16082
16083 if (!args) SWIG_fail;
16084 swig_obj[0] = args;
16085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16086 if (!SWIG_IsOK(res1)) {
16087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16088 }
16089 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16090 {
16091 PyThreadState* __tstate = wxPyBeginAllowThreads();
16092 result = (int)(arg1)->GetRudderMax();
16093 wxPyEndAllowThreads(__tstate);
16094 if (PyErr_Occurred()) SWIG_fail;
16095 }
16096 resultobj = SWIG_From_int(static_cast< int >(result));
16097 return resultobj;
16098 fail:
16099 return NULL;
16100 }
16101
16102
16103 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16104 PyObject *resultobj = 0;
16105 wxJoystick *arg1 = (wxJoystick *) 0 ;
16106 int result;
16107 void *argp1 = 0 ;
16108 int res1 = 0 ;
16109 PyObject *swig_obj[1] ;
16110
16111 if (!args) SWIG_fail;
16112 swig_obj[0] = args;
16113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16114 if (!SWIG_IsOK(res1)) {
16115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16116 }
16117 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16118 {
16119 PyThreadState* __tstate = wxPyBeginAllowThreads();
16120 result = (int)(arg1)->GetUMin();
16121 wxPyEndAllowThreads(__tstate);
16122 if (PyErr_Occurred()) SWIG_fail;
16123 }
16124 resultobj = SWIG_From_int(static_cast< int >(result));
16125 return resultobj;
16126 fail:
16127 return NULL;
16128 }
16129
16130
16131 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16132 PyObject *resultobj = 0;
16133 wxJoystick *arg1 = (wxJoystick *) 0 ;
16134 int result;
16135 void *argp1 = 0 ;
16136 int res1 = 0 ;
16137 PyObject *swig_obj[1] ;
16138
16139 if (!args) SWIG_fail;
16140 swig_obj[0] = args;
16141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16142 if (!SWIG_IsOK(res1)) {
16143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16144 }
16145 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16146 {
16147 PyThreadState* __tstate = wxPyBeginAllowThreads();
16148 result = (int)(arg1)->GetUMax();
16149 wxPyEndAllowThreads(__tstate);
16150 if (PyErr_Occurred()) SWIG_fail;
16151 }
16152 resultobj = SWIG_From_int(static_cast< int >(result));
16153 return resultobj;
16154 fail:
16155 return NULL;
16156 }
16157
16158
16159 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16160 PyObject *resultobj = 0;
16161 wxJoystick *arg1 = (wxJoystick *) 0 ;
16162 int result;
16163 void *argp1 = 0 ;
16164 int res1 = 0 ;
16165 PyObject *swig_obj[1] ;
16166
16167 if (!args) SWIG_fail;
16168 swig_obj[0] = args;
16169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16170 if (!SWIG_IsOK(res1)) {
16171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16172 }
16173 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16174 {
16175 PyThreadState* __tstate = wxPyBeginAllowThreads();
16176 result = (int)(arg1)->GetVMin();
16177 wxPyEndAllowThreads(__tstate);
16178 if (PyErr_Occurred()) SWIG_fail;
16179 }
16180 resultobj = SWIG_From_int(static_cast< int >(result));
16181 return resultobj;
16182 fail:
16183 return NULL;
16184 }
16185
16186
16187 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16188 PyObject *resultobj = 0;
16189 wxJoystick *arg1 = (wxJoystick *) 0 ;
16190 int result;
16191 void *argp1 = 0 ;
16192 int res1 = 0 ;
16193 PyObject *swig_obj[1] ;
16194
16195 if (!args) SWIG_fail;
16196 swig_obj[0] = args;
16197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16198 if (!SWIG_IsOK(res1)) {
16199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16200 }
16201 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16202 {
16203 PyThreadState* __tstate = wxPyBeginAllowThreads();
16204 result = (int)(arg1)->GetVMax();
16205 wxPyEndAllowThreads(__tstate);
16206 if (PyErr_Occurred()) SWIG_fail;
16207 }
16208 resultobj = SWIG_From_int(static_cast< int >(result));
16209 return resultobj;
16210 fail:
16211 return NULL;
16212 }
16213
16214
16215 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16216 PyObject *resultobj = 0;
16217 wxJoystick *arg1 = (wxJoystick *) 0 ;
16218 bool result;
16219 void *argp1 = 0 ;
16220 int res1 = 0 ;
16221 PyObject *swig_obj[1] ;
16222
16223 if (!args) SWIG_fail;
16224 swig_obj[0] = args;
16225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16226 if (!SWIG_IsOK(res1)) {
16227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16228 }
16229 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16230 {
16231 PyThreadState* __tstate = wxPyBeginAllowThreads();
16232 result = (bool)(arg1)->HasRudder();
16233 wxPyEndAllowThreads(__tstate);
16234 if (PyErr_Occurred()) SWIG_fail;
16235 }
16236 {
16237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16238 }
16239 return resultobj;
16240 fail:
16241 return NULL;
16242 }
16243
16244
16245 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16246 PyObject *resultobj = 0;
16247 wxJoystick *arg1 = (wxJoystick *) 0 ;
16248 bool result;
16249 void *argp1 = 0 ;
16250 int res1 = 0 ;
16251 PyObject *swig_obj[1] ;
16252
16253 if (!args) SWIG_fail;
16254 swig_obj[0] = args;
16255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16256 if (!SWIG_IsOK(res1)) {
16257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16258 }
16259 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16260 {
16261 PyThreadState* __tstate = wxPyBeginAllowThreads();
16262 result = (bool)(arg1)->HasZ();
16263 wxPyEndAllowThreads(__tstate);
16264 if (PyErr_Occurred()) SWIG_fail;
16265 }
16266 {
16267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16268 }
16269 return resultobj;
16270 fail:
16271 return NULL;
16272 }
16273
16274
16275 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16276 PyObject *resultobj = 0;
16277 wxJoystick *arg1 = (wxJoystick *) 0 ;
16278 bool result;
16279 void *argp1 = 0 ;
16280 int res1 = 0 ;
16281 PyObject *swig_obj[1] ;
16282
16283 if (!args) SWIG_fail;
16284 swig_obj[0] = args;
16285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16286 if (!SWIG_IsOK(res1)) {
16287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16288 }
16289 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16290 {
16291 PyThreadState* __tstate = wxPyBeginAllowThreads();
16292 result = (bool)(arg1)->HasU();
16293 wxPyEndAllowThreads(__tstate);
16294 if (PyErr_Occurred()) SWIG_fail;
16295 }
16296 {
16297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16298 }
16299 return resultobj;
16300 fail:
16301 return NULL;
16302 }
16303
16304
16305 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16306 PyObject *resultobj = 0;
16307 wxJoystick *arg1 = (wxJoystick *) 0 ;
16308 bool result;
16309 void *argp1 = 0 ;
16310 int res1 = 0 ;
16311 PyObject *swig_obj[1] ;
16312
16313 if (!args) SWIG_fail;
16314 swig_obj[0] = args;
16315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16316 if (!SWIG_IsOK(res1)) {
16317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16318 }
16319 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16320 {
16321 PyThreadState* __tstate = wxPyBeginAllowThreads();
16322 result = (bool)(arg1)->HasV();
16323 wxPyEndAllowThreads(__tstate);
16324 if (PyErr_Occurred()) SWIG_fail;
16325 }
16326 {
16327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16328 }
16329 return resultobj;
16330 fail:
16331 return NULL;
16332 }
16333
16334
16335 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16336 PyObject *resultobj = 0;
16337 wxJoystick *arg1 = (wxJoystick *) 0 ;
16338 bool result;
16339 void *argp1 = 0 ;
16340 int res1 = 0 ;
16341 PyObject *swig_obj[1] ;
16342
16343 if (!args) SWIG_fail;
16344 swig_obj[0] = args;
16345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16346 if (!SWIG_IsOK(res1)) {
16347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16348 }
16349 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16350 {
16351 PyThreadState* __tstate = wxPyBeginAllowThreads();
16352 result = (bool)(arg1)->HasPOV();
16353 wxPyEndAllowThreads(__tstate);
16354 if (PyErr_Occurred()) SWIG_fail;
16355 }
16356 {
16357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16358 }
16359 return resultobj;
16360 fail:
16361 return NULL;
16362 }
16363
16364
16365 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16366 PyObject *resultobj = 0;
16367 wxJoystick *arg1 = (wxJoystick *) 0 ;
16368 bool 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_wxJoystick, 0 | 0 );
16376 if (!SWIG_IsOK(res1)) {
16377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16378 }
16379 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16380 {
16381 PyThreadState* __tstate = wxPyBeginAllowThreads();
16382 result = (bool)(arg1)->HasPOV4Dir();
16383 wxPyEndAllowThreads(__tstate);
16384 if (PyErr_Occurred()) SWIG_fail;
16385 }
16386 {
16387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16388 }
16389 return resultobj;
16390 fail:
16391 return NULL;
16392 }
16393
16394
16395 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16396 PyObject *resultobj = 0;
16397 wxJoystick *arg1 = (wxJoystick *) 0 ;
16398 bool result;
16399 void *argp1 = 0 ;
16400 int res1 = 0 ;
16401 PyObject *swig_obj[1] ;
16402
16403 if (!args) SWIG_fail;
16404 swig_obj[0] = args;
16405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16406 if (!SWIG_IsOK(res1)) {
16407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16408 }
16409 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16410 {
16411 PyThreadState* __tstate = wxPyBeginAllowThreads();
16412 result = (bool)(arg1)->HasPOVCTS();
16413 wxPyEndAllowThreads(__tstate);
16414 if (PyErr_Occurred()) SWIG_fail;
16415 }
16416 {
16417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16418 }
16419 return resultobj;
16420 fail:
16421 return NULL;
16422 }
16423
16424
16425 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16426 PyObject *resultobj = 0;
16427 wxJoystick *arg1 = (wxJoystick *) 0 ;
16428 wxWindow *arg2 = (wxWindow *) 0 ;
16429 int arg3 = (int) 0 ;
16430 bool result;
16431 void *argp1 = 0 ;
16432 int res1 = 0 ;
16433 void *argp2 = 0 ;
16434 int res2 = 0 ;
16435 int val3 ;
16436 int ecode3 = 0 ;
16437 PyObject * obj0 = 0 ;
16438 PyObject * obj1 = 0 ;
16439 PyObject * obj2 = 0 ;
16440 char * kwnames[] = {
16441 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16442 };
16443
16444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16446 if (!SWIG_IsOK(res1)) {
16447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16448 }
16449 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16450 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16451 if (!SWIG_IsOK(res2)) {
16452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16453 }
16454 arg2 = reinterpret_cast< wxWindow * >(argp2);
16455 if (obj2) {
16456 ecode3 = SWIG_AsVal_int(obj2, &val3);
16457 if (!SWIG_IsOK(ecode3)) {
16458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16459 }
16460 arg3 = static_cast< int >(val3);
16461 }
16462 {
16463 PyThreadState* __tstate = wxPyBeginAllowThreads();
16464 result = (bool)(arg1)->SetCapture(arg2,arg3);
16465 wxPyEndAllowThreads(__tstate);
16466 if (PyErr_Occurred()) SWIG_fail;
16467 }
16468 {
16469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16470 }
16471 return resultobj;
16472 fail:
16473 return NULL;
16474 }
16475
16476
16477 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16478 PyObject *resultobj = 0;
16479 wxJoystick *arg1 = (wxJoystick *) 0 ;
16480 bool 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_wxJoystick, 0 | 0 );
16488 if (!SWIG_IsOK(res1)) {
16489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16490 }
16491 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16492 {
16493 PyThreadState* __tstate = wxPyBeginAllowThreads();
16494 result = (bool)(arg1)->ReleaseCapture();
16495 wxPyEndAllowThreads(__tstate);
16496 if (PyErr_Occurred()) SWIG_fail;
16497 }
16498 {
16499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16500 }
16501 return resultobj;
16502 fail:
16503 return NULL;
16504 }
16505
16506
16507 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16508 PyObject *obj;
16509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16510 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16511 return SWIG_Py_Void();
16512 }
16513
16514 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16515 return SWIG_Python_InitShadowInstance(args);
16516 }
16517
16518 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16519 PyObject *resultobj = 0;
16520 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16521 int arg2 = (int) 0 ;
16522 int arg3 = (int) wxJOYSTICK1 ;
16523 int arg4 = (int) 0 ;
16524 wxJoystickEvent *result = 0 ;
16525 int val1 ;
16526 int ecode1 = 0 ;
16527 int val2 ;
16528 int ecode2 = 0 ;
16529 int val3 ;
16530 int ecode3 = 0 ;
16531 int val4 ;
16532 int ecode4 = 0 ;
16533 PyObject * obj0 = 0 ;
16534 PyObject * obj1 = 0 ;
16535 PyObject * obj2 = 0 ;
16536 PyObject * obj3 = 0 ;
16537 char * kwnames[] = {
16538 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16539 };
16540
16541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16542 if (obj0) {
16543 ecode1 = SWIG_AsVal_int(obj0, &val1);
16544 if (!SWIG_IsOK(ecode1)) {
16545 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16546 }
16547 arg1 = static_cast< wxEventType >(val1);
16548 }
16549 if (obj1) {
16550 ecode2 = SWIG_AsVal_int(obj1, &val2);
16551 if (!SWIG_IsOK(ecode2)) {
16552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16553 }
16554 arg2 = static_cast< int >(val2);
16555 }
16556 if (obj2) {
16557 ecode3 = SWIG_AsVal_int(obj2, &val3);
16558 if (!SWIG_IsOK(ecode3)) {
16559 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16560 }
16561 arg3 = static_cast< int >(val3);
16562 }
16563 if (obj3) {
16564 ecode4 = SWIG_AsVal_int(obj3, &val4);
16565 if (!SWIG_IsOK(ecode4)) {
16566 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16567 }
16568 arg4 = static_cast< int >(val4);
16569 }
16570 {
16571 PyThreadState* __tstate = wxPyBeginAllowThreads();
16572 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16573 wxPyEndAllowThreads(__tstate);
16574 if (PyErr_Occurred()) SWIG_fail;
16575 }
16576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16577 return resultobj;
16578 fail:
16579 return NULL;
16580 }
16581
16582
16583 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16584 PyObject *resultobj = 0;
16585 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16586 wxPoint result;
16587 void *argp1 = 0 ;
16588 int res1 = 0 ;
16589 PyObject *swig_obj[1] ;
16590
16591 if (!args) SWIG_fail;
16592 swig_obj[0] = args;
16593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16594 if (!SWIG_IsOK(res1)) {
16595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16596 }
16597 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16598 {
16599 PyThreadState* __tstate = wxPyBeginAllowThreads();
16600 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16601 wxPyEndAllowThreads(__tstate);
16602 if (PyErr_Occurred()) SWIG_fail;
16603 }
16604 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16605 return resultobj;
16606 fail:
16607 return NULL;
16608 }
16609
16610
16611 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16612 PyObject *resultobj = 0;
16613 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16614 int result;
16615 void *argp1 = 0 ;
16616 int res1 = 0 ;
16617 PyObject *swig_obj[1] ;
16618
16619 if (!args) SWIG_fail;
16620 swig_obj[0] = args;
16621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16622 if (!SWIG_IsOK(res1)) {
16623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16624 }
16625 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16626 {
16627 PyThreadState* __tstate = wxPyBeginAllowThreads();
16628 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16629 wxPyEndAllowThreads(__tstate);
16630 if (PyErr_Occurred()) SWIG_fail;
16631 }
16632 resultobj = SWIG_From_int(static_cast< int >(result));
16633 return resultobj;
16634 fail:
16635 return NULL;
16636 }
16637
16638
16639 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16640 PyObject *resultobj = 0;
16641 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16642 int result;
16643 void *argp1 = 0 ;
16644 int res1 = 0 ;
16645 PyObject *swig_obj[1] ;
16646
16647 if (!args) SWIG_fail;
16648 swig_obj[0] = args;
16649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16650 if (!SWIG_IsOK(res1)) {
16651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16652 }
16653 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16654 {
16655 PyThreadState* __tstate = wxPyBeginAllowThreads();
16656 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16657 wxPyEndAllowThreads(__tstate);
16658 if (PyErr_Occurred()) SWIG_fail;
16659 }
16660 resultobj = SWIG_From_int(static_cast< int >(result));
16661 return resultobj;
16662 fail:
16663 return NULL;
16664 }
16665
16666
16667 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16668 PyObject *resultobj = 0;
16669 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16670 int result;
16671 void *argp1 = 0 ;
16672 int res1 = 0 ;
16673 PyObject *swig_obj[1] ;
16674
16675 if (!args) SWIG_fail;
16676 swig_obj[0] = args;
16677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16678 if (!SWIG_IsOK(res1)) {
16679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16680 }
16681 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16682 {
16683 PyThreadState* __tstate = wxPyBeginAllowThreads();
16684 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16685 wxPyEndAllowThreads(__tstate);
16686 if (PyErr_Occurred()) SWIG_fail;
16687 }
16688 resultobj = SWIG_From_int(static_cast< int >(result));
16689 return resultobj;
16690 fail:
16691 return NULL;
16692 }
16693
16694
16695 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16696 PyObject *resultobj = 0;
16697 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16698 int result;
16699 void *argp1 = 0 ;
16700 int res1 = 0 ;
16701 PyObject *swig_obj[1] ;
16702
16703 if (!args) SWIG_fail;
16704 swig_obj[0] = args;
16705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16706 if (!SWIG_IsOK(res1)) {
16707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16708 }
16709 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16710 {
16711 PyThreadState* __tstate = wxPyBeginAllowThreads();
16712 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16713 wxPyEndAllowThreads(__tstate);
16714 if (PyErr_Occurred()) SWIG_fail;
16715 }
16716 resultobj = SWIG_From_int(static_cast< int >(result));
16717 return resultobj;
16718 fail:
16719 return NULL;
16720 }
16721
16722
16723 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16724 PyObject *resultobj = 0;
16725 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16726 int arg2 ;
16727 void *argp1 = 0 ;
16728 int res1 = 0 ;
16729 int val2 ;
16730 int ecode2 = 0 ;
16731 PyObject * obj0 = 0 ;
16732 PyObject * obj1 = 0 ;
16733 char * kwnames[] = {
16734 (char *) "self",(char *) "stick", NULL
16735 };
16736
16737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16739 if (!SWIG_IsOK(res1)) {
16740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16741 }
16742 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16743 ecode2 = SWIG_AsVal_int(obj1, &val2);
16744 if (!SWIG_IsOK(ecode2)) {
16745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16746 }
16747 arg2 = static_cast< int >(val2);
16748 {
16749 PyThreadState* __tstate = wxPyBeginAllowThreads();
16750 (arg1)->SetJoystick(arg2);
16751 wxPyEndAllowThreads(__tstate);
16752 if (PyErr_Occurred()) SWIG_fail;
16753 }
16754 resultobj = SWIG_Py_Void();
16755 return resultobj;
16756 fail:
16757 return NULL;
16758 }
16759
16760
16761 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16762 PyObject *resultobj = 0;
16763 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16764 int arg2 ;
16765 void *argp1 = 0 ;
16766 int res1 = 0 ;
16767 int val2 ;
16768 int ecode2 = 0 ;
16769 PyObject * obj0 = 0 ;
16770 PyObject * obj1 = 0 ;
16771 char * kwnames[] = {
16772 (char *) "self",(char *) "state", NULL
16773 };
16774
16775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16777 if (!SWIG_IsOK(res1)) {
16778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16779 }
16780 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16781 ecode2 = SWIG_AsVal_int(obj1, &val2);
16782 if (!SWIG_IsOK(ecode2)) {
16783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16784 }
16785 arg2 = static_cast< int >(val2);
16786 {
16787 PyThreadState* __tstate = wxPyBeginAllowThreads();
16788 (arg1)->SetButtonState(arg2);
16789 wxPyEndAllowThreads(__tstate);
16790 if (PyErr_Occurred()) SWIG_fail;
16791 }
16792 resultobj = SWIG_Py_Void();
16793 return resultobj;
16794 fail:
16795 return NULL;
16796 }
16797
16798
16799 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16800 PyObject *resultobj = 0;
16801 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16802 int arg2 ;
16803 void *argp1 = 0 ;
16804 int res1 = 0 ;
16805 int val2 ;
16806 int ecode2 = 0 ;
16807 PyObject * obj0 = 0 ;
16808 PyObject * obj1 = 0 ;
16809 char * kwnames[] = {
16810 (char *) "self",(char *) "change", NULL
16811 };
16812
16813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16815 if (!SWIG_IsOK(res1)) {
16816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16817 }
16818 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16819 ecode2 = SWIG_AsVal_int(obj1, &val2);
16820 if (!SWIG_IsOK(ecode2)) {
16821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16822 }
16823 arg2 = static_cast< int >(val2);
16824 {
16825 PyThreadState* __tstate = wxPyBeginAllowThreads();
16826 (arg1)->SetButtonChange(arg2);
16827 wxPyEndAllowThreads(__tstate);
16828 if (PyErr_Occurred()) SWIG_fail;
16829 }
16830 resultobj = SWIG_Py_Void();
16831 return resultobj;
16832 fail:
16833 return NULL;
16834 }
16835
16836
16837 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16838 PyObject *resultobj = 0;
16839 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16840 wxPoint *arg2 = 0 ;
16841 void *argp1 = 0 ;
16842 int res1 = 0 ;
16843 wxPoint temp2 ;
16844 PyObject * obj0 = 0 ;
16845 PyObject * obj1 = 0 ;
16846 char * kwnames[] = {
16847 (char *) "self",(char *) "pos", NULL
16848 };
16849
16850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16852 if (!SWIG_IsOK(res1)) {
16853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16854 }
16855 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16856 {
16857 arg2 = &temp2;
16858 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16859 }
16860 {
16861 PyThreadState* __tstate = wxPyBeginAllowThreads();
16862 (arg1)->SetPosition((wxPoint const &)*arg2);
16863 wxPyEndAllowThreads(__tstate);
16864 if (PyErr_Occurred()) SWIG_fail;
16865 }
16866 resultobj = SWIG_Py_Void();
16867 return resultobj;
16868 fail:
16869 return NULL;
16870 }
16871
16872
16873 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16874 PyObject *resultobj = 0;
16875 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16876 int arg2 ;
16877 void *argp1 = 0 ;
16878 int res1 = 0 ;
16879 int val2 ;
16880 int ecode2 = 0 ;
16881 PyObject * obj0 = 0 ;
16882 PyObject * obj1 = 0 ;
16883 char * kwnames[] = {
16884 (char *) "self",(char *) "zPos", NULL
16885 };
16886
16887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16889 if (!SWIG_IsOK(res1)) {
16890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16891 }
16892 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16893 ecode2 = SWIG_AsVal_int(obj1, &val2);
16894 if (!SWIG_IsOK(ecode2)) {
16895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16896 }
16897 arg2 = static_cast< int >(val2);
16898 {
16899 PyThreadState* __tstate = wxPyBeginAllowThreads();
16900 (arg1)->SetZPosition(arg2);
16901 wxPyEndAllowThreads(__tstate);
16902 if (PyErr_Occurred()) SWIG_fail;
16903 }
16904 resultobj = SWIG_Py_Void();
16905 return resultobj;
16906 fail:
16907 return NULL;
16908 }
16909
16910
16911 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16912 PyObject *resultobj = 0;
16913 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16914 bool result;
16915 void *argp1 = 0 ;
16916 int res1 = 0 ;
16917 PyObject *swig_obj[1] ;
16918
16919 if (!args) SWIG_fail;
16920 swig_obj[0] = args;
16921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16922 if (!SWIG_IsOK(res1)) {
16923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16924 }
16925 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16926 {
16927 PyThreadState* __tstate = wxPyBeginAllowThreads();
16928 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16929 wxPyEndAllowThreads(__tstate);
16930 if (PyErr_Occurred()) SWIG_fail;
16931 }
16932 {
16933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16934 }
16935 return resultobj;
16936 fail:
16937 return NULL;
16938 }
16939
16940
16941 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16942 PyObject *resultobj = 0;
16943 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16944 bool result;
16945 void *argp1 = 0 ;
16946 int res1 = 0 ;
16947 PyObject *swig_obj[1] ;
16948
16949 if (!args) SWIG_fail;
16950 swig_obj[0] = args;
16951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16952 if (!SWIG_IsOK(res1)) {
16953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16954 }
16955 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16956 {
16957 PyThreadState* __tstate = wxPyBeginAllowThreads();
16958 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16959 wxPyEndAllowThreads(__tstate);
16960 if (PyErr_Occurred()) SWIG_fail;
16961 }
16962 {
16963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16964 }
16965 return resultobj;
16966 fail:
16967 return NULL;
16968 }
16969
16970
16971 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16972 PyObject *resultobj = 0;
16973 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16974 bool result;
16975 void *argp1 = 0 ;
16976 int res1 = 0 ;
16977 PyObject *swig_obj[1] ;
16978
16979 if (!args) SWIG_fail;
16980 swig_obj[0] = args;
16981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16982 if (!SWIG_IsOK(res1)) {
16983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16984 }
16985 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16986 {
16987 PyThreadState* __tstate = wxPyBeginAllowThreads();
16988 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16989 wxPyEndAllowThreads(__tstate);
16990 if (PyErr_Occurred()) SWIG_fail;
16991 }
16992 {
16993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16994 }
16995 return resultobj;
16996 fail:
16997 return NULL;
16998 }
16999
17000
17001 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17002 PyObject *resultobj = 0;
17003 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17004 int arg2 = (int) wxJOY_BUTTON_ANY ;
17005 bool result;
17006 void *argp1 = 0 ;
17007 int res1 = 0 ;
17008 int val2 ;
17009 int ecode2 = 0 ;
17010 PyObject * obj0 = 0 ;
17011 PyObject * obj1 = 0 ;
17012 char * kwnames[] = {
17013 (char *) "self",(char *) "but", NULL
17014 };
17015
17016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
17017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17018 if (!SWIG_IsOK(res1)) {
17019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17020 }
17021 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17022 if (obj1) {
17023 ecode2 = SWIG_AsVal_int(obj1, &val2);
17024 if (!SWIG_IsOK(ecode2)) {
17025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17026 }
17027 arg2 = static_cast< int >(val2);
17028 }
17029 {
17030 PyThreadState* __tstate = wxPyBeginAllowThreads();
17031 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17032 wxPyEndAllowThreads(__tstate);
17033 if (PyErr_Occurred()) SWIG_fail;
17034 }
17035 {
17036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17037 }
17038 return resultobj;
17039 fail:
17040 return NULL;
17041 }
17042
17043
17044 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17045 PyObject *resultobj = 0;
17046 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17047 int arg2 = (int) wxJOY_BUTTON_ANY ;
17048 bool result;
17049 void *argp1 = 0 ;
17050 int res1 = 0 ;
17051 int val2 ;
17052 int ecode2 = 0 ;
17053 PyObject * obj0 = 0 ;
17054 PyObject * obj1 = 0 ;
17055 char * kwnames[] = {
17056 (char *) "self",(char *) "but", NULL
17057 };
17058
17059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17061 if (!SWIG_IsOK(res1)) {
17062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17063 }
17064 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17065 if (obj1) {
17066 ecode2 = SWIG_AsVal_int(obj1, &val2);
17067 if (!SWIG_IsOK(ecode2)) {
17068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17069 }
17070 arg2 = static_cast< int >(val2);
17071 }
17072 {
17073 PyThreadState* __tstate = wxPyBeginAllowThreads();
17074 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17075 wxPyEndAllowThreads(__tstate);
17076 if (PyErr_Occurred()) SWIG_fail;
17077 }
17078 {
17079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17080 }
17081 return resultobj;
17082 fail:
17083 return NULL;
17084 }
17085
17086
17087 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17088 PyObject *resultobj = 0;
17089 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17090 int arg2 = (int) wxJOY_BUTTON_ANY ;
17091 bool result;
17092 void *argp1 = 0 ;
17093 int res1 = 0 ;
17094 int val2 ;
17095 int ecode2 = 0 ;
17096 PyObject * obj0 = 0 ;
17097 PyObject * obj1 = 0 ;
17098 char * kwnames[] = {
17099 (char *) "self",(char *) "but", NULL
17100 };
17101
17102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17104 if (!SWIG_IsOK(res1)) {
17105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17106 }
17107 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17108 if (obj1) {
17109 ecode2 = SWIG_AsVal_int(obj1, &val2);
17110 if (!SWIG_IsOK(ecode2)) {
17111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17112 }
17113 arg2 = static_cast< int >(val2);
17114 }
17115 {
17116 PyThreadState* __tstate = wxPyBeginAllowThreads();
17117 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
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 *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17131 PyObject *obj;
17132 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17133 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17134 return SWIG_Py_Void();
17135 }
17136
17137 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17138 return SWIG_Python_InitShadowInstance(args);
17139 }
17140
17141 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17142 PyObject *resultobj = 0;
17143 wxString const &arg1_defvalue = wxPyEmptyString ;
17144 wxString *arg1 = (wxString *) &arg1_defvalue ;
17145 wxSound *result = 0 ;
17146 bool temp1 = false ;
17147 PyObject * obj0 = 0 ;
17148 char * kwnames[] = {
17149 (char *) "fileName", NULL
17150 };
17151
17152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17153 if (obj0) {
17154 {
17155 arg1 = wxString_in_helper(obj0);
17156 if (arg1 == NULL) SWIG_fail;
17157 temp1 = true;
17158 }
17159 }
17160 {
17161 if (!wxPyCheckForApp()) SWIG_fail;
17162 PyThreadState* __tstate = wxPyBeginAllowThreads();
17163 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17164 wxPyEndAllowThreads(__tstate);
17165 if (PyErr_Occurred()) SWIG_fail;
17166 }
17167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17168 {
17169 if (temp1)
17170 delete arg1;
17171 }
17172 return resultobj;
17173 fail:
17174 {
17175 if (temp1)
17176 delete arg1;
17177 }
17178 return NULL;
17179 }
17180
17181
17182 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17183 PyObject *resultobj = 0;
17184 PyObject *arg1 = (PyObject *) 0 ;
17185 wxSound *result = 0 ;
17186 PyObject * obj0 = 0 ;
17187 char * kwnames[] = {
17188 (char *) "data", NULL
17189 };
17190
17191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17192 arg1 = obj0;
17193 {
17194 if (!wxPyCheckForApp()) SWIG_fail;
17195 PyThreadState* __tstate = wxPyBeginAllowThreads();
17196 result = (wxSound *)new_wxSound(arg1);
17197 wxPyEndAllowThreads(__tstate);
17198 if (PyErr_Occurred()) SWIG_fail;
17199 }
17200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17201 return resultobj;
17202 fail:
17203 return NULL;
17204 }
17205
17206
17207 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17208 PyObject *resultobj = 0;
17209 wxSound *arg1 = (wxSound *) 0 ;
17210 void *argp1 = 0 ;
17211 int res1 = 0 ;
17212 PyObject *swig_obj[1] ;
17213
17214 if (!args) SWIG_fail;
17215 swig_obj[0] = args;
17216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17217 if (!SWIG_IsOK(res1)) {
17218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17219 }
17220 arg1 = reinterpret_cast< wxSound * >(argp1);
17221 {
17222 PyThreadState* __tstate = wxPyBeginAllowThreads();
17223 delete arg1;
17224
17225 wxPyEndAllowThreads(__tstate);
17226 if (PyErr_Occurred()) SWIG_fail;
17227 }
17228 resultobj = SWIG_Py_Void();
17229 return resultobj;
17230 fail:
17231 return NULL;
17232 }
17233
17234
17235 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17236 PyObject *resultobj = 0;
17237 wxSound *arg1 = (wxSound *) 0 ;
17238 wxString *arg2 = 0 ;
17239 bool result;
17240 void *argp1 = 0 ;
17241 int res1 = 0 ;
17242 bool temp2 = false ;
17243 PyObject * obj0 = 0 ;
17244 PyObject * obj1 = 0 ;
17245 char * kwnames[] = {
17246 (char *) "self",(char *) "fileName", NULL
17247 };
17248
17249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17251 if (!SWIG_IsOK(res1)) {
17252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17253 }
17254 arg1 = reinterpret_cast< wxSound * >(argp1);
17255 {
17256 arg2 = wxString_in_helper(obj1);
17257 if (arg2 == NULL) SWIG_fail;
17258 temp2 = true;
17259 }
17260 {
17261 PyThreadState* __tstate = wxPyBeginAllowThreads();
17262 result = (bool)(arg1)->Create((wxString const &)*arg2);
17263 wxPyEndAllowThreads(__tstate);
17264 if (PyErr_Occurred()) SWIG_fail;
17265 }
17266 {
17267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17268 }
17269 {
17270 if (temp2)
17271 delete arg2;
17272 }
17273 return resultobj;
17274 fail:
17275 {
17276 if (temp2)
17277 delete arg2;
17278 }
17279 return NULL;
17280 }
17281
17282
17283 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17284 PyObject *resultobj = 0;
17285 wxSound *arg1 = (wxSound *) 0 ;
17286 PyObject *arg2 = (PyObject *) 0 ;
17287 bool result;
17288 void *argp1 = 0 ;
17289 int res1 = 0 ;
17290 PyObject * obj0 = 0 ;
17291 PyObject * obj1 = 0 ;
17292 char * kwnames[] = {
17293 (char *) "self",(char *) "data", NULL
17294 };
17295
17296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17298 if (!SWIG_IsOK(res1)) {
17299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17300 }
17301 arg1 = reinterpret_cast< wxSound * >(argp1);
17302 arg2 = obj1;
17303 {
17304 PyThreadState* __tstate = wxPyBeginAllowThreads();
17305 result = (bool)wxSound_CreateFromData(arg1,arg2);
17306 wxPyEndAllowThreads(__tstate);
17307 if (PyErr_Occurred()) SWIG_fail;
17308 }
17309 {
17310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17311 }
17312 return resultobj;
17313 fail:
17314 return NULL;
17315 }
17316
17317
17318 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17319 PyObject *resultobj = 0;
17320 wxSound *arg1 = (wxSound *) 0 ;
17321 bool result;
17322 void *argp1 = 0 ;
17323 int res1 = 0 ;
17324 PyObject *swig_obj[1] ;
17325
17326 if (!args) SWIG_fail;
17327 swig_obj[0] = args;
17328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17329 if (!SWIG_IsOK(res1)) {
17330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17331 }
17332 arg1 = reinterpret_cast< wxSound * >(argp1);
17333 {
17334 PyThreadState* __tstate = wxPyBeginAllowThreads();
17335 result = (bool)(arg1)->IsOk();
17336 wxPyEndAllowThreads(__tstate);
17337 if (PyErr_Occurred()) SWIG_fail;
17338 }
17339 {
17340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17341 }
17342 return resultobj;
17343 fail:
17344 return NULL;
17345 }
17346
17347
17348 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17349 PyObject *resultobj = 0;
17350 wxSound *arg1 = (wxSound *) 0 ;
17351 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17352 bool result;
17353 void *argp1 = 0 ;
17354 int res1 = 0 ;
17355 unsigned int val2 ;
17356 int ecode2 = 0 ;
17357 PyObject * obj0 = 0 ;
17358 PyObject * obj1 = 0 ;
17359 char * kwnames[] = {
17360 (char *) "self",(char *) "flags", NULL
17361 };
17362
17363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17365 if (!SWIG_IsOK(res1)) {
17366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17367 }
17368 arg1 = reinterpret_cast< wxSound * >(argp1);
17369 if (obj1) {
17370 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17371 if (!SWIG_IsOK(ecode2)) {
17372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17373 }
17374 arg2 = static_cast< unsigned int >(val2);
17375 }
17376 {
17377 if (!wxPyCheckForApp()) SWIG_fail;
17378 PyThreadState* __tstate = wxPyBeginAllowThreads();
17379 result = (bool)((wxSound const *)arg1)->Play(arg2);
17380 wxPyEndAllowThreads(__tstate);
17381 if (PyErr_Occurred()) SWIG_fail;
17382 }
17383 {
17384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17385 }
17386 return resultobj;
17387 fail:
17388 return NULL;
17389 }
17390
17391
17392 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17393 PyObject *resultobj = 0;
17394 wxString *arg1 = 0 ;
17395 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17396 bool result;
17397 bool temp1 = false ;
17398 unsigned int val2 ;
17399 int ecode2 = 0 ;
17400 PyObject * obj0 = 0 ;
17401 PyObject * obj1 = 0 ;
17402 char * kwnames[] = {
17403 (char *) "filename",(char *) "flags", NULL
17404 };
17405
17406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17407 {
17408 arg1 = wxString_in_helper(obj0);
17409 if (arg1 == NULL) SWIG_fail;
17410 temp1 = true;
17411 }
17412 if (obj1) {
17413 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17414 if (!SWIG_IsOK(ecode2)) {
17415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17416 }
17417 arg2 = static_cast< unsigned int >(val2);
17418 }
17419 {
17420 if (!wxPyCheckForApp()) SWIG_fail;
17421 PyThreadState* __tstate = wxPyBeginAllowThreads();
17422 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17423 wxPyEndAllowThreads(__tstate);
17424 if (PyErr_Occurred()) SWIG_fail;
17425 }
17426 {
17427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17428 }
17429 {
17430 if (temp1)
17431 delete arg1;
17432 }
17433 return resultobj;
17434 fail:
17435 {
17436 if (temp1)
17437 delete arg1;
17438 }
17439 return NULL;
17440 }
17441
17442
17443 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17444 PyObject *resultobj = 0;
17445
17446 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17447 {
17448 if (!wxPyCheckForApp()) SWIG_fail;
17449 PyThreadState* __tstate = wxPyBeginAllowThreads();
17450 wxSound::Stop();
17451 wxPyEndAllowThreads(__tstate);
17452 if (PyErr_Occurred()) SWIG_fail;
17453 }
17454 resultobj = SWIG_Py_Void();
17455 return resultobj;
17456 fail:
17457 return NULL;
17458 }
17459
17460
17461 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17462 PyObject *obj;
17463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17464 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17465 return SWIG_Py_Void();
17466 }
17467
17468 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17469 return SWIG_Python_InitShadowInstance(args);
17470 }
17471
17472 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17473 PyObject *resultobj = 0;
17474 wxString *arg1 = 0 ;
17475 wxString *arg2 = 0 ;
17476 wxString *arg3 = 0 ;
17477 wxString *arg4 = 0 ;
17478 wxFileTypeInfo *result = 0 ;
17479 bool temp1 = false ;
17480 bool temp2 = false ;
17481 bool temp3 = false ;
17482 bool temp4 = false ;
17483 PyObject * obj0 = 0 ;
17484 PyObject * obj1 = 0 ;
17485 PyObject * obj2 = 0 ;
17486 PyObject * obj3 = 0 ;
17487 char * kwnames[] = {
17488 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17489 };
17490
17491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17492 {
17493 arg1 = wxString_in_helper(obj0);
17494 if (arg1 == NULL) SWIG_fail;
17495 temp1 = true;
17496 }
17497 {
17498 arg2 = wxString_in_helper(obj1);
17499 if (arg2 == NULL) SWIG_fail;
17500 temp2 = true;
17501 }
17502 {
17503 arg3 = wxString_in_helper(obj2);
17504 if (arg3 == NULL) SWIG_fail;
17505 temp3 = true;
17506 }
17507 {
17508 arg4 = wxString_in_helper(obj3);
17509 if (arg4 == NULL) SWIG_fail;
17510 temp4 = true;
17511 }
17512 {
17513 PyThreadState* __tstate = wxPyBeginAllowThreads();
17514 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17515 wxPyEndAllowThreads(__tstate);
17516 if (PyErr_Occurred()) SWIG_fail;
17517 }
17518 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17519 {
17520 if (temp1)
17521 delete arg1;
17522 }
17523 {
17524 if (temp2)
17525 delete arg2;
17526 }
17527 {
17528 if (temp3)
17529 delete arg3;
17530 }
17531 {
17532 if (temp4)
17533 delete arg4;
17534 }
17535 return resultobj;
17536 fail:
17537 {
17538 if (temp1)
17539 delete arg1;
17540 }
17541 {
17542 if (temp2)
17543 delete arg2;
17544 }
17545 {
17546 if (temp3)
17547 delete arg3;
17548 }
17549 {
17550 if (temp4)
17551 delete arg4;
17552 }
17553 return NULL;
17554 }
17555
17556
17557 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17558 PyObject *resultobj = 0;
17559 wxArrayString *arg1 = 0 ;
17560 wxFileTypeInfo *result = 0 ;
17561 bool temp1 = false ;
17562 PyObject * obj0 = 0 ;
17563 char * kwnames[] = {
17564 (char *) "sArray", NULL
17565 };
17566
17567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17568 {
17569 if (! PySequence_Check(obj0)) {
17570 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17571 SWIG_fail;
17572 }
17573 arg1 = new wxArrayString;
17574 temp1 = true;
17575 int i, len=PySequence_Length(obj0);
17576 for (i=0; i<len; i++) {
17577 PyObject* item = PySequence_GetItem(obj0, i);
17578 wxString* s = wxString_in_helper(item);
17579 if (PyErr_Occurred()) SWIG_fail;
17580 arg1->Add(*s);
17581 delete s;
17582 Py_DECREF(item);
17583 }
17584 }
17585 {
17586 PyThreadState* __tstate = wxPyBeginAllowThreads();
17587 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17588 wxPyEndAllowThreads(__tstate);
17589 if (PyErr_Occurred()) SWIG_fail;
17590 }
17591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17592 {
17593 if (temp1) delete arg1;
17594 }
17595 return resultobj;
17596 fail:
17597 {
17598 if (temp1) delete arg1;
17599 }
17600 return NULL;
17601 }
17602
17603
17604 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17605 PyObject *resultobj = 0;
17606 wxFileTypeInfo *result = 0 ;
17607
17608 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17609 {
17610 PyThreadState* __tstate = wxPyBeginAllowThreads();
17611 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17612 wxPyEndAllowThreads(__tstate);
17613 if (PyErr_Occurred()) SWIG_fail;
17614 }
17615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17616 return resultobj;
17617 fail:
17618 return NULL;
17619 }
17620
17621
17622 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17623 PyObject *resultobj = 0;
17624 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17625 bool result;
17626 void *argp1 = 0 ;
17627 int res1 = 0 ;
17628 PyObject *swig_obj[1] ;
17629
17630 if (!args) SWIG_fail;
17631 swig_obj[0] = args;
17632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17633 if (!SWIG_IsOK(res1)) {
17634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17635 }
17636 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17637 {
17638 PyThreadState* __tstate = wxPyBeginAllowThreads();
17639 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17640 wxPyEndAllowThreads(__tstate);
17641 if (PyErr_Occurred()) SWIG_fail;
17642 }
17643 {
17644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17645 }
17646 return resultobj;
17647 fail:
17648 return NULL;
17649 }
17650
17651
17652 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17653 PyObject *resultobj = 0;
17654 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17655 wxString *arg2 = 0 ;
17656 int arg3 = (int) 0 ;
17657 void *argp1 = 0 ;
17658 int res1 = 0 ;
17659 bool temp2 = false ;
17660 int val3 ;
17661 int ecode3 = 0 ;
17662 PyObject * obj0 = 0 ;
17663 PyObject * obj1 = 0 ;
17664 PyObject * obj2 = 0 ;
17665 char * kwnames[] = {
17666 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17667 };
17668
17669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17671 if (!SWIG_IsOK(res1)) {
17672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17673 }
17674 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17675 {
17676 arg2 = wxString_in_helper(obj1);
17677 if (arg2 == NULL) SWIG_fail;
17678 temp2 = true;
17679 }
17680 if (obj2) {
17681 ecode3 = SWIG_AsVal_int(obj2, &val3);
17682 if (!SWIG_IsOK(ecode3)) {
17683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17684 }
17685 arg3 = static_cast< int >(val3);
17686 }
17687 {
17688 PyThreadState* __tstate = wxPyBeginAllowThreads();
17689 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17690 wxPyEndAllowThreads(__tstate);
17691 if (PyErr_Occurred()) SWIG_fail;
17692 }
17693 resultobj = SWIG_Py_Void();
17694 {
17695 if (temp2)
17696 delete arg2;
17697 }
17698 return resultobj;
17699 fail:
17700 {
17701 if (temp2)
17702 delete arg2;
17703 }
17704 return NULL;
17705 }
17706
17707
17708 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17709 PyObject *resultobj = 0;
17710 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17711 wxString *arg2 = 0 ;
17712 void *argp1 = 0 ;
17713 int res1 = 0 ;
17714 bool temp2 = false ;
17715 PyObject * obj0 = 0 ;
17716 PyObject * obj1 = 0 ;
17717 char * kwnames[] = {
17718 (char *) "self",(char *) "shortDesc", NULL
17719 };
17720
17721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17723 if (!SWIG_IsOK(res1)) {
17724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17725 }
17726 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17727 {
17728 arg2 = wxString_in_helper(obj1);
17729 if (arg2 == NULL) SWIG_fail;
17730 temp2 = true;
17731 }
17732 {
17733 PyThreadState* __tstate = wxPyBeginAllowThreads();
17734 (arg1)->SetShortDesc((wxString const &)*arg2);
17735 wxPyEndAllowThreads(__tstate);
17736 if (PyErr_Occurred()) SWIG_fail;
17737 }
17738 resultobj = SWIG_Py_Void();
17739 {
17740 if (temp2)
17741 delete arg2;
17742 }
17743 return resultobj;
17744 fail:
17745 {
17746 if (temp2)
17747 delete arg2;
17748 }
17749 return NULL;
17750 }
17751
17752
17753 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17754 PyObject *resultobj = 0;
17755 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17756 wxString *result = 0 ;
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_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17766 }
17767 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17768 {
17769 PyThreadState* __tstate = wxPyBeginAllowThreads();
17770 {
17771 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17772 result = (wxString *) &_result_ref;
17773 }
17774 wxPyEndAllowThreads(__tstate);
17775 if (PyErr_Occurred()) SWIG_fail;
17776 }
17777 {
17778 #if wxUSE_UNICODE
17779 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17780 #else
17781 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17782 #endif
17783 }
17784 return resultobj;
17785 fail:
17786 return NULL;
17787 }
17788
17789
17790 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17791 PyObject *resultobj = 0;
17792 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17793 wxString *result = 0 ;
17794 void *argp1 = 0 ;
17795 int res1 = 0 ;
17796 PyObject *swig_obj[1] ;
17797
17798 if (!args) SWIG_fail;
17799 swig_obj[0] = args;
17800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17801 if (!SWIG_IsOK(res1)) {
17802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17803 }
17804 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17805 {
17806 PyThreadState* __tstate = wxPyBeginAllowThreads();
17807 {
17808 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17809 result = (wxString *) &_result_ref;
17810 }
17811 wxPyEndAllowThreads(__tstate);
17812 if (PyErr_Occurred()) SWIG_fail;
17813 }
17814 {
17815 #if wxUSE_UNICODE
17816 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17817 #else
17818 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17819 #endif
17820 }
17821 return resultobj;
17822 fail:
17823 return NULL;
17824 }
17825
17826
17827 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17828 PyObject *resultobj = 0;
17829 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17830 wxString *result = 0 ;
17831 void *argp1 = 0 ;
17832 int res1 = 0 ;
17833 PyObject *swig_obj[1] ;
17834
17835 if (!args) SWIG_fail;
17836 swig_obj[0] = args;
17837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17838 if (!SWIG_IsOK(res1)) {
17839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17840 }
17841 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17842 {
17843 PyThreadState* __tstate = wxPyBeginAllowThreads();
17844 {
17845 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17846 result = (wxString *) &_result_ref;
17847 }
17848 wxPyEndAllowThreads(__tstate);
17849 if (PyErr_Occurred()) SWIG_fail;
17850 }
17851 {
17852 #if wxUSE_UNICODE
17853 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17854 #else
17855 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17856 #endif
17857 }
17858 return resultobj;
17859 fail:
17860 return NULL;
17861 }
17862
17863
17864 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17865 PyObject *resultobj = 0;
17866 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17867 wxString *result = 0 ;
17868 void *argp1 = 0 ;
17869 int res1 = 0 ;
17870 PyObject *swig_obj[1] ;
17871
17872 if (!args) SWIG_fail;
17873 swig_obj[0] = args;
17874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17875 if (!SWIG_IsOK(res1)) {
17876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17877 }
17878 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17879 {
17880 PyThreadState* __tstate = wxPyBeginAllowThreads();
17881 {
17882 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17883 result = (wxString *) &_result_ref;
17884 }
17885 wxPyEndAllowThreads(__tstate);
17886 if (PyErr_Occurred()) SWIG_fail;
17887 }
17888 {
17889 #if wxUSE_UNICODE
17890 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17891 #else
17892 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17893 #endif
17894 }
17895 return resultobj;
17896 fail:
17897 return NULL;
17898 }
17899
17900
17901 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17902 PyObject *resultobj = 0;
17903 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17904 wxString *result = 0 ;
17905 void *argp1 = 0 ;
17906 int res1 = 0 ;
17907 PyObject *swig_obj[1] ;
17908
17909 if (!args) SWIG_fail;
17910 swig_obj[0] = args;
17911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17912 if (!SWIG_IsOK(res1)) {
17913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17914 }
17915 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17916 {
17917 PyThreadState* __tstate = wxPyBeginAllowThreads();
17918 {
17919 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17920 result = (wxString *) &_result_ref;
17921 }
17922 wxPyEndAllowThreads(__tstate);
17923 if (PyErr_Occurred()) SWIG_fail;
17924 }
17925 {
17926 #if wxUSE_UNICODE
17927 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17928 #else
17929 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17930 #endif
17931 }
17932 return resultobj;
17933 fail:
17934 return NULL;
17935 }
17936
17937
17938 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17939 PyObject *resultobj = 0;
17940 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17941 wxArrayString *result = 0 ;
17942 void *argp1 = 0 ;
17943 int res1 = 0 ;
17944 PyObject *swig_obj[1] ;
17945
17946 if (!args) SWIG_fail;
17947 swig_obj[0] = args;
17948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17949 if (!SWIG_IsOK(res1)) {
17950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17951 }
17952 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17953 {
17954 PyThreadState* __tstate = wxPyBeginAllowThreads();
17955 {
17956 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17957 result = (wxArrayString *) &_result_ref;
17958 }
17959 wxPyEndAllowThreads(__tstate);
17960 if (PyErr_Occurred()) SWIG_fail;
17961 }
17962 {
17963 resultobj = wxArrayString2PyList_helper(*result);
17964 }
17965 return resultobj;
17966 fail:
17967 return NULL;
17968 }
17969
17970
17971 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17972 PyObject *resultobj = 0;
17973 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17974 size_t result;
17975 void *argp1 = 0 ;
17976 int res1 = 0 ;
17977 PyObject *swig_obj[1] ;
17978
17979 if (!args) SWIG_fail;
17980 swig_obj[0] = args;
17981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17982 if (!SWIG_IsOK(res1)) {
17983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17984 }
17985 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17986 {
17987 PyThreadState* __tstate = wxPyBeginAllowThreads();
17988 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17989 wxPyEndAllowThreads(__tstate);
17990 if (PyErr_Occurred()) SWIG_fail;
17991 }
17992 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17993 return resultobj;
17994 fail:
17995 return NULL;
17996 }
17997
17998
17999 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18000 PyObject *resultobj = 0;
18001 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18002 wxString *result = 0 ;
18003 void *argp1 = 0 ;
18004 int res1 = 0 ;
18005 PyObject *swig_obj[1] ;
18006
18007 if (!args) SWIG_fail;
18008 swig_obj[0] = args;
18009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18010 if (!SWIG_IsOK(res1)) {
18011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18012 }
18013 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18014 {
18015 PyThreadState* __tstate = wxPyBeginAllowThreads();
18016 {
18017 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
18018 result = (wxString *) &_result_ref;
18019 }
18020 wxPyEndAllowThreads(__tstate);
18021 if (PyErr_Occurred()) SWIG_fail;
18022 }
18023 {
18024 #if wxUSE_UNICODE
18025 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18026 #else
18027 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18028 #endif
18029 }
18030 return resultobj;
18031 fail:
18032 return NULL;
18033 }
18034
18035
18036 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18037 PyObject *resultobj = 0;
18038 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18039 int result;
18040 void *argp1 = 0 ;
18041 int res1 = 0 ;
18042 PyObject *swig_obj[1] ;
18043
18044 if (!args) SWIG_fail;
18045 swig_obj[0] = args;
18046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18047 if (!SWIG_IsOK(res1)) {
18048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18049 }
18050 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18051 {
18052 PyThreadState* __tstate = wxPyBeginAllowThreads();
18053 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18054 wxPyEndAllowThreads(__tstate);
18055 if (PyErr_Occurred()) SWIG_fail;
18056 }
18057 resultobj = SWIG_From_int(static_cast< int >(result));
18058 return resultobj;
18059 fail:
18060 return NULL;
18061 }
18062
18063
18064 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18065 PyObject *obj;
18066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18067 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18068 return SWIG_Py_Void();
18069 }
18070
18071 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18072 return SWIG_Python_InitShadowInstance(args);
18073 }
18074
18075 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18076 PyObject *resultobj = 0;
18077 wxFileTypeInfo *arg1 = 0 ;
18078 wxFileType *result = 0 ;
18079 void *argp1 = 0 ;
18080 int res1 = 0 ;
18081 PyObject * obj0 = 0 ;
18082 char * kwnames[] = {
18083 (char *) "ftInfo", NULL
18084 };
18085
18086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18087 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18088 if (!SWIG_IsOK(res1)) {
18089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18090 }
18091 if (!argp1) {
18092 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18093 }
18094 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18095 {
18096 PyThreadState* __tstate = wxPyBeginAllowThreads();
18097 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18098 wxPyEndAllowThreads(__tstate);
18099 if (PyErr_Occurred()) SWIG_fail;
18100 }
18101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18102 return resultobj;
18103 fail:
18104 return NULL;
18105 }
18106
18107
18108 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18109 PyObject *resultobj = 0;
18110 wxFileType *arg1 = (wxFileType *) 0 ;
18111 void *argp1 = 0 ;
18112 int res1 = 0 ;
18113 PyObject *swig_obj[1] ;
18114
18115 if (!args) SWIG_fail;
18116 swig_obj[0] = args;
18117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18118 if (!SWIG_IsOK(res1)) {
18119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18120 }
18121 arg1 = reinterpret_cast< wxFileType * >(argp1);
18122 {
18123 PyThreadState* __tstate = wxPyBeginAllowThreads();
18124 delete arg1;
18125
18126 wxPyEndAllowThreads(__tstate);
18127 if (PyErr_Occurred()) SWIG_fail;
18128 }
18129 resultobj = SWIG_Py_Void();
18130 return resultobj;
18131 fail:
18132 return NULL;
18133 }
18134
18135
18136 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18137 PyObject *resultobj = 0;
18138 wxFileType *arg1 = (wxFileType *) 0 ;
18139 PyObject *result = 0 ;
18140 void *argp1 = 0 ;
18141 int res1 = 0 ;
18142 PyObject *swig_obj[1] ;
18143
18144 if (!args) SWIG_fail;
18145 swig_obj[0] = args;
18146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18147 if (!SWIG_IsOK(res1)) {
18148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18149 }
18150 arg1 = reinterpret_cast< wxFileType * >(argp1);
18151 {
18152 PyThreadState* __tstate = wxPyBeginAllowThreads();
18153 result = (PyObject *)wxFileType_GetMimeType(arg1);
18154 wxPyEndAllowThreads(__tstate);
18155 if (PyErr_Occurred()) SWIG_fail;
18156 }
18157 resultobj = result;
18158 return resultobj;
18159 fail:
18160 return NULL;
18161 }
18162
18163
18164 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18165 PyObject *resultobj = 0;
18166 wxFileType *arg1 = (wxFileType *) 0 ;
18167 PyObject *result = 0 ;
18168 void *argp1 = 0 ;
18169 int res1 = 0 ;
18170 PyObject *swig_obj[1] ;
18171
18172 if (!args) SWIG_fail;
18173 swig_obj[0] = args;
18174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18175 if (!SWIG_IsOK(res1)) {
18176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18177 }
18178 arg1 = reinterpret_cast< wxFileType * >(argp1);
18179 {
18180 PyThreadState* __tstate = wxPyBeginAllowThreads();
18181 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18182 wxPyEndAllowThreads(__tstate);
18183 if (PyErr_Occurred()) SWIG_fail;
18184 }
18185 resultobj = result;
18186 return resultobj;
18187 fail:
18188 return NULL;
18189 }
18190
18191
18192 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18193 PyObject *resultobj = 0;
18194 wxFileType *arg1 = (wxFileType *) 0 ;
18195 PyObject *result = 0 ;
18196 void *argp1 = 0 ;
18197 int res1 = 0 ;
18198 PyObject *swig_obj[1] ;
18199
18200 if (!args) SWIG_fail;
18201 swig_obj[0] = args;
18202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18203 if (!SWIG_IsOK(res1)) {
18204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18205 }
18206 arg1 = reinterpret_cast< wxFileType * >(argp1);
18207 {
18208 PyThreadState* __tstate = wxPyBeginAllowThreads();
18209 result = (PyObject *)wxFileType_GetExtensions(arg1);
18210 wxPyEndAllowThreads(__tstate);
18211 if (PyErr_Occurred()) SWIG_fail;
18212 }
18213 resultobj = result;
18214 return resultobj;
18215 fail:
18216 return NULL;
18217 }
18218
18219
18220 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18221 PyObject *resultobj = 0;
18222 wxFileType *arg1 = (wxFileType *) 0 ;
18223 wxIcon *result = 0 ;
18224 void *argp1 = 0 ;
18225 int res1 = 0 ;
18226 PyObject *swig_obj[1] ;
18227
18228 if (!args) SWIG_fail;
18229 swig_obj[0] = args;
18230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18231 if (!SWIG_IsOK(res1)) {
18232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18233 }
18234 arg1 = reinterpret_cast< wxFileType * >(argp1);
18235 {
18236 PyThreadState* __tstate = wxPyBeginAllowThreads();
18237 result = (wxIcon *)wxFileType_GetIcon(arg1);
18238 wxPyEndAllowThreads(__tstate);
18239 if (PyErr_Occurred()) SWIG_fail;
18240 }
18241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18242 return resultobj;
18243 fail:
18244 return NULL;
18245 }
18246
18247
18248 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18249 PyObject *resultobj = 0;
18250 wxFileType *arg1 = (wxFileType *) 0 ;
18251 PyObject *result = 0 ;
18252 void *argp1 = 0 ;
18253 int res1 = 0 ;
18254 PyObject *swig_obj[1] ;
18255
18256 if (!args) SWIG_fail;
18257 swig_obj[0] = args;
18258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18259 if (!SWIG_IsOK(res1)) {
18260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18261 }
18262 arg1 = reinterpret_cast< wxFileType * >(argp1);
18263 {
18264 PyThreadState* __tstate = wxPyBeginAllowThreads();
18265 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18266 wxPyEndAllowThreads(__tstate);
18267 if (PyErr_Occurred()) SWIG_fail;
18268 }
18269 resultobj = result;
18270 return resultobj;
18271 fail:
18272 return NULL;
18273 }
18274
18275
18276 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18277 PyObject *resultobj = 0;
18278 wxFileType *arg1 = (wxFileType *) 0 ;
18279 PyObject *result = 0 ;
18280 void *argp1 = 0 ;
18281 int res1 = 0 ;
18282 PyObject *swig_obj[1] ;
18283
18284 if (!args) SWIG_fail;
18285 swig_obj[0] = args;
18286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18287 if (!SWIG_IsOK(res1)) {
18288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18289 }
18290 arg1 = reinterpret_cast< wxFileType * >(argp1);
18291 {
18292 PyThreadState* __tstate = wxPyBeginAllowThreads();
18293 result = (PyObject *)wxFileType_GetDescription(arg1);
18294 wxPyEndAllowThreads(__tstate);
18295 if (PyErr_Occurred()) SWIG_fail;
18296 }
18297 resultobj = result;
18298 return resultobj;
18299 fail:
18300 return NULL;
18301 }
18302
18303
18304 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18305 PyObject *resultobj = 0;
18306 wxFileType *arg1 = (wxFileType *) 0 ;
18307 wxString *arg2 = 0 ;
18308 wxString const &arg3_defvalue = wxPyEmptyString ;
18309 wxString *arg3 = (wxString *) &arg3_defvalue ;
18310 PyObject *result = 0 ;
18311 void *argp1 = 0 ;
18312 int res1 = 0 ;
18313 bool temp2 = false ;
18314 bool temp3 = false ;
18315 PyObject * obj0 = 0 ;
18316 PyObject * obj1 = 0 ;
18317 PyObject * obj2 = 0 ;
18318 char * kwnames[] = {
18319 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18320 };
18321
18322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18324 if (!SWIG_IsOK(res1)) {
18325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18326 }
18327 arg1 = reinterpret_cast< wxFileType * >(argp1);
18328 {
18329 arg2 = wxString_in_helper(obj1);
18330 if (arg2 == NULL) SWIG_fail;
18331 temp2 = true;
18332 }
18333 if (obj2) {
18334 {
18335 arg3 = wxString_in_helper(obj2);
18336 if (arg3 == NULL) SWIG_fail;
18337 temp3 = true;
18338 }
18339 }
18340 {
18341 PyThreadState* __tstate = wxPyBeginAllowThreads();
18342 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18343 wxPyEndAllowThreads(__tstate);
18344 if (PyErr_Occurred()) SWIG_fail;
18345 }
18346 resultobj = result;
18347 {
18348 if (temp2)
18349 delete arg2;
18350 }
18351 {
18352 if (temp3)
18353 delete arg3;
18354 }
18355 return resultobj;
18356 fail:
18357 {
18358 if (temp2)
18359 delete arg2;
18360 }
18361 {
18362 if (temp3)
18363 delete arg3;
18364 }
18365 return NULL;
18366 }
18367
18368
18369 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18370 PyObject *resultobj = 0;
18371 wxFileType *arg1 = (wxFileType *) 0 ;
18372 wxString *arg2 = 0 ;
18373 wxString const &arg3_defvalue = wxPyEmptyString ;
18374 wxString *arg3 = (wxString *) &arg3_defvalue ;
18375 PyObject *result = 0 ;
18376 void *argp1 = 0 ;
18377 int res1 = 0 ;
18378 bool temp2 = false ;
18379 bool temp3 = false ;
18380 PyObject * obj0 = 0 ;
18381 PyObject * obj1 = 0 ;
18382 PyObject * obj2 = 0 ;
18383 char * kwnames[] = {
18384 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18385 };
18386
18387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18389 if (!SWIG_IsOK(res1)) {
18390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18391 }
18392 arg1 = reinterpret_cast< wxFileType * >(argp1);
18393 {
18394 arg2 = wxString_in_helper(obj1);
18395 if (arg2 == NULL) SWIG_fail;
18396 temp2 = true;
18397 }
18398 if (obj2) {
18399 {
18400 arg3 = wxString_in_helper(obj2);
18401 if (arg3 == NULL) SWIG_fail;
18402 temp3 = true;
18403 }
18404 }
18405 {
18406 PyThreadState* __tstate = wxPyBeginAllowThreads();
18407 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18408 wxPyEndAllowThreads(__tstate);
18409 if (PyErr_Occurred()) SWIG_fail;
18410 }
18411 resultobj = result;
18412 {
18413 if (temp2)
18414 delete arg2;
18415 }
18416 {
18417 if (temp3)
18418 delete arg3;
18419 }
18420 return resultobj;
18421 fail:
18422 {
18423 if (temp2)
18424 delete arg2;
18425 }
18426 {
18427 if (temp3)
18428 delete arg3;
18429 }
18430 return NULL;
18431 }
18432
18433
18434 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18435 PyObject *resultobj = 0;
18436 wxFileType *arg1 = (wxFileType *) 0 ;
18437 wxString *arg2 = 0 ;
18438 wxString const &arg3_defvalue = wxPyEmptyString ;
18439 wxString *arg3 = (wxString *) &arg3_defvalue ;
18440 PyObject *result = 0 ;
18441 void *argp1 = 0 ;
18442 int res1 = 0 ;
18443 bool temp2 = false ;
18444 bool temp3 = false ;
18445 PyObject * obj0 = 0 ;
18446 PyObject * obj1 = 0 ;
18447 PyObject * obj2 = 0 ;
18448 char * kwnames[] = {
18449 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18450 };
18451
18452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18454 if (!SWIG_IsOK(res1)) {
18455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18456 }
18457 arg1 = reinterpret_cast< wxFileType * >(argp1);
18458 {
18459 arg2 = wxString_in_helper(obj1);
18460 if (arg2 == NULL) SWIG_fail;
18461 temp2 = true;
18462 }
18463 if (obj2) {
18464 {
18465 arg3 = wxString_in_helper(obj2);
18466 if (arg3 == NULL) SWIG_fail;
18467 temp3 = true;
18468 }
18469 }
18470 {
18471 PyThreadState* __tstate = wxPyBeginAllowThreads();
18472 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18473 wxPyEndAllowThreads(__tstate);
18474 if (PyErr_Occurred()) SWIG_fail;
18475 }
18476 resultobj = result;
18477 {
18478 if (temp2)
18479 delete arg2;
18480 }
18481 {
18482 if (temp3)
18483 delete arg3;
18484 }
18485 return resultobj;
18486 fail:
18487 {
18488 if (temp2)
18489 delete arg2;
18490 }
18491 {
18492 if (temp3)
18493 delete arg3;
18494 }
18495 return NULL;
18496 }
18497
18498
18499 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18500 PyObject *resultobj = 0;
18501 wxFileType *arg1 = (wxFileType *) 0 ;
18502 wxString *arg2 = 0 ;
18503 wxString *arg3 = 0 ;
18504 bool arg4 = (bool) true ;
18505 bool result;
18506 void *argp1 = 0 ;
18507 int res1 = 0 ;
18508 bool temp2 = false ;
18509 bool temp3 = false ;
18510 bool val4 ;
18511 int ecode4 = 0 ;
18512 PyObject * obj0 = 0 ;
18513 PyObject * obj1 = 0 ;
18514 PyObject * obj2 = 0 ;
18515 PyObject * obj3 = 0 ;
18516 char * kwnames[] = {
18517 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18518 };
18519
18520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18522 if (!SWIG_IsOK(res1)) {
18523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18524 }
18525 arg1 = reinterpret_cast< wxFileType * >(argp1);
18526 {
18527 arg2 = wxString_in_helper(obj1);
18528 if (arg2 == NULL) SWIG_fail;
18529 temp2 = true;
18530 }
18531 {
18532 arg3 = wxString_in_helper(obj2);
18533 if (arg3 == NULL) SWIG_fail;
18534 temp3 = true;
18535 }
18536 if (obj3) {
18537 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18538 if (!SWIG_IsOK(ecode4)) {
18539 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18540 }
18541 arg4 = static_cast< bool >(val4);
18542 }
18543 {
18544 PyThreadState* __tstate = wxPyBeginAllowThreads();
18545 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18546 wxPyEndAllowThreads(__tstate);
18547 if (PyErr_Occurred()) SWIG_fail;
18548 }
18549 {
18550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18551 }
18552 {
18553 if (temp2)
18554 delete arg2;
18555 }
18556 {
18557 if (temp3)
18558 delete arg3;
18559 }
18560 return resultobj;
18561 fail:
18562 {
18563 if (temp2)
18564 delete arg2;
18565 }
18566 {
18567 if (temp3)
18568 delete arg3;
18569 }
18570 return NULL;
18571 }
18572
18573
18574 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18575 PyObject *resultobj = 0;
18576 wxFileType *arg1 = (wxFileType *) 0 ;
18577 wxString const &arg2_defvalue = wxPyEmptyString ;
18578 wxString *arg2 = (wxString *) &arg2_defvalue ;
18579 int arg3 = (int) 0 ;
18580 bool result;
18581 void *argp1 = 0 ;
18582 int res1 = 0 ;
18583 bool temp2 = false ;
18584 int val3 ;
18585 int ecode3 = 0 ;
18586 PyObject * obj0 = 0 ;
18587 PyObject * obj1 = 0 ;
18588 PyObject * obj2 = 0 ;
18589 char * kwnames[] = {
18590 (char *) "self",(char *) "cmd",(char *) "index", NULL
18591 };
18592
18593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18595 if (!SWIG_IsOK(res1)) {
18596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18597 }
18598 arg1 = reinterpret_cast< wxFileType * >(argp1);
18599 if (obj1) {
18600 {
18601 arg2 = wxString_in_helper(obj1);
18602 if (arg2 == NULL) SWIG_fail;
18603 temp2 = true;
18604 }
18605 }
18606 if (obj2) {
18607 ecode3 = SWIG_AsVal_int(obj2, &val3);
18608 if (!SWIG_IsOK(ecode3)) {
18609 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18610 }
18611 arg3 = static_cast< int >(val3);
18612 }
18613 {
18614 PyThreadState* __tstate = wxPyBeginAllowThreads();
18615 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18616 wxPyEndAllowThreads(__tstate);
18617 if (PyErr_Occurred()) SWIG_fail;
18618 }
18619 {
18620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18621 }
18622 {
18623 if (temp2)
18624 delete arg2;
18625 }
18626 return resultobj;
18627 fail:
18628 {
18629 if (temp2)
18630 delete arg2;
18631 }
18632 return NULL;
18633 }
18634
18635
18636 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18637 PyObject *resultobj = 0;
18638 wxFileType *arg1 = (wxFileType *) 0 ;
18639 bool result;
18640 void *argp1 = 0 ;
18641 int res1 = 0 ;
18642 PyObject *swig_obj[1] ;
18643
18644 if (!args) SWIG_fail;
18645 swig_obj[0] = args;
18646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18647 if (!SWIG_IsOK(res1)) {
18648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18649 }
18650 arg1 = reinterpret_cast< wxFileType * >(argp1);
18651 {
18652 PyThreadState* __tstate = wxPyBeginAllowThreads();
18653 result = (bool)(arg1)->Unassociate();
18654 wxPyEndAllowThreads(__tstate);
18655 if (PyErr_Occurred()) SWIG_fail;
18656 }
18657 {
18658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18659 }
18660 return resultobj;
18661 fail:
18662 return NULL;
18663 }
18664
18665
18666 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18667 PyObject *resultobj = 0;
18668 wxString *arg1 = 0 ;
18669 wxString *arg2 = 0 ;
18670 wxString const &arg3_defvalue = wxPyEmptyString ;
18671 wxString *arg3 = (wxString *) &arg3_defvalue ;
18672 wxString result;
18673 bool temp1 = false ;
18674 bool temp2 = false ;
18675 bool temp3 = false ;
18676 PyObject * obj0 = 0 ;
18677 PyObject * obj1 = 0 ;
18678 PyObject * obj2 = 0 ;
18679 char * kwnames[] = {
18680 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18681 };
18682
18683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18684 {
18685 arg1 = wxString_in_helper(obj0);
18686 if (arg1 == NULL) SWIG_fail;
18687 temp1 = true;
18688 }
18689 {
18690 arg2 = wxString_in_helper(obj1);
18691 if (arg2 == NULL) SWIG_fail;
18692 temp2 = true;
18693 }
18694 if (obj2) {
18695 {
18696 arg3 = wxString_in_helper(obj2);
18697 if (arg3 == NULL) SWIG_fail;
18698 temp3 = true;
18699 }
18700 }
18701 {
18702 PyThreadState* __tstate = wxPyBeginAllowThreads();
18703 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18704 wxPyEndAllowThreads(__tstate);
18705 if (PyErr_Occurred()) SWIG_fail;
18706 }
18707 {
18708 #if wxUSE_UNICODE
18709 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18710 #else
18711 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18712 #endif
18713 }
18714 {
18715 if (temp1)
18716 delete arg1;
18717 }
18718 {
18719 if (temp2)
18720 delete arg2;
18721 }
18722 {
18723 if (temp3)
18724 delete arg3;
18725 }
18726 return resultobj;
18727 fail:
18728 {
18729 if (temp1)
18730 delete arg1;
18731 }
18732 {
18733 if (temp2)
18734 delete arg2;
18735 }
18736 {
18737 if (temp3)
18738 delete arg3;
18739 }
18740 return NULL;
18741 }
18742
18743
18744 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18745 PyObject *obj;
18746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18747 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18748 return SWIG_Py_Void();
18749 }
18750
18751 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18752 return SWIG_Python_InitShadowInstance(args);
18753 }
18754
18755 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18756 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18757 return 1;
18758 }
18759
18760
18761 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18762 PyObject *pyobj = 0;
18763
18764 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18765 return pyobj;
18766 }
18767
18768
18769 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18770 PyObject *resultobj = 0;
18771 wxString *arg1 = 0 ;
18772 wxString *arg2 = 0 ;
18773 bool result;
18774 bool temp1 = false ;
18775 bool temp2 = false ;
18776 PyObject * obj0 = 0 ;
18777 PyObject * obj1 = 0 ;
18778 char * kwnames[] = {
18779 (char *) "mimeType",(char *) "wildcard", NULL
18780 };
18781
18782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18783 {
18784 arg1 = wxString_in_helper(obj0);
18785 if (arg1 == NULL) SWIG_fail;
18786 temp1 = true;
18787 }
18788 {
18789 arg2 = wxString_in_helper(obj1);
18790 if (arg2 == NULL) SWIG_fail;
18791 temp2 = true;
18792 }
18793 {
18794 PyThreadState* __tstate = wxPyBeginAllowThreads();
18795 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18796 wxPyEndAllowThreads(__tstate);
18797 if (PyErr_Occurred()) SWIG_fail;
18798 }
18799 {
18800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18801 }
18802 {
18803 if (temp1)
18804 delete arg1;
18805 }
18806 {
18807 if (temp2)
18808 delete arg2;
18809 }
18810 return resultobj;
18811 fail:
18812 {
18813 if (temp1)
18814 delete arg1;
18815 }
18816 {
18817 if (temp2)
18818 delete arg2;
18819 }
18820 return NULL;
18821 }
18822
18823
18824 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18825 PyObject *resultobj = 0;
18826 wxMimeTypesManager *result = 0 ;
18827
18828 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18829 {
18830 PyThreadState* __tstate = wxPyBeginAllowThreads();
18831 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18832 wxPyEndAllowThreads(__tstate);
18833 if (PyErr_Occurred()) SWIG_fail;
18834 }
18835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18836 return resultobj;
18837 fail:
18838 return NULL;
18839 }
18840
18841
18842 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18843 PyObject *resultobj = 0;
18844 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18845 int arg2 = (int) wxMAILCAP_ALL ;
18846 wxString const &arg3_defvalue = wxPyEmptyString ;
18847 wxString *arg3 = (wxString *) &arg3_defvalue ;
18848 void *argp1 = 0 ;
18849 int res1 = 0 ;
18850 int val2 ;
18851 int ecode2 = 0 ;
18852 bool temp3 = false ;
18853 PyObject * obj0 = 0 ;
18854 PyObject * obj1 = 0 ;
18855 PyObject * obj2 = 0 ;
18856 char * kwnames[] = {
18857 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18858 };
18859
18860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18862 if (!SWIG_IsOK(res1)) {
18863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18864 }
18865 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18866 if (obj1) {
18867 ecode2 = SWIG_AsVal_int(obj1, &val2);
18868 if (!SWIG_IsOK(ecode2)) {
18869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18870 }
18871 arg2 = static_cast< int >(val2);
18872 }
18873 if (obj2) {
18874 {
18875 arg3 = wxString_in_helper(obj2);
18876 if (arg3 == NULL) SWIG_fail;
18877 temp3 = true;
18878 }
18879 }
18880 {
18881 PyThreadState* __tstate = wxPyBeginAllowThreads();
18882 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18883 wxPyEndAllowThreads(__tstate);
18884 if (PyErr_Occurred()) SWIG_fail;
18885 }
18886 resultobj = SWIG_Py_Void();
18887 {
18888 if (temp3)
18889 delete arg3;
18890 }
18891 return resultobj;
18892 fail:
18893 {
18894 if (temp3)
18895 delete arg3;
18896 }
18897 return NULL;
18898 }
18899
18900
18901 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18902 PyObject *resultobj = 0;
18903 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18904 void *argp1 = 0 ;
18905 int res1 = 0 ;
18906 PyObject *swig_obj[1] ;
18907
18908 if (!args) SWIG_fail;
18909 swig_obj[0] = args;
18910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18911 if (!SWIG_IsOK(res1)) {
18912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18913 }
18914 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18915 {
18916 PyThreadState* __tstate = wxPyBeginAllowThreads();
18917 (arg1)->ClearData();
18918 wxPyEndAllowThreads(__tstate);
18919 if (PyErr_Occurred()) SWIG_fail;
18920 }
18921 resultobj = SWIG_Py_Void();
18922 return resultobj;
18923 fail:
18924 return NULL;
18925 }
18926
18927
18928 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18929 PyObject *resultobj = 0;
18930 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18931 wxString *arg2 = 0 ;
18932 wxFileType *result = 0 ;
18933 void *argp1 = 0 ;
18934 int res1 = 0 ;
18935 bool temp2 = false ;
18936 PyObject * obj0 = 0 ;
18937 PyObject * obj1 = 0 ;
18938 char * kwnames[] = {
18939 (char *) "self",(char *) "ext", NULL
18940 };
18941
18942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18944 if (!SWIG_IsOK(res1)) {
18945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18946 }
18947 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18948 {
18949 arg2 = wxString_in_helper(obj1);
18950 if (arg2 == NULL) SWIG_fail;
18951 temp2 = true;
18952 }
18953 {
18954 PyThreadState* __tstate = wxPyBeginAllowThreads();
18955 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18956 wxPyEndAllowThreads(__tstate);
18957 if (PyErr_Occurred()) SWIG_fail;
18958 }
18959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18960 {
18961 if (temp2)
18962 delete arg2;
18963 }
18964 return resultobj;
18965 fail:
18966 {
18967 if (temp2)
18968 delete arg2;
18969 }
18970 return NULL;
18971 }
18972
18973
18974 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18975 PyObject *resultobj = 0;
18976 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18977 wxString *arg2 = 0 ;
18978 wxFileType *result = 0 ;
18979 void *argp1 = 0 ;
18980 int res1 = 0 ;
18981 bool temp2 = false ;
18982 PyObject * obj0 = 0 ;
18983 PyObject * obj1 = 0 ;
18984 char * kwnames[] = {
18985 (char *) "self",(char *) "mimeType", NULL
18986 };
18987
18988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18990 if (!SWIG_IsOK(res1)) {
18991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18992 }
18993 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18994 {
18995 arg2 = wxString_in_helper(obj1);
18996 if (arg2 == NULL) SWIG_fail;
18997 temp2 = true;
18998 }
18999 {
19000 PyThreadState* __tstate = wxPyBeginAllowThreads();
19001 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
19002 wxPyEndAllowThreads(__tstate);
19003 if (PyErr_Occurred()) SWIG_fail;
19004 }
19005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19006 {
19007 if (temp2)
19008 delete arg2;
19009 }
19010 return resultobj;
19011 fail:
19012 {
19013 if (temp2)
19014 delete arg2;
19015 }
19016 return NULL;
19017 }
19018
19019
19020 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19021 PyObject *resultobj = 0;
19022 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19023 wxString *arg2 = 0 ;
19024 bool arg3 = (bool) false ;
19025 bool result;
19026 void *argp1 = 0 ;
19027 int res1 = 0 ;
19028 bool temp2 = false ;
19029 bool val3 ;
19030 int ecode3 = 0 ;
19031 PyObject * obj0 = 0 ;
19032 PyObject * obj1 = 0 ;
19033 PyObject * obj2 = 0 ;
19034 char * kwnames[] = {
19035 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19036 };
19037
19038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19040 if (!SWIG_IsOK(res1)) {
19041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19042 }
19043 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19044 {
19045 arg2 = wxString_in_helper(obj1);
19046 if (arg2 == NULL) SWIG_fail;
19047 temp2 = true;
19048 }
19049 if (obj2) {
19050 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19051 if (!SWIG_IsOK(ecode3)) {
19052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19053 }
19054 arg3 = static_cast< bool >(val3);
19055 }
19056 {
19057 PyThreadState* __tstate = wxPyBeginAllowThreads();
19058 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19059 wxPyEndAllowThreads(__tstate);
19060 if (PyErr_Occurred()) SWIG_fail;
19061 }
19062 {
19063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19064 }
19065 {
19066 if (temp2)
19067 delete arg2;
19068 }
19069 return resultobj;
19070 fail:
19071 {
19072 if (temp2)
19073 delete arg2;
19074 }
19075 return NULL;
19076 }
19077
19078
19079 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19080 PyObject *resultobj = 0;
19081 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19082 wxString *arg2 = 0 ;
19083 bool result;
19084 void *argp1 = 0 ;
19085 int res1 = 0 ;
19086 bool temp2 = false ;
19087 PyObject * obj0 = 0 ;
19088 PyObject * obj1 = 0 ;
19089 char * kwnames[] = {
19090 (char *) "self",(char *) "filename", NULL
19091 };
19092
19093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19095 if (!SWIG_IsOK(res1)) {
19096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19097 }
19098 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19099 {
19100 arg2 = wxString_in_helper(obj1);
19101 if (arg2 == NULL) SWIG_fail;
19102 temp2 = true;
19103 }
19104 {
19105 PyThreadState* __tstate = wxPyBeginAllowThreads();
19106 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19107 wxPyEndAllowThreads(__tstate);
19108 if (PyErr_Occurred()) SWIG_fail;
19109 }
19110 {
19111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19112 }
19113 {
19114 if (temp2)
19115 delete arg2;
19116 }
19117 return resultobj;
19118 fail:
19119 {
19120 if (temp2)
19121 delete arg2;
19122 }
19123 return NULL;
19124 }
19125
19126
19127 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19128 PyObject *resultobj = 0;
19129 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19130 PyObject *result = 0 ;
19131 void *argp1 = 0 ;
19132 int res1 = 0 ;
19133 PyObject *swig_obj[1] ;
19134
19135 if (!args) SWIG_fail;
19136 swig_obj[0] = args;
19137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19138 if (!SWIG_IsOK(res1)) {
19139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19140 }
19141 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19142 {
19143 PyThreadState* __tstate = wxPyBeginAllowThreads();
19144 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19145 wxPyEndAllowThreads(__tstate);
19146 if (PyErr_Occurred()) SWIG_fail;
19147 }
19148 resultobj = result;
19149 return resultobj;
19150 fail:
19151 return NULL;
19152 }
19153
19154
19155 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19156 PyObject *resultobj = 0;
19157 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19158 wxFileTypeInfo *arg2 = 0 ;
19159 void *argp1 = 0 ;
19160 int res1 = 0 ;
19161 void *argp2 = 0 ;
19162 int res2 = 0 ;
19163 PyObject * obj0 = 0 ;
19164 PyObject * obj1 = 0 ;
19165 char * kwnames[] = {
19166 (char *) "self",(char *) "ft", NULL
19167 };
19168
19169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19171 if (!SWIG_IsOK(res1)) {
19172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19173 }
19174 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19175 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19176 if (!SWIG_IsOK(res2)) {
19177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19178 }
19179 if (!argp2) {
19180 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19181 }
19182 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19183 {
19184 PyThreadState* __tstate = wxPyBeginAllowThreads();
19185 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19186 wxPyEndAllowThreads(__tstate);
19187 if (PyErr_Occurred()) SWIG_fail;
19188 }
19189 resultobj = SWIG_Py_Void();
19190 return resultobj;
19191 fail:
19192 return NULL;
19193 }
19194
19195
19196 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19197 PyObject *resultobj = 0;
19198 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19199 wxFileTypeInfo *arg2 = 0 ;
19200 wxFileType *result = 0 ;
19201 void *argp1 = 0 ;
19202 int res1 = 0 ;
19203 void *argp2 = 0 ;
19204 int res2 = 0 ;
19205 PyObject * obj0 = 0 ;
19206 PyObject * obj1 = 0 ;
19207 char * kwnames[] = {
19208 (char *) "self",(char *) "ftInfo", NULL
19209 };
19210
19211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19213 if (!SWIG_IsOK(res1)) {
19214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19215 }
19216 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19217 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19218 if (!SWIG_IsOK(res2)) {
19219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19220 }
19221 if (!argp2) {
19222 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19223 }
19224 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19225 {
19226 PyThreadState* __tstate = wxPyBeginAllowThreads();
19227 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19228 wxPyEndAllowThreads(__tstate);
19229 if (PyErr_Occurred()) SWIG_fail;
19230 }
19231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19232 return resultobj;
19233 fail:
19234 return NULL;
19235 }
19236
19237
19238 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19239 PyObject *resultobj = 0;
19240 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19241 wxFileType *arg2 = (wxFileType *) 0 ;
19242 bool result;
19243 void *argp1 = 0 ;
19244 int res1 = 0 ;
19245 void *argp2 = 0 ;
19246 int res2 = 0 ;
19247 PyObject * obj0 = 0 ;
19248 PyObject * obj1 = 0 ;
19249 char * kwnames[] = {
19250 (char *) "self",(char *) "ft", NULL
19251 };
19252
19253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19255 if (!SWIG_IsOK(res1)) {
19256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19257 }
19258 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19259 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19260 if (!SWIG_IsOK(res2)) {
19261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19262 }
19263 arg2 = reinterpret_cast< wxFileType * >(argp2);
19264 {
19265 PyThreadState* __tstate = wxPyBeginAllowThreads();
19266 result = (bool)(arg1)->Unassociate(arg2);
19267 wxPyEndAllowThreads(__tstate);
19268 if (PyErr_Occurred()) SWIG_fail;
19269 }
19270 {
19271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19272 }
19273 return resultobj;
19274 fail:
19275 return NULL;
19276 }
19277
19278
19279 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19280 PyObject *resultobj = 0;
19281 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19282 void *argp1 = 0 ;
19283 int res1 = 0 ;
19284 PyObject *swig_obj[1] ;
19285
19286 if (!args) SWIG_fail;
19287 swig_obj[0] = args;
19288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19289 if (!SWIG_IsOK(res1)) {
19290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19291 }
19292 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19293 {
19294 PyThreadState* __tstate = wxPyBeginAllowThreads();
19295 delete arg1;
19296
19297 wxPyEndAllowThreads(__tstate);
19298 if (PyErr_Occurred()) SWIG_fail;
19299 }
19300 resultobj = SWIG_Py_Void();
19301 return resultobj;
19302 fail:
19303 return NULL;
19304 }
19305
19306
19307 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19308 PyObject *obj;
19309 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19310 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19311 return SWIG_Py_Void();
19312 }
19313
19314 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19315 return SWIG_Python_InitShadowInstance(args);
19316 }
19317
19318 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19319 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19320 return 1;
19321 }
19322
19323
19324 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19325 PyObject *pyobj = 0;
19326
19327 {
19328 #if wxUSE_UNICODE
19329 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19330 #else
19331 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19332 #endif
19333 }
19334 return pyobj;
19335 }
19336
19337
19338 SWIGINTERN int ART_MENU_set(PyObject *) {
19339 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19340 return 1;
19341 }
19342
19343
19344 SWIGINTERN PyObject *ART_MENU_get(void) {
19345 PyObject *pyobj = 0;
19346
19347 {
19348 #if wxUSE_UNICODE
19349 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19350 #else
19351 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19352 #endif
19353 }
19354 return pyobj;
19355 }
19356
19357
19358 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19359 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19360 return 1;
19361 }
19362
19363
19364 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19365 PyObject *pyobj = 0;
19366
19367 {
19368 #if wxUSE_UNICODE
19369 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19370 #else
19371 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19372 #endif
19373 }
19374 return pyobj;
19375 }
19376
19377
19378 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19379 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19380 return 1;
19381 }
19382
19383
19384 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19385 PyObject *pyobj = 0;
19386
19387 {
19388 #if wxUSE_UNICODE
19389 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19390 #else
19391 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19392 #endif
19393 }
19394 return pyobj;
19395 }
19396
19397
19398 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19399 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19400 return 1;
19401 }
19402
19403
19404 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19405 PyObject *pyobj = 0;
19406
19407 {
19408 #if wxUSE_UNICODE
19409 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19410 #else
19411 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19412 #endif
19413 }
19414 return pyobj;
19415 }
19416
19417
19418 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19419 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19420 return 1;
19421 }
19422
19423
19424 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19425 PyObject *pyobj = 0;
19426
19427 {
19428 #if wxUSE_UNICODE
19429 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19430 #else
19431 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19432 #endif
19433 }
19434 return pyobj;
19435 }
19436
19437
19438 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19439 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19440 return 1;
19441 }
19442
19443
19444 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19445 PyObject *pyobj = 0;
19446
19447 {
19448 #if wxUSE_UNICODE
19449 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19450 #else
19451 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19452 #endif
19453 }
19454 return pyobj;
19455 }
19456
19457
19458 SWIGINTERN int ART_OTHER_set(PyObject *) {
19459 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19460 return 1;
19461 }
19462
19463
19464 SWIGINTERN PyObject *ART_OTHER_get(void) {
19465 PyObject *pyobj = 0;
19466
19467 {
19468 #if wxUSE_UNICODE
19469 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19470 #else
19471 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19472 #endif
19473 }
19474 return pyobj;
19475 }
19476
19477
19478 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19479 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19480 return 1;
19481 }
19482
19483
19484 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19485 PyObject *pyobj = 0;
19486
19487 {
19488 #if wxUSE_UNICODE
19489 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19490 #else
19491 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19492 #endif
19493 }
19494 return pyobj;
19495 }
19496
19497
19498 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19499 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19500 return 1;
19501 }
19502
19503
19504 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19505 PyObject *pyobj = 0;
19506
19507 {
19508 #if wxUSE_UNICODE
19509 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19510 #else
19511 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19512 #endif
19513 }
19514 return pyobj;
19515 }
19516
19517
19518 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19519 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19520 return 1;
19521 }
19522
19523
19524 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19525 PyObject *pyobj = 0;
19526
19527 {
19528 #if wxUSE_UNICODE
19529 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19530 #else
19531 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19532 #endif
19533 }
19534 return pyobj;
19535 }
19536
19537
19538 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19539 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19540 return 1;
19541 }
19542
19543
19544 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19545 PyObject *pyobj = 0;
19546
19547 {
19548 #if wxUSE_UNICODE
19549 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19550 #else
19551 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19552 #endif
19553 }
19554 return pyobj;
19555 }
19556
19557
19558 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19559 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19560 return 1;
19561 }
19562
19563
19564 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19565 PyObject *pyobj = 0;
19566
19567 {
19568 #if wxUSE_UNICODE
19569 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19570 #else
19571 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19572 #endif
19573 }
19574 return pyobj;
19575 }
19576
19577
19578 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19579 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19580 return 1;
19581 }
19582
19583
19584 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19585 PyObject *pyobj = 0;
19586
19587 {
19588 #if wxUSE_UNICODE
19589 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19590 #else
19591 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19592 #endif
19593 }
19594 return pyobj;
19595 }
19596
19597
19598 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19599 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19600 return 1;
19601 }
19602
19603
19604 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19605 PyObject *pyobj = 0;
19606
19607 {
19608 #if wxUSE_UNICODE
19609 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19610 #else
19611 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19612 #endif
19613 }
19614 return pyobj;
19615 }
19616
19617
19618 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19619 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19620 return 1;
19621 }
19622
19623
19624 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19625 PyObject *pyobj = 0;
19626
19627 {
19628 #if wxUSE_UNICODE
19629 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19630 #else
19631 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19632 #endif
19633 }
19634 return pyobj;
19635 }
19636
19637
19638 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19639 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19640 return 1;
19641 }
19642
19643
19644 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19645 PyObject *pyobj = 0;
19646
19647 {
19648 #if wxUSE_UNICODE
19649 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19650 #else
19651 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19652 #endif
19653 }
19654 return pyobj;
19655 }
19656
19657
19658 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19659 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19660 return 1;
19661 }
19662
19663
19664 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19665 PyObject *pyobj = 0;
19666
19667 {
19668 #if wxUSE_UNICODE
19669 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19670 #else
19671 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19672 #endif
19673 }
19674 return pyobj;
19675 }
19676
19677
19678 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19679 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19680 return 1;
19681 }
19682
19683
19684 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19685 PyObject *pyobj = 0;
19686
19687 {
19688 #if wxUSE_UNICODE
19689 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19690 #else
19691 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19692 #endif
19693 }
19694 return pyobj;
19695 }
19696
19697
19698 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19699 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19700 return 1;
19701 }
19702
19703
19704 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19705 PyObject *pyobj = 0;
19706
19707 {
19708 #if wxUSE_UNICODE
19709 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19710 #else
19711 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19712 #endif
19713 }
19714 return pyobj;
19715 }
19716
19717
19718 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19719 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19720 return 1;
19721 }
19722
19723
19724 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19725 PyObject *pyobj = 0;
19726
19727 {
19728 #if wxUSE_UNICODE
19729 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19730 #else
19731 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19732 #endif
19733 }
19734 return pyobj;
19735 }
19736
19737
19738 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19739 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19740 return 1;
19741 }
19742
19743
19744 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19745 PyObject *pyobj = 0;
19746
19747 {
19748 #if wxUSE_UNICODE
19749 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19750 #else
19751 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19752 #endif
19753 }
19754 return pyobj;
19755 }
19756
19757
19758 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19759 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19760 return 1;
19761 }
19762
19763
19764 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19765 PyObject *pyobj = 0;
19766
19767 {
19768 #if wxUSE_UNICODE
19769 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19770 #else
19771 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19772 #endif
19773 }
19774 return pyobj;
19775 }
19776
19777
19778 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19779 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19780 return 1;
19781 }
19782
19783
19784 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19785 PyObject *pyobj = 0;
19786
19787 {
19788 #if wxUSE_UNICODE
19789 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19790 #else
19791 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19792 #endif
19793 }
19794 return pyobj;
19795 }
19796
19797
19798 SWIGINTERN int ART_PRINT_set(PyObject *) {
19799 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19800 return 1;
19801 }
19802
19803
19804 SWIGINTERN PyObject *ART_PRINT_get(void) {
19805 PyObject *pyobj = 0;
19806
19807 {
19808 #if wxUSE_UNICODE
19809 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19810 #else
19811 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19812 #endif
19813 }
19814 return pyobj;
19815 }
19816
19817
19818 SWIGINTERN int ART_HELP_set(PyObject *) {
19819 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19820 return 1;
19821 }
19822
19823
19824 SWIGINTERN PyObject *ART_HELP_get(void) {
19825 PyObject *pyobj = 0;
19826
19827 {
19828 #if wxUSE_UNICODE
19829 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19830 #else
19831 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19832 #endif
19833 }
19834 return pyobj;
19835 }
19836
19837
19838 SWIGINTERN int ART_TIP_set(PyObject *) {
19839 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19840 return 1;
19841 }
19842
19843
19844 SWIGINTERN PyObject *ART_TIP_get(void) {
19845 PyObject *pyobj = 0;
19846
19847 {
19848 #if wxUSE_UNICODE
19849 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19850 #else
19851 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19852 #endif
19853 }
19854 return pyobj;
19855 }
19856
19857
19858 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19859 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19860 return 1;
19861 }
19862
19863
19864 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19865 PyObject *pyobj = 0;
19866
19867 {
19868 #if wxUSE_UNICODE
19869 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19870 #else
19871 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19872 #endif
19873 }
19874 return pyobj;
19875 }
19876
19877
19878 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19879 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19880 return 1;
19881 }
19882
19883
19884 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19885 PyObject *pyobj = 0;
19886
19887 {
19888 #if wxUSE_UNICODE
19889 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19890 #else
19891 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19892 #endif
19893 }
19894 return pyobj;
19895 }
19896
19897
19898 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19899 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19900 return 1;
19901 }
19902
19903
19904 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19905 PyObject *pyobj = 0;
19906
19907 {
19908 #if wxUSE_UNICODE
19909 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19910 #else
19911 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19912 #endif
19913 }
19914 return pyobj;
19915 }
19916
19917
19918 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19919 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19920 return 1;
19921 }
19922
19923
19924 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19925 PyObject *pyobj = 0;
19926
19927 {
19928 #if wxUSE_UNICODE
19929 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19930 #else
19931 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19932 #endif
19933 }
19934 return pyobj;
19935 }
19936
19937
19938 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19939 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19940 return 1;
19941 }
19942
19943
19944 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19945 PyObject *pyobj = 0;
19946
19947 {
19948 #if wxUSE_UNICODE
19949 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19950 #else
19951 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19952 #endif
19953 }
19954 return pyobj;
19955 }
19956
19957
19958 SWIGINTERN int ART_CDROM_set(PyObject *) {
19959 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19960 return 1;
19961 }
19962
19963
19964 SWIGINTERN PyObject *ART_CDROM_get(void) {
19965 PyObject *pyobj = 0;
19966
19967 {
19968 #if wxUSE_UNICODE
19969 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19970 #else
19971 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19972 #endif
19973 }
19974 return pyobj;
19975 }
19976
19977
19978 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19979 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19980 return 1;
19981 }
19982
19983
19984 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19985 PyObject *pyobj = 0;
19986
19987 {
19988 #if wxUSE_UNICODE
19989 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19990 #else
19991 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19992 #endif
19993 }
19994 return pyobj;
19995 }
19996
19997
19998 SWIGINTERN int ART_FOLDER_set(PyObject *) {
19999 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
20000 return 1;
20001 }
20002
20003
20004 SWIGINTERN PyObject *ART_FOLDER_get(void) {
20005 PyObject *pyobj = 0;
20006
20007 {
20008 #if wxUSE_UNICODE
20009 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20010 #else
20011 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20012 #endif
20013 }
20014 return pyobj;
20015 }
20016
20017
20018 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
20019 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
20020 return 1;
20021 }
20022
20023
20024 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
20025 PyObject *pyobj = 0;
20026
20027 {
20028 #if wxUSE_UNICODE
20029 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20030 #else
20031 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20032 #endif
20033 }
20034 return pyobj;
20035 }
20036
20037
20038 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20039 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20040 return 1;
20041 }
20042
20043
20044 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20045 PyObject *pyobj = 0;
20046
20047 {
20048 #if wxUSE_UNICODE
20049 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20050 #else
20051 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20052 #endif
20053 }
20054 return pyobj;
20055 }
20056
20057
20058 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20059 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20060 return 1;
20061 }
20062
20063
20064 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20065 PyObject *pyobj = 0;
20066
20067 {
20068 #if wxUSE_UNICODE
20069 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20070 #else
20071 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20072 #endif
20073 }
20074 return pyobj;
20075 }
20076
20077
20078 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20079 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20080 return 1;
20081 }
20082
20083
20084 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20085 PyObject *pyobj = 0;
20086
20087 {
20088 #if wxUSE_UNICODE
20089 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20090 #else
20091 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20092 #endif
20093 }
20094 return pyobj;
20095 }
20096
20097
20098 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20099 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20100 return 1;
20101 }
20102
20103
20104 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20105 PyObject *pyobj = 0;
20106
20107 {
20108 #if wxUSE_UNICODE
20109 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20110 #else
20111 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20112 #endif
20113 }
20114 return pyobj;
20115 }
20116
20117
20118 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20119 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20120 return 1;
20121 }
20122
20123
20124 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20125 PyObject *pyobj = 0;
20126
20127 {
20128 #if wxUSE_UNICODE
20129 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20130 #else
20131 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20132 #endif
20133 }
20134 return pyobj;
20135 }
20136
20137
20138 SWIGINTERN int ART_ERROR_set(PyObject *) {
20139 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20140 return 1;
20141 }
20142
20143
20144 SWIGINTERN PyObject *ART_ERROR_get(void) {
20145 PyObject *pyobj = 0;
20146
20147 {
20148 #if wxUSE_UNICODE
20149 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20150 #else
20151 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20152 #endif
20153 }
20154 return pyobj;
20155 }
20156
20157
20158 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20159 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20160 return 1;
20161 }
20162
20163
20164 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20165 PyObject *pyobj = 0;
20166
20167 {
20168 #if wxUSE_UNICODE
20169 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20170 #else
20171 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20172 #endif
20173 }
20174 return pyobj;
20175 }
20176
20177
20178 SWIGINTERN int ART_WARNING_set(PyObject *) {
20179 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20180 return 1;
20181 }
20182
20183
20184 SWIGINTERN PyObject *ART_WARNING_get(void) {
20185 PyObject *pyobj = 0;
20186
20187 {
20188 #if wxUSE_UNICODE
20189 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20190 #else
20191 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20192 #endif
20193 }
20194 return pyobj;
20195 }
20196
20197
20198 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20199 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20200 return 1;
20201 }
20202
20203
20204 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20205 PyObject *pyobj = 0;
20206
20207 {
20208 #if wxUSE_UNICODE
20209 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20210 #else
20211 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20212 #endif
20213 }
20214 return pyobj;
20215 }
20216
20217
20218 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20219 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20220 return 1;
20221 }
20222
20223
20224 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20225 PyObject *pyobj = 0;
20226
20227 {
20228 #if wxUSE_UNICODE
20229 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20230 #else
20231 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20232 #endif
20233 }
20234 return pyobj;
20235 }
20236
20237
20238 SWIGINTERN int ART_COPY_set(PyObject *) {
20239 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20240 return 1;
20241 }
20242
20243
20244 SWIGINTERN PyObject *ART_COPY_get(void) {
20245 PyObject *pyobj = 0;
20246
20247 {
20248 #if wxUSE_UNICODE
20249 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20250 #else
20251 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20252 #endif
20253 }
20254 return pyobj;
20255 }
20256
20257
20258 SWIGINTERN int ART_CUT_set(PyObject *) {
20259 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20260 return 1;
20261 }
20262
20263
20264 SWIGINTERN PyObject *ART_CUT_get(void) {
20265 PyObject *pyobj = 0;
20266
20267 {
20268 #if wxUSE_UNICODE
20269 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20270 #else
20271 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20272 #endif
20273 }
20274 return pyobj;
20275 }
20276
20277
20278 SWIGINTERN int ART_PASTE_set(PyObject *) {
20279 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20280 return 1;
20281 }
20282
20283
20284 SWIGINTERN PyObject *ART_PASTE_get(void) {
20285 PyObject *pyobj = 0;
20286
20287 {
20288 #if wxUSE_UNICODE
20289 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20290 #else
20291 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20292 #endif
20293 }
20294 return pyobj;
20295 }
20296
20297
20298 SWIGINTERN int ART_DELETE_set(PyObject *) {
20299 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20300 return 1;
20301 }
20302
20303
20304 SWIGINTERN PyObject *ART_DELETE_get(void) {
20305 PyObject *pyobj = 0;
20306
20307 {
20308 #if wxUSE_UNICODE
20309 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20310 #else
20311 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20312 #endif
20313 }
20314 return pyobj;
20315 }
20316
20317
20318 SWIGINTERN int ART_NEW_set(PyObject *) {
20319 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20320 return 1;
20321 }
20322
20323
20324 SWIGINTERN PyObject *ART_NEW_get(void) {
20325 PyObject *pyobj = 0;
20326
20327 {
20328 #if wxUSE_UNICODE
20329 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20330 #else
20331 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20332 #endif
20333 }
20334 return pyobj;
20335 }
20336
20337
20338 SWIGINTERN int ART_UNDO_set(PyObject *) {
20339 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20340 return 1;
20341 }
20342
20343
20344 SWIGINTERN PyObject *ART_UNDO_get(void) {
20345 PyObject *pyobj = 0;
20346
20347 {
20348 #if wxUSE_UNICODE
20349 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20350 #else
20351 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20352 #endif
20353 }
20354 return pyobj;
20355 }
20356
20357
20358 SWIGINTERN int ART_REDO_set(PyObject *) {
20359 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20360 return 1;
20361 }
20362
20363
20364 SWIGINTERN PyObject *ART_REDO_get(void) {
20365 PyObject *pyobj = 0;
20366
20367 {
20368 #if wxUSE_UNICODE
20369 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20370 #else
20371 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20372 #endif
20373 }
20374 return pyobj;
20375 }
20376
20377
20378 SWIGINTERN int ART_QUIT_set(PyObject *) {
20379 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20380 return 1;
20381 }
20382
20383
20384 SWIGINTERN PyObject *ART_QUIT_get(void) {
20385 PyObject *pyobj = 0;
20386
20387 {
20388 #if wxUSE_UNICODE
20389 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20390 #else
20391 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20392 #endif
20393 }
20394 return pyobj;
20395 }
20396
20397
20398 SWIGINTERN int ART_FIND_set(PyObject *) {
20399 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20400 return 1;
20401 }
20402
20403
20404 SWIGINTERN PyObject *ART_FIND_get(void) {
20405 PyObject *pyobj = 0;
20406
20407 {
20408 #if wxUSE_UNICODE
20409 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20410 #else
20411 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20412 #endif
20413 }
20414 return pyobj;
20415 }
20416
20417
20418 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20419 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20420 return 1;
20421 }
20422
20423
20424 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20425 PyObject *pyobj = 0;
20426
20427 {
20428 #if wxUSE_UNICODE
20429 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20430 #else
20431 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20432 #endif
20433 }
20434 return pyobj;
20435 }
20436
20437
20438 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20439 PyObject *resultobj = 0;
20440 wxPyArtProvider *result = 0 ;
20441
20442 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20443 {
20444 if (!wxPyCheckForApp()) SWIG_fail;
20445 PyThreadState* __tstate = wxPyBeginAllowThreads();
20446 result = (wxPyArtProvider *)new wxPyArtProvider();
20447 wxPyEndAllowThreads(__tstate);
20448 if (PyErr_Occurred()) SWIG_fail;
20449 }
20450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20451 return resultobj;
20452 fail:
20453 return NULL;
20454 }
20455
20456
20457 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20458 PyObject *resultobj = 0;
20459 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20460 void *argp1 = 0 ;
20461 int res1 = 0 ;
20462 PyObject *swig_obj[1] ;
20463
20464 if (!args) SWIG_fail;
20465 swig_obj[0] = args;
20466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20467 if (!SWIG_IsOK(res1)) {
20468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20469 }
20470 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20471 {
20472 PyThreadState* __tstate = wxPyBeginAllowThreads();
20473 delete arg1;
20474
20475 wxPyEndAllowThreads(__tstate);
20476 if (PyErr_Occurred()) SWIG_fail;
20477 }
20478 resultobj = SWIG_Py_Void();
20479 return resultobj;
20480 fail:
20481 return NULL;
20482 }
20483
20484
20485 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20486 PyObject *resultobj = 0;
20487 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20488 PyObject *arg2 = (PyObject *) 0 ;
20489 PyObject *arg3 = (PyObject *) 0 ;
20490 void *argp1 = 0 ;
20491 int res1 = 0 ;
20492 PyObject * obj0 = 0 ;
20493 PyObject * obj1 = 0 ;
20494 PyObject * obj2 = 0 ;
20495 char * kwnames[] = {
20496 (char *) "self",(char *) "self",(char *) "_class", NULL
20497 };
20498
20499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20501 if (!SWIG_IsOK(res1)) {
20502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20503 }
20504 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20505 arg2 = obj1;
20506 arg3 = obj2;
20507 {
20508 PyThreadState* __tstate = wxPyBeginAllowThreads();
20509 (arg1)->_setCallbackInfo(arg2,arg3);
20510 wxPyEndAllowThreads(__tstate);
20511 if (PyErr_Occurred()) SWIG_fail;
20512 }
20513 resultobj = SWIG_Py_Void();
20514 return resultobj;
20515 fail:
20516 return NULL;
20517 }
20518
20519
20520 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20521 PyObject *resultobj = 0;
20522 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20523 int res1 = 0 ;
20524 PyObject * obj0 = 0 ;
20525 char * kwnames[] = {
20526 (char *) "provider", NULL
20527 };
20528
20529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20530 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20531 if (!SWIG_IsOK(res1)) {
20532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20533 }
20534 {
20535 PyThreadState* __tstate = wxPyBeginAllowThreads();
20536 wxPyArtProvider::Push(arg1);
20537 wxPyEndAllowThreads(__tstate);
20538 if (PyErr_Occurred()) SWIG_fail;
20539 }
20540 resultobj = SWIG_Py_Void();
20541 return resultobj;
20542 fail:
20543 return NULL;
20544 }
20545
20546
20547 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20548 PyObject *resultobj = 0;
20549 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20550 int res1 = 0 ;
20551 PyObject * obj0 = 0 ;
20552 char * kwnames[] = {
20553 (char *) "provider", NULL
20554 };
20555
20556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20557 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20558 if (!SWIG_IsOK(res1)) {
20559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20560 }
20561 {
20562 PyThreadState* __tstate = wxPyBeginAllowThreads();
20563 wxPyArtProvider::Insert(arg1);
20564 wxPyEndAllowThreads(__tstate);
20565 if (PyErr_Occurred()) SWIG_fail;
20566 }
20567 resultobj = SWIG_Py_Void();
20568 return resultobj;
20569 fail:
20570 return NULL;
20571 }
20572
20573
20574 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20575 PyObject *resultobj = 0;
20576 bool result;
20577
20578 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20579 {
20580 PyThreadState* __tstate = wxPyBeginAllowThreads();
20581 result = (bool)wxPyArtProvider::Pop();
20582 wxPyEndAllowThreads(__tstate);
20583 if (PyErr_Occurred()) SWIG_fail;
20584 }
20585 {
20586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20587 }
20588 return resultobj;
20589 fail:
20590 return NULL;
20591 }
20592
20593
20594 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20595 PyObject *resultobj = 0;
20596 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20597 bool result;
20598 void *argp1 = 0 ;
20599 int res1 = 0 ;
20600 PyObject * obj0 = 0 ;
20601 char * kwnames[] = {
20602 (char *) "provider", NULL
20603 };
20604
20605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20607 if (!SWIG_IsOK(res1)) {
20608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20609 }
20610 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20611 {
20612 PyThreadState* __tstate = wxPyBeginAllowThreads();
20613 result = (bool)wxPyArtProvider::Delete(arg1);
20614 wxPyEndAllowThreads(__tstate);
20615 if (PyErr_Occurred()) SWIG_fail;
20616 }
20617 {
20618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20619 }
20620 return resultobj;
20621 fail:
20622 return NULL;
20623 }
20624
20625
20626 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20627 PyObject *resultobj = 0;
20628 wxString *arg1 = 0 ;
20629 wxString const &arg2_defvalue = wxPyART_OTHER ;
20630 wxString *arg2 = (wxString *) &arg2_defvalue ;
20631 wxSize const &arg3_defvalue = wxDefaultSize ;
20632 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20633 wxBitmap result;
20634 bool temp1 = false ;
20635 bool temp2 = false ;
20636 wxSize temp3 ;
20637 PyObject * obj0 = 0 ;
20638 PyObject * obj1 = 0 ;
20639 PyObject * obj2 = 0 ;
20640 char * kwnames[] = {
20641 (char *) "id",(char *) "client",(char *) "size", NULL
20642 };
20643
20644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20645 {
20646 arg1 = wxString_in_helper(obj0);
20647 if (arg1 == NULL) SWIG_fail;
20648 temp1 = true;
20649 }
20650 if (obj1) {
20651 {
20652 arg2 = wxString_in_helper(obj1);
20653 if (arg2 == NULL) SWIG_fail;
20654 temp2 = true;
20655 }
20656 }
20657 if (obj2) {
20658 {
20659 arg3 = &temp3;
20660 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20661 }
20662 }
20663 {
20664 if (!wxPyCheckForApp()) SWIG_fail;
20665 PyThreadState* __tstate = wxPyBeginAllowThreads();
20666 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20667 wxPyEndAllowThreads(__tstate);
20668 if (PyErr_Occurred()) SWIG_fail;
20669 }
20670 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20671 {
20672 if (temp1)
20673 delete arg1;
20674 }
20675 {
20676 if (temp2)
20677 delete arg2;
20678 }
20679 return resultobj;
20680 fail:
20681 {
20682 if (temp1)
20683 delete arg1;
20684 }
20685 {
20686 if (temp2)
20687 delete arg2;
20688 }
20689 return NULL;
20690 }
20691
20692
20693 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20694 PyObject *resultobj = 0;
20695 wxString *arg1 = 0 ;
20696 wxString const &arg2_defvalue = wxPyART_OTHER ;
20697 wxString *arg2 = (wxString *) &arg2_defvalue ;
20698 wxSize const &arg3_defvalue = wxDefaultSize ;
20699 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20700 wxIcon result;
20701 bool temp1 = false ;
20702 bool temp2 = false ;
20703 wxSize temp3 ;
20704 PyObject * obj0 = 0 ;
20705 PyObject * obj1 = 0 ;
20706 PyObject * obj2 = 0 ;
20707 char * kwnames[] = {
20708 (char *) "id",(char *) "client",(char *) "size", NULL
20709 };
20710
20711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20712 {
20713 arg1 = wxString_in_helper(obj0);
20714 if (arg1 == NULL) SWIG_fail;
20715 temp1 = true;
20716 }
20717 if (obj1) {
20718 {
20719 arg2 = wxString_in_helper(obj1);
20720 if (arg2 == NULL) SWIG_fail;
20721 temp2 = true;
20722 }
20723 }
20724 if (obj2) {
20725 {
20726 arg3 = &temp3;
20727 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20728 }
20729 }
20730 {
20731 if (!wxPyCheckForApp()) SWIG_fail;
20732 PyThreadState* __tstate = wxPyBeginAllowThreads();
20733 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20734 wxPyEndAllowThreads(__tstate);
20735 if (PyErr_Occurred()) SWIG_fail;
20736 }
20737 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20738 {
20739 if (temp1)
20740 delete arg1;
20741 }
20742 {
20743 if (temp2)
20744 delete arg2;
20745 }
20746 return resultobj;
20747 fail:
20748 {
20749 if (temp1)
20750 delete arg1;
20751 }
20752 {
20753 if (temp2)
20754 delete arg2;
20755 }
20756 return NULL;
20757 }
20758
20759
20760 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20761 PyObject *resultobj = 0;
20762 wxString *arg1 = 0 ;
20763 bool arg2 = (bool) false ;
20764 wxSize result;
20765 bool temp1 = false ;
20766 bool val2 ;
20767 int ecode2 = 0 ;
20768 PyObject * obj0 = 0 ;
20769 PyObject * obj1 = 0 ;
20770 char * kwnames[] = {
20771 (char *) "client",(char *) "platform_dependent", NULL
20772 };
20773
20774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20775 {
20776 arg1 = wxString_in_helper(obj0);
20777 if (arg1 == NULL) SWIG_fail;
20778 temp1 = true;
20779 }
20780 if (obj1) {
20781 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20782 if (!SWIG_IsOK(ecode2)) {
20783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20784 }
20785 arg2 = static_cast< bool >(val2);
20786 }
20787 {
20788 PyThreadState* __tstate = wxPyBeginAllowThreads();
20789 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20790 wxPyEndAllowThreads(__tstate);
20791 if (PyErr_Occurred()) SWIG_fail;
20792 }
20793 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20794 {
20795 if (temp1)
20796 delete arg1;
20797 }
20798 return resultobj;
20799 fail:
20800 {
20801 if (temp1)
20802 delete arg1;
20803 }
20804 return NULL;
20805 }
20806
20807
20808 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20809 PyObject *resultobj = 0;
20810 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20811 void *argp1 = 0 ;
20812 int res1 = 0 ;
20813 PyObject *swig_obj[1] ;
20814
20815 if (!args) SWIG_fail;
20816 swig_obj[0] = args;
20817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20818 if (!SWIG_IsOK(res1)) {
20819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20820 }
20821 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20822 {
20823 PyThreadState* __tstate = wxPyBeginAllowThreads();
20824 wxPyArtProvider_Destroy(arg1);
20825 wxPyEndAllowThreads(__tstate);
20826 if (PyErr_Occurred()) SWIG_fail;
20827 }
20828 resultobj = SWIG_Py_Void();
20829 return resultobj;
20830 fail:
20831 return NULL;
20832 }
20833
20834
20835 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20836 PyObject *obj;
20837 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20838 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20839 return SWIG_Py_Void();
20840 }
20841
20842 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20843 return SWIG_Python_InitShadowInstance(args);
20844 }
20845
20846 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20847 PyObject *resultobj = 0;
20848 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20849 void *argp1 = 0 ;
20850 int res1 = 0 ;
20851 PyObject *swig_obj[1] ;
20852
20853 if (!args) SWIG_fail;
20854 swig_obj[0] = args;
20855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20856 if (!SWIG_IsOK(res1)) {
20857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20858 }
20859 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20860 {
20861 PyThreadState* __tstate = wxPyBeginAllowThreads();
20862 delete arg1;
20863
20864 wxPyEndAllowThreads(__tstate);
20865 if (PyErr_Occurred()) SWIG_fail;
20866 }
20867 resultobj = SWIG_Py_Void();
20868 return resultobj;
20869 fail:
20870 return NULL;
20871 }
20872
20873
20874 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20875 PyObject *resultobj = 0;
20876 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20877 wxConfigBase *result = 0 ;
20878 int res1 = 0 ;
20879 PyObject * obj0 = 0 ;
20880 char * kwnames[] = {
20881 (char *) "config", NULL
20882 };
20883
20884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20885 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20886 if (!SWIG_IsOK(res1)) {
20887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20888 }
20889 {
20890 PyThreadState* __tstate = wxPyBeginAllowThreads();
20891 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20892 wxPyEndAllowThreads(__tstate);
20893 if (PyErr_Occurred()) SWIG_fail;
20894 }
20895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20896 return resultobj;
20897 fail:
20898 return NULL;
20899 }
20900
20901
20902 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20903 PyObject *resultobj = 0;
20904 bool arg1 = (bool) true ;
20905 wxConfigBase *result = 0 ;
20906 bool val1 ;
20907 int ecode1 = 0 ;
20908 PyObject * obj0 = 0 ;
20909 char * kwnames[] = {
20910 (char *) "createOnDemand", NULL
20911 };
20912
20913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20914 if (obj0) {
20915 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20916 if (!SWIG_IsOK(ecode1)) {
20917 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20918 }
20919 arg1 = static_cast< bool >(val1);
20920 }
20921 {
20922 PyThreadState* __tstate = wxPyBeginAllowThreads();
20923 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20924 wxPyEndAllowThreads(__tstate);
20925 if (PyErr_Occurred()) SWIG_fail;
20926 }
20927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20928 return resultobj;
20929 fail:
20930 return NULL;
20931 }
20932
20933
20934 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20935 PyObject *resultobj = 0;
20936 wxConfigBase *result = 0 ;
20937
20938 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20939 {
20940 PyThreadState* __tstate = wxPyBeginAllowThreads();
20941 result = (wxConfigBase *)wxConfigBase::Create();
20942 wxPyEndAllowThreads(__tstate);
20943 if (PyErr_Occurred()) SWIG_fail;
20944 }
20945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20946 return resultobj;
20947 fail:
20948 return NULL;
20949 }
20950
20951
20952 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20953 PyObject *resultobj = 0;
20954
20955 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20956 {
20957 PyThreadState* __tstate = wxPyBeginAllowThreads();
20958 wxConfigBase::DontCreateOnDemand();
20959 wxPyEndAllowThreads(__tstate);
20960 if (PyErr_Occurred()) SWIG_fail;
20961 }
20962 resultobj = SWIG_Py_Void();
20963 return resultobj;
20964 fail:
20965 return NULL;
20966 }
20967
20968
20969 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20970 PyObject *resultobj = 0;
20971 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20972 wxString *arg2 = 0 ;
20973 void *argp1 = 0 ;
20974 int res1 = 0 ;
20975 bool temp2 = false ;
20976 PyObject * obj0 = 0 ;
20977 PyObject * obj1 = 0 ;
20978 char * kwnames[] = {
20979 (char *) "self",(char *) "path", NULL
20980 };
20981
20982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",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_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20986 }
20987 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20988 {
20989 arg2 = wxString_in_helper(obj1);
20990 if (arg2 == NULL) SWIG_fail;
20991 temp2 = true;
20992 }
20993 {
20994 PyThreadState* __tstate = wxPyBeginAllowThreads();
20995 (arg1)->SetPath((wxString const &)*arg2);
20996 wxPyEndAllowThreads(__tstate);
20997 if (PyErr_Occurred()) SWIG_fail;
20998 }
20999 resultobj = SWIG_Py_Void();
21000 {
21001 if (temp2)
21002 delete arg2;
21003 }
21004 return resultobj;
21005 fail:
21006 {
21007 if (temp2)
21008 delete arg2;
21009 }
21010 return NULL;
21011 }
21012
21013
21014 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21015 PyObject *resultobj = 0;
21016 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21017 wxString *result = 0 ;
21018 void *argp1 = 0 ;
21019 int res1 = 0 ;
21020 PyObject *swig_obj[1] ;
21021
21022 if (!args) SWIG_fail;
21023 swig_obj[0] = args;
21024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21025 if (!SWIG_IsOK(res1)) {
21026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21027 }
21028 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21029 {
21030 PyThreadState* __tstate = wxPyBeginAllowThreads();
21031 {
21032 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21033 result = (wxString *) &_result_ref;
21034 }
21035 wxPyEndAllowThreads(__tstate);
21036 if (PyErr_Occurred()) SWIG_fail;
21037 }
21038 {
21039 #if wxUSE_UNICODE
21040 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21041 #else
21042 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21043 #endif
21044 }
21045 return resultobj;
21046 fail:
21047 return NULL;
21048 }
21049
21050
21051 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21052 PyObject *resultobj = 0;
21053 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21054 PyObject *result = 0 ;
21055 void *argp1 = 0 ;
21056 int res1 = 0 ;
21057 PyObject *swig_obj[1] ;
21058
21059 if (!args) SWIG_fail;
21060 swig_obj[0] = args;
21061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21062 if (!SWIG_IsOK(res1)) {
21063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21064 }
21065 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21066 {
21067 PyThreadState* __tstate = wxPyBeginAllowThreads();
21068 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21069 wxPyEndAllowThreads(__tstate);
21070 if (PyErr_Occurred()) SWIG_fail;
21071 }
21072 resultobj = result;
21073 return resultobj;
21074 fail:
21075 return NULL;
21076 }
21077
21078
21079 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21080 PyObject *resultobj = 0;
21081 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21082 long arg2 ;
21083 PyObject *result = 0 ;
21084 void *argp1 = 0 ;
21085 int res1 = 0 ;
21086 long val2 ;
21087 int ecode2 = 0 ;
21088 PyObject * obj0 = 0 ;
21089 PyObject * obj1 = 0 ;
21090 char * kwnames[] = {
21091 (char *) "self",(char *) "index", NULL
21092 };
21093
21094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21096 if (!SWIG_IsOK(res1)) {
21097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21098 }
21099 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21100 ecode2 = SWIG_AsVal_long(obj1, &val2);
21101 if (!SWIG_IsOK(ecode2)) {
21102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21103 }
21104 arg2 = static_cast< long >(val2);
21105 {
21106 PyThreadState* __tstate = wxPyBeginAllowThreads();
21107 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21108 wxPyEndAllowThreads(__tstate);
21109 if (PyErr_Occurred()) SWIG_fail;
21110 }
21111 resultobj = result;
21112 return resultobj;
21113 fail:
21114 return NULL;
21115 }
21116
21117
21118 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21119 PyObject *resultobj = 0;
21120 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21121 PyObject *result = 0 ;
21122 void *argp1 = 0 ;
21123 int res1 = 0 ;
21124 PyObject *swig_obj[1] ;
21125
21126 if (!args) SWIG_fail;
21127 swig_obj[0] = args;
21128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21129 if (!SWIG_IsOK(res1)) {
21130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21131 }
21132 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21133 {
21134 PyThreadState* __tstate = wxPyBeginAllowThreads();
21135 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21136 wxPyEndAllowThreads(__tstate);
21137 if (PyErr_Occurred()) SWIG_fail;
21138 }
21139 resultobj = result;
21140 return resultobj;
21141 fail:
21142 return NULL;
21143 }
21144
21145
21146 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21147 PyObject *resultobj = 0;
21148 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21149 long arg2 ;
21150 PyObject *result = 0 ;
21151 void *argp1 = 0 ;
21152 int res1 = 0 ;
21153 long val2 ;
21154 int ecode2 = 0 ;
21155 PyObject * obj0 = 0 ;
21156 PyObject * obj1 = 0 ;
21157 char * kwnames[] = {
21158 (char *) "self",(char *) "index", NULL
21159 };
21160
21161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21163 if (!SWIG_IsOK(res1)) {
21164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21165 }
21166 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21167 ecode2 = SWIG_AsVal_long(obj1, &val2);
21168 if (!SWIG_IsOK(ecode2)) {
21169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21170 }
21171 arg2 = static_cast< long >(val2);
21172 {
21173 PyThreadState* __tstate = wxPyBeginAllowThreads();
21174 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21175 wxPyEndAllowThreads(__tstate);
21176 if (PyErr_Occurred()) SWIG_fail;
21177 }
21178 resultobj = result;
21179 return resultobj;
21180 fail:
21181 return NULL;
21182 }
21183
21184
21185 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21186 PyObject *resultobj = 0;
21187 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21188 bool arg2 = (bool) false ;
21189 size_t result;
21190 void *argp1 = 0 ;
21191 int res1 = 0 ;
21192 bool val2 ;
21193 int ecode2 = 0 ;
21194 PyObject * obj0 = 0 ;
21195 PyObject * obj1 = 0 ;
21196 char * kwnames[] = {
21197 (char *) "self",(char *) "recursive", NULL
21198 };
21199
21200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21202 if (!SWIG_IsOK(res1)) {
21203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21204 }
21205 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21206 if (obj1) {
21207 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21208 if (!SWIG_IsOK(ecode2)) {
21209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21210 }
21211 arg2 = static_cast< bool >(val2);
21212 }
21213 {
21214 PyThreadState* __tstate = wxPyBeginAllowThreads();
21215 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21216 wxPyEndAllowThreads(__tstate);
21217 if (PyErr_Occurred()) SWIG_fail;
21218 }
21219 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21220 return resultobj;
21221 fail:
21222 return NULL;
21223 }
21224
21225
21226 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21227 PyObject *resultobj = 0;
21228 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21229 bool arg2 = (bool) false ;
21230 size_t result;
21231 void *argp1 = 0 ;
21232 int res1 = 0 ;
21233 bool val2 ;
21234 int ecode2 = 0 ;
21235 PyObject * obj0 = 0 ;
21236 PyObject * obj1 = 0 ;
21237 char * kwnames[] = {
21238 (char *) "self",(char *) "recursive", NULL
21239 };
21240
21241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21243 if (!SWIG_IsOK(res1)) {
21244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21245 }
21246 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21247 if (obj1) {
21248 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21249 if (!SWIG_IsOK(ecode2)) {
21250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21251 }
21252 arg2 = static_cast< bool >(val2);
21253 }
21254 {
21255 PyThreadState* __tstate = wxPyBeginAllowThreads();
21256 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21257 wxPyEndAllowThreads(__tstate);
21258 if (PyErr_Occurred()) SWIG_fail;
21259 }
21260 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21261 return resultobj;
21262 fail:
21263 return NULL;
21264 }
21265
21266
21267 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21268 PyObject *resultobj = 0;
21269 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21270 wxString *arg2 = 0 ;
21271 bool result;
21272 void *argp1 = 0 ;
21273 int res1 = 0 ;
21274 bool temp2 = false ;
21275 PyObject * obj0 = 0 ;
21276 PyObject * obj1 = 0 ;
21277 char * kwnames[] = {
21278 (char *) "self",(char *) "name", NULL
21279 };
21280
21281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21283 if (!SWIG_IsOK(res1)) {
21284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21285 }
21286 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21287 {
21288 arg2 = wxString_in_helper(obj1);
21289 if (arg2 == NULL) SWIG_fail;
21290 temp2 = true;
21291 }
21292 {
21293 PyThreadState* __tstate = wxPyBeginAllowThreads();
21294 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21295 wxPyEndAllowThreads(__tstate);
21296 if (PyErr_Occurred()) SWIG_fail;
21297 }
21298 {
21299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21300 }
21301 {
21302 if (temp2)
21303 delete arg2;
21304 }
21305 return resultobj;
21306 fail:
21307 {
21308 if (temp2)
21309 delete arg2;
21310 }
21311 return NULL;
21312 }
21313
21314
21315 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21316 PyObject *resultobj = 0;
21317 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21318 wxString *arg2 = 0 ;
21319 bool result;
21320 void *argp1 = 0 ;
21321 int res1 = 0 ;
21322 bool temp2 = false ;
21323 PyObject * obj0 = 0 ;
21324 PyObject * obj1 = 0 ;
21325 char * kwnames[] = {
21326 (char *) "self",(char *) "name", NULL
21327 };
21328
21329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21331 if (!SWIG_IsOK(res1)) {
21332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21333 }
21334 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21335 {
21336 arg2 = wxString_in_helper(obj1);
21337 if (arg2 == NULL) SWIG_fail;
21338 temp2 = true;
21339 }
21340 {
21341 PyThreadState* __tstate = wxPyBeginAllowThreads();
21342 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21343 wxPyEndAllowThreads(__tstate);
21344 if (PyErr_Occurred()) SWIG_fail;
21345 }
21346 {
21347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21348 }
21349 {
21350 if (temp2)
21351 delete arg2;
21352 }
21353 return resultobj;
21354 fail:
21355 {
21356 if (temp2)
21357 delete arg2;
21358 }
21359 return NULL;
21360 }
21361
21362
21363 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21364 PyObject *resultobj = 0;
21365 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21366 wxString *arg2 = 0 ;
21367 bool result;
21368 void *argp1 = 0 ;
21369 int res1 = 0 ;
21370 bool temp2 = false ;
21371 PyObject * obj0 = 0 ;
21372 PyObject * obj1 = 0 ;
21373 char * kwnames[] = {
21374 (char *) "self",(char *) "name", NULL
21375 };
21376
21377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21379 if (!SWIG_IsOK(res1)) {
21380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21381 }
21382 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21383 {
21384 arg2 = wxString_in_helper(obj1);
21385 if (arg2 == NULL) SWIG_fail;
21386 temp2 = true;
21387 }
21388 {
21389 PyThreadState* __tstate = wxPyBeginAllowThreads();
21390 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21391 wxPyEndAllowThreads(__tstate);
21392 if (PyErr_Occurred()) SWIG_fail;
21393 }
21394 {
21395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21396 }
21397 {
21398 if (temp2)
21399 delete arg2;
21400 }
21401 return resultobj;
21402 fail:
21403 {
21404 if (temp2)
21405 delete arg2;
21406 }
21407 return NULL;
21408 }
21409
21410
21411 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21412 PyObject *resultobj = 0;
21413 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21414 wxString *arg2 = 0 ;
21415 wxConfigBase::EntryType result;
21416 void *argp1 = 0 ;
21417 int res1 = 0 ;
21418 bool temp2 = false ;
21419 PyObject * obj0 = 0 ;
21420 PyObject * obj1 = 0 ;
21421 char * kwnames[] = {
21422 (char *) "self",(char *) "name", NULL
21423 };
21424
21425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21427 if (!SWIG_IsOK(res1)) {
21428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21429 }
21430 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21431 {
21432 arg2 = wxString_in_helper(obj1);
21433 if (arg2 == NULL) SWIG_fail;
21434 temp2 = true;
21435 }
21436 {
21437 PyThreadState* __tstate = wxPyBeginAllowThreads();
21438 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21439 wxPyEndAllowThreads(__tstate);
21440 if (PyErr_Occurred()) SWIG_fail;
21441 }
21442 resultobj = SWIG_From_int(static_cast< int >(result));
21443 {
21444 if (temp2)
21445 delete arg2;
21446 }
21447 return resultobj;
21448 fail:
21449 {
21450 if (temp2)
21451 delete arg2;
21452 }
21453 return NULL;
21454 }
21455
21456
21457 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21458 PyObject *resultobj = 0;
21459 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21460 wxString *arg2 = 0 ;
21461 wxString const &arg3_defvalue = wxPyEmptyString ;
21462 wxString *arg3 = (wxString *) &arg3_defvalue ;
21463 wxString result;
21464 void *argp1 = 0 ;
21465 int res1 = 0 ;
21466 bool temp2 = false ;
21467 bool temp3 = false ;
21468 PyObject * obj0 = 0 ;
21469 PyObject * obj1 = 0 ;
21470 PyObject * obj2 = 0 ;
21471 char * kwnames[] = {
21472 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21473 };
21474
21475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21477 if (!SWIG_IsOK(res1)) {
21478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21479 }
21480 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21481 {
21482 arg2 = wxString_in_helper(obj1);
21483 if (arg2 == NULL) SWIG_fail;
21484 temp2 = true;
21485 }
21486 if (obj2) {
21487 {
21488 arg3 = wxString_in_helper(obj2);
21489 if (arg3 == NULL) SWIG_fail;
21490 temp3 = true;
21491 }
21492 }
21493 {
21494 PyThreadState* __tstate = wxPyBeginAllowThreads();
21495 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21496 wxPyEndAllowThreads(__tstate);
21497 if (PyErr_Occurred()) SWIG_fail;
21498 }
21499 {
21500 #if wxUSE_UNICODE
21501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21502 #else
21503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21504 #endif
21505 }
21506 {
21507 if (temp2)
21508 delete arg2;
21509 }
21510 {
21511 if (temp3)
21512 delete arg3;
21513 }
21514 return resultobj;
21515 fail:
21516 {
21517 if (temp2)
21518 delete arg2;
21519 }
21520 {
21521 if (temp3)
21522 delete arg3;
21523 }
21524 return NULL;
21525 }
21526
21527
21528 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21529 PyObject *resultobj = 0;
21530 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21531 wxString *arg2 = 0 ;
21532 long arg3 = (long) 0 ;
21533 long result;
21534 void *argp1 = 0 ;
21535 int res1 = 0 ;
21536 bool temp2 = false ;
21537 long val3 ;
21538 int ecode3 = 0 ;
21539 PyObject * obj0 = 0 ;
21540 PyObject * obj1 = 0 ;
21541 PyObject * obj2 = 0 ;
21542 char * kwnames[] = {
21543 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21544 };
21545
21546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21548 if (!SWIG_IsOK(res1)) {
21549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21550 }
21551 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21552 {
21553 arg2 = wxString_in_helper(obj1);
21554 if (arg2 == NULL) SWIG_fail;
21555 temp2 = true;
21556 }
21557 if (obj2) {
21558 ecode3 = SWIG_AsVal_long(obj2, &val3);
21559 if (!SWIG_IsOK(ecode3)) {
21560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21561 }
21562 arg3 = static_cast< long >(val3);
21563 }
21564 {
21565 PyThreadState* __tstate = wxPyBeginAllowThreads();
21566 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21567 wxPyEndAllowThreads(__tstate);
21568 if (PyErr_Occurred()) SWIG_fail;
21569 }
21570 resultobj = SWIG_From_long(static_cast< long >(result));
21571 {
21572 if (temp2)
21573 delete arg2;
21574 }
21575 return resultobj;
21576 fail:
21577 {
21578 if (temp2)
21579 delete arg2;
21580 }
21581 return NULL;
21582 }
21583
21584
21585 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21586 PyObject *resultobj = 0;
21587 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21588 wxString *arg2 = 0 ;
21589 double arg3 = (double) 0.0 ;
21590 double result;
21591 void *argp1 = 0 ;
21592 int res1 = 0 ;
21593 bool temp2 = false ;
21594 double val3 ;
21595 int ecode3 = 0 ;
21596 PyObject * obj0 = 0 ;
21597 PyObject * obj1 = 0 ;
21598 PyObject * obj2 = 0 ;
21599 char * kwnames[] = {
21600 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21601 };
21602
21603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21605 if (!SWIG_IsOK(res1)) {
21606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21607 }
21608 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21609 {
21610 arg2 = wxString_in_helper(obj1);
21611 if (arg2 == NULL) SWIG_fail;
21612 temp2 = true;
21613 }
21614 if (obj2) {
21615 ecode3 = SWIG_AsVal_double(obj2, &val3);
21616 if (!SWIG_IsOK(ecode3)) {
21617 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21618 }
21619 arg3 = static_cast< double >(val3);
21620 }
21621 {
21622 PyThreadState* __tstate = wxPyBeginAllowThreads();
21623 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21624 wxPyEndAllowThreads(__tstate);
21625 if (PyErr_Occurred()) SWIG_fail;
21626 }
21627 resultobj = SWIG_From_double(static_cast< double >(result));
21628 {
21629 if (temp2)
21630 delete arg2;
21631 }
21632 return resultobj;
21633 fail:
21634 {
21635 if (temp2)
21636 delete arg2;
21637 }
21638 return NULL;
21639 }
21640
21641
21642 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21643 PyObject *resultobj = 0;
21644 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21645 wxString *arg2 = 0 ;
21646 bool arg3 = (bool) false ;
21647 bool result;
21648 void *argp1 = 0 ;
21649 int res1 = 0 ;
21650 bool temp2 = false ;
21651 bool val3 ;
21652 int ecode3 = 0 ;
21653 PyObject * obj0 = 0 ;
21654 PyObject * obj1 = 0 ;
21655 PyObject * obj2 = 0 ;
21656 char * kwnames[] = {
21657 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21658 };
21659
21660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21662 if (!SWIG_IsOK(res1)) {
21663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21664 }
21665 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21666 {
21667 arg2 = wxString_in_helper(obj1);
21668 if (arg2 == NULL) SWIG_fail;
21669 temp2 = true;
21670 }
21671 if (obj2) {
21672 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21673 if (!SWIG_IsOK(ecode3)) {
21674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21675 }
21676 arg3 = static_cast< bool >(val3);
21677 }
21678 {
21679 PyThreadState* __tstate = wxPyBeginAllowThreads();
21680 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21681 wxPyEndAllowThreads(__tstate);
21682 if (PyErr_Occurred()) SWIG_fail;
21683 }
21684 {
21685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21686 }
21687 {
21688 if (temp2)
21689 delete arg2;
21690 }
21691 return resultobj;
21692 fail:
21693 {
21694 if (temp2)
21695 delete arg2;
21696 }
21697 return NULL;
21698 }
21699
21700
21701 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21702 PyObject *resultobj = 0;
21703 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21704 wxString *arg2 = 0 ;
21705 wxString *arg3 = 0 ;
21706 bool result;
21707 void *argp1 = 0 ;
21708 int res1 = 0 ;
21709 bool temp2 = false ;
21710 bool temp3 = false ;
21711 PyObject * obj0 = 0 ;
21712 PyObject * obj1 = 0 ;
21713 PyObject * obj2 = 0 ;
21714 char * kwnames[] = {
21715 (char *) "self",(char *) "key",(char *) "value", NULL
21716 };
21717
21718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21720 if (!SWIG_IsOK(res1)) {
21721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21722 }
21723 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21724 {
21725 arg2 = wxString_in_helper(obj1);
21726 if (arg2 == NULL) SWIG_fail;
21727 temp2 = true;
21728 }
21729 {
21730 arg3 = wxString_in_helper(obj2);
21731 if (arg3 == NULL) SWIG_fail;
21732 temp3 = true;
21733 }
21734 {
21735 PyThreadState* __tstate = wxPyBeginAllowThreads();
21736 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21737 wxPyEndAllowThreads(__tstate);
21738 if (PyErr_Occurred()) SWIG_fail;
21739 }
21740 {
21741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21742 }
21743 {
21744 if (temp2)
21745 delete arg2;
21746 }
21747 {
21748 if (temp3)
21749 delete arg3;
21750 }
21751 return resultobj;
21752 fail:
21753 {
21754 if (temp2)
21755 delete arg2;
21756 }
21757 {
21758 if (temp3)
21759 delete arg3;
21760 }
21761 return NULL;
21762 }
21763
21764
21765 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21766 PyObject *resultobj = 0;
21767 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21768 wxString *arg2 = 0 ;
21769 long arg3 ;
21770 bool result;
21771 void *argp1 = 0 ;
21772 int res1 = 0 ;
21773 bool temp2 = false ;
21774 long val3 ;
21775 int ecode3 = 0 ;
21776 PyObject * obj0 = 0 ;
21777 PyObject * obj1 = 0 ;
21778 PyObject * obj2 = 0 ;
21779 char * kwnames[] = {
21780 (char *) "self",(char *) "key",(char *) "value", NULL
21781 };
21782
21783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21785 if (!SWIG_IsOK(res1)) {
21786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21787 }
21788 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21789 {
21790 arg2 = wxString_in_helper(obj1);
21791 if (arg2 == NULL) SWIG_fail;
21792 temp2 = true;
21793 }
21794 ecode3 = SWIG_AsVal_long(obj2, &val3);
21795 if (!SWIG_IsOK(ecode3)) {
21796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21797 }
21798 arg3 = static_cast< long >(val3);
21799 {
21800 PyThreadState* __tstate = wxPyBeginAllowThreads();
21801 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21802 wxPyEndAllowThreads(__tstate);
21803 if (PyErr_Occurred()) SWIG_fail;
21804 }
21805 {
21806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21807 }
21808 {
21809 if (temp2)
21810 delete arg2;
21811 }
21812 return resultobj;
21813 fail:
21814 {
21815 if (temp2)
21816 delete arg2;
21817 }
21818 return NULL;
21819 }
21820
21821
21822 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21823 PyObject *resultobj = 0;
21824 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21825 wxString *arg2 = 0 ;
21826 double arg3 ;
21827 bool result;
21828 void *argp1 = 0 ;
21829 int res1 = 0 ;
21830 bool temp2 = false ;
21831 double val3 ;
21832 int ecode3 = 0 ;
21833 PyObject * obj0 = 0 ;
21834 PyObject * obj1 = 0 ;
21835 PyObject * obj2 = 0 ;
21836 char * kwnames[] = {
21837 (char *) "self",(char *) "key",(char *) "value", NULL
21838 };
21839
21840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21842 if (!SWIG_IsOK(res1)) {
21843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21844 }
21845 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21846 {
21847 arg2 = wxString_in_helper(obj1);
21848 if (arg2 == NULL) SWIG_fail;
21849 temp2 = true;
21850 }
21851 ecode3 = SWIG_AsVal_double(obj2, &val3);
21852 if (!SWIG_IsOK(ecode3)) {
21853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21854 }
21855 arg3 = static_cast< double >(val3);
21856 {
21857 PyThreadState* __tstate = wxPyBeginAllowThreads();
21858 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21859 wxPyEndAllowThreads(__tstate);
21860 if (PyErr_Occurred()) SWIG_fail;
21861 }
21862 {
21863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21864 }
21865 {
21866 if (temp2)
21867 delete arg2;
21868 }
21869 return resultobj;
21870 fail:
21871 {
21872 if (temp2)
21873 delete arg2;
21874 }
21875 return NULL;
21876 }
21877
21878
21879 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21880 PyObject *resultobj = 0;
21881 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21882 wxString *arg2 = 0 ;
21883 bool arg3 ;
21884 bool result;
21885 void *argp1 = 0 ;
21886 int res1 = 0 ;
21887 bool temp2 = false ;
21888 bool val3 ;
21889 int ecode3 = 0 ;
21890 PyObject * obj0 = 0 ;
21891 PyObject * obj1 = 0 ;
21892 PyObject * obj2 = 0 ;
21893 char * kwnames[] = {
21894 (char *) "self",(char *) "key",(char *) "value", NULL
21895 };
21896
21897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21899 if (!SWIG_IsOK(res1)) {
21900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21901 }
21902 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21903 {
21904 arg2 = wxString_in_helper(obj1);
21905 if (arg2 == NULL) SWIG_fail;
21906 temp2 = true;
21907 }
21908 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21909 if (!SWIG_IsOK(ecode3)) {
21910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21911 }
21912 arg3 = static_cast< bool >(val3);
21913 {
21914 PyThreadState* __tstate = wxPyBeginAllowThreads();
21915 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21916 wxPyEndAllowThreads(__tstate);
21917 if (PyErr_Occurred()) SWIG_fail;
21918 }
21919 {
21920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21921 }
21922 {
21923 if (temp2)
21924 delete arg2;
21925 }
21926 return resultobj;
21927 fail:
21928 {
21929 if (temp2)
21930 delete arg2;
21931 }
21932 return NULL;
21933 }
21934
21935
21936 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21937 PyObject *resultobj = 0;
21938 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21939 bool arg2 = (bool) false ;
21940 bool result;
21941 void *argp1 = 0 ;
21942 int res1 = 0 ;
21943 bool val2 ;
21944 int ecode2 = 0 ;
21945 PyObject * obj0 = 0 ;
21946 PyObject * obj1 = 0 ;
21947 char * kwnames[] = {
21948 (char *) "self",(char *) "currentOnly", NULL
21949 };
21950
21951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21953 if (!SWIG_IsOK(res1)) {
21954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21955 }
21956 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21957 if (obj1) {
21958 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21959 if (!SWIG_IsOK(ecode2)) {
21960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21961 }
21962 arg2 = static_cast< bool >(val2);
21963 }
21964 {
21965 PyThreadState* __tstate = wxPyBeginAllowThreads();
21966 result = (bool)(arg1)->Flush(arg2);
21967 wxPyEndAllowThreads(__tstate);
21968 if (PyErr_Occurred()) SWIG_fail;
21969 }
21970 {
21971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21972 }
21973 return resultobj;
21974 fail:
21975 return NULL;
21976 }
21977
21978
21979 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21980 PyObject *resultobj = 0;
21981 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21982 wxString *arg2 = 0 ;
21983 wxString *arg3 = 0 ;
21984 bool result;
21985 void *argp1 = 0 ;
21986 int res1 = 0 ;
21987 bool temp2 = false ;
21988 bool temp3 = false ;
21989 PyObject * obj0 = 0 ;
21990 PyObject * obj1 = 0 ;
21991 PyObject * obj2 = 0 ;
21992 char * kwnames[] = {
21993 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21994 };
21995
21996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21998 if (!SWIG_IsOK(res1)) {
21999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22000 }
22001 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22002 {
22003 arg2 = wxString_in_helper(obj1);
22004 if (arg2 == NULL) SWIG_fail;
22005 temp2 = true;
22006 }
22007 {
22008 arg3 = wxString_in_helper(obj2);
22009 if (arg3 == NULL) SWIG_fail;
22010 temp3 = true;
22011 }
22012 {
22013 PyThreadState* __tstate = wxPyBeginAllowThreads();
22014 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
22015 wxPyEndAllowThreads(__tstate);
22016 if (PyErr_Occurred()) SWIG_fail;
22017 }
22018 {
22019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22020 }
22021 {
22022 if (temp2)
22023 delete arg2;
22024 }
22025 {
22026 if (temp3)
22027 delete arg3;
22028 }
22029 return resultobj;
22030 fail:
22031 {
22032 if (temp2)
22033 delete arg2;
22034 }
22035 {
22036 if (temp3)
22037 delete arg3;
22038 }
22039 return NULL;
22040 }
22041
22042
22043 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22044 PyObject *resultobj = 0;
22045 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22046 wxString *arg2 = 0 ;
22047 wxString *arg3 = 0 ;
22048 bool result;
22049 void *argp1 = 0 ;
22050 int res1 = 0 ;
22051 bool temp2 = false ;
22052 bool temp3 = false ;
22053 PyObject * obj0 = 0 ;
22054 PyObject * obj1 = 0 ;
22055 PyObject * obj2 = 0 ;
22056 char * kwnames[] = {
22057 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22058 };
22059
22060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22062 if (!SWIG_IsOK(res1)) {
22063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22064 }
22065 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22066 {
22067 arg2 = wxString_in_helper(obj1);
22068 if (arg2 == NULL) SWIG_fail;
22069 temp2 = true;
22070 }
22071 {
22072 arg3 = wxString_in_helper(obj2);
22073 if (arg3 == NULL) SWIG_fail;
22074 temp3 = true;
22075 }
22076 {
22077 PyThreadState* __tstate = wxPyBeginAllowThreads();
22078 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22079 wxPyEndAllowThreads(__tstate);
22080 if (PyErr_Occurred()) SWIG_fail;
22081 }
22082 {
22083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22084 }
22085 {
22086 if (temp2)
22087 delete arg2;
22088 }
22089 {
22090 if (temp3)
22091 delete arg3;
22092 }
22093 return resultobj;
22094 fail:
22095 {
22096 if (temp2)
22097 delete arg2;
22098 }
22099 {
22100 if (temp3)
22101 delete arg3;
22102 }
22103 return NULL;
22104 }
22105
22106
22107 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22108 PyObject *resultobj = 0;
22109 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22110 wxString *arg2 = 0 ;
22111 bool arg3 = (bool) true ;
22112 bool result;
22113 void *argp1 = 0 ;
22114 int res1 = 0 ;
22115 bool temp2 = false ;
22116 bool val3 ;
22117 int ecode3 = 0 ;
22118 PyObject * obj0 = 0 ;
22119 PyObject * obj1 = 0 ;
22120 PyObject * obj2 = 0 ;
22121 char * kwnames[] = {
22122 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22123 };
22124
22125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22127 if (!SWIG_IsOK(res1)) {
22128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22129 }
22130 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22131 {
22132 arg2 = wxString_in_helper(obj1);
22133 if (arg2 == NULL) SWIG_fail;
22134 temp2 = true;
22135 }
22136 if (obj2) {
22137 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22138 if (!SWIG_IsOK(ecode3)) {
22139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22140 }
22141 arg3 = static_cast< bool >(val3);
22142 }
22143 {
22144 PyThreadState* __tstate = wxPyBeginAllowThreads();
22145 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22146 wxPyEndAllowThreads(__tstate);
22147 if (PyErr_Occurred()) SWIG_fail;
22148 }
22149 {
22150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22151 }
22152 {
22153 if (temp2)
22154 delete arg2;
22155 }
22156 return resultobj;
22157 fail:
22158 {
22159 if (temp2)
22160 delete arg2;
22161 }
22162 return NULL;
22163 }
22164
22165
22166 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22167 PyObject *resultobj = 0;
22168 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22169 wxString *arg2 = 0 ;
22170 bool 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 *) "key", NULL
22178 };
22179
22180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",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_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
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 = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22194 wxPyEndAllowThreads(__tstate);
22195 if (PyErr_Occurred()) SWIG_fail;
22196 }
22197 {
22198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22199 }
22200 {
22201 if (temp2)
22202 delete arg2;
22203 }
22204 return resultobj;
22205 fail:
22206 {
22207 if (temp2)
22208 delete arg2;
22209 }
22210 return NULL;
22211 }
22212
22213
22214 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22215 PyObject *resultobj = 0;
22216 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22217 bool result;
22218 void *argp1 = 0 ;
22219 int res1 = 0 ;
22220 PyObject *swig_obj[1] ;
22221
22222 if (!args) SWIG_fail;
22223 swig_obj[0] = args;
22224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22225 if (!SWIG_IsOK(res1)) {
22226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22227 }
22228 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22229 {
22230 PyThreadState* __tstate = wxPyBeginAllowThreads();
22231 result = (bool)(arg1)->DeleteAll();
22232 wxPyEndAllowThreads(__tstate);
22233 if (PyErr_Occurred()) SWIG_fail;
22234 }
22235 {
22236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22237 }
22238 return resultobj;
22239 fail:
22240 return NULL;
22241 }
22242
22243
22244 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22245 PyObject *resultobj = 0;
22246 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22247 bool arg2 = (bool) true ;
22248 void *argp1 = 0 ;
22249 int res1 = 0 ;
22250 bool val2 ;
22251 int ecode2 = 0 ;
22252 PyObject * obj0 = 0 ;
22253 PyObject * obj1 = 0 ;
22254 char * kwnames[] = {
22255 (char *) "self",(char *) "doIt", NULL
22256 };
22257
22258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22260 if (!SWIG_IsOK(res1)) {
22261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22262 }
22263 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22264 if (obj1) {
22265 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22266 if (!SWIG_IsOK(ecode2)) {
22267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22268 }
22269 arg2 = static_cast< bool >(val2);
22270 }
22271 {
22272 PyThreadState* __tstate = wxPyBeginAllowThreads();
22273 (arg1)->SetExpandEnvVars(arg2);
22274 wxPyEndAllowThreads(__tstate);
22275 if (PyErr_Occurred()) SWIG_fail;
22276 }
22277 resultobj = SWIG_Py_Void();
22278 return resultobj;
22279 fail:
22280 return NULL;
22281 }
22282
22283
22284 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22285 PyObject *resultobj = 0;
22286 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22287 bool result;
22288 void *argp1 = 0 ;
22289 int res1 = 0 ;
22290 PyObject *swig_obj[1] ;
22291
22292 if (!args) SWIG_fail;
22293 swig_obj[0] = args;
22294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22295 if (!SWIG_IsOK(res1)) {
22296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22297 }
22298 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22299 {
22300 PyThreadState* __tstate = wxPyBeginAllowThreads();
22301 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22302 wxPyEndAllowThreads(__tstate);
22303 if (PyErr_Occurred()) SWIG_fail;
22304 }
22305 {
22306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22307 }
22308 return resultobj;
22309 fail:
22310 return NULL;
22311 }
22312
22313
22314 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22315 PyObject *resultobj = 0;
22316 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22317 bool arg2 = (bool) true ;
22318 void *argp1 = 0 ;
22319 int res1 = 0 ;
22320 bool val2 ;
22321 int ecode2 = 0 ;
22322 PyObject * obj0 = 0 ;
22323 PyObject * obj1 = 0 ;
22324 char * kwnames[] = {
22325 (char *) "self",(char *) "doIt", NULL
22326 };
22327
22328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22330 if (!SWIG_IsOK(res1)) {
22331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22332 }
22333 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22334 if (obj1) {
22335 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22336 if (!SWIG_IsOK(ecode2)) {
22337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22338 }
22339 arg2 = static_cast< bool >(val2);
22340 }
22341 {
22342 PyThreadState* __tstate = wxPyBeginAllowThreads();
22343 (arg1)->SetRecordDefaults(arg2);
22344 wxPyEndAllowThreads(__tstate);
22345 if (PyErr_Occurred()) SWIG_fail;
22346 }
22347 resultobj = SWIG_Py_Void();
22348 return resultobj;
22349 fail:
22350 return NULL;
22351 }
22352
22353
22354 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22355 PyObject *resultobj = 0;
22356 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22357 bool result;
22358 void *argp1 = 0 ;
22359 int res1 = 0 ;
22360 PyObject *swig_obj[1] ;
22361
22362 if (!args) SWIG_fail;
22363 swig_obj[0] = args;
22364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22365 if (!SWIG_IsOK(res1)) {
22366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22367 }
22368 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22369 {
22370 PyThreadState* __tstate = wxPyBeginAllowThreads();
22371 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22372 wxPyEndAllowThreads(__tstate);
22373 if (PyErr_Occurred()) SWIG_fail;
22374 }
22375 {
22376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22377 }
22378 return resultobj;
22379 fail:
22380 return NULL;
22381 }
22382
22383
22384 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22385 PyObject *resultobj = 0;
22386 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22387 wxString *arg2 = 0 ;
22388 wxString result;
22389 void *argp1 = 0 ;
22390 int res1 = 0 ;
22391 bool temp2 = false ;
22392 PyObject * obj0 = 0 ;
22393 PyObject * obj1 = 0 ;
22394 char * kwnames[] = {
22395 (char *) "self",(char *) "str", NULL
22396 };
22397
22398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22400 if (!SWIG_IsOK(res1)) {
22401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22402 }
22403 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22404 {
22405 arg2 = wxString_in_helper(obj1);
22406 if (arg2 == NULL) SWIG_fail;
22407 temp2 = true;
22408 }
22409 {
22410 PyThreadState* __tstate = wxPyBeginAllowThreads();
22411 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22412 wxPyEndAllowThreads(__tstate);
22413 if (PyErr_Occurred()) SWIG_fail;
22414 }
22415 {
22416 #if wxUSE_UNICODE
22417 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22418 #else
22419 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22420 #endif
22421 }
22422 {
22423 if (temp2)
22424 delete arg2;
22425 }
22426 return resultobj;
22427 fail:
22428 {
22429 if (temp2)
22430 delete arg2;
22431 }
22432 return NULL;
22433 }
22434
22435
22436 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22437 PyObject *resultobj = 0;
22438 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22439 wxString result;
22440 void *argp1 = 0 ;
22441 int res1 = 0 ;
22442 PyObject *swig_obj[1] ;
22443
22444 if (!args) SWIG_fail;
22445 swig_obj[0] = args;
22446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22447 if (!SWIG_IsOK(res1)) {
22448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22449 }
22450 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22451 {
22452 PyThreadState* __tstate = wxPyBeginAllowThreads();
22453 result = ((wxConfigBase const *)arg1)->GetAppName();
22454 wxPyEndAllowThreads(__tstate);
22455 if (PyErr_Occurred()) SWIG_fail;
22456 }
22457 {
22458 #if wxUSE_UNICODE
22459 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22460 #else
22461 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22462 #endif
22463 }
22464 return resultobj;
22465 fail:
22466 return NULL;
22467 }
22468
22469
22470 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22471 PyObject *resultobj = 0;
22472 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22473 wxString result;
22474 void *argp1 = 0 ;
22475 int res1 = 0 ;
22476 PyObject *swig_obj[1] ;
22477
22478 if (!args) SWIG_fail;
22479 swig_obj[0] = args;
22480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22481 if (!SWIG_IsOK(res1)) {
22482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22483 }
22484 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22485 {
22486 PyThreadState* __tstate = wxPyBeginAllowThreads();
22487 result = ((wxConfigBase const *)arg1)->GetVendorName();
22488 wxPyEndAllowThreads(__tstate);
22489 if (PyErr_Occurred()) SWIG_fail;
22490 }
22491 {
22492 #if wxUSE_UNICODE
22493 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22494 #else
22495 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22496 #endif
22497 }
22498 return resultobj;
22499 fail:
22500 return NULL;
22501 }
22502
22503
22504 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22505 PyObject *resultobj = 0;
22506 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22507 wxString *arg2 = 0 ;
22508 void *argp1 = 0 ;
22509 int res1 = 0 ;
22510 bool temp2 = false ;
22511 PyObject * obj0 = 0 ;
22512 PyObject * obj1 = 0 ;
22513 char * kwnames[] = {
22514 (char *) "self",(char *) "appName", NULL
22515 };
22516
22517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22519 if (!SWIG_IsOK(res1)) {
22520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22521 }
22522 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22523 {
22524 arg2 = wxString_in_helper(obj1);
22525 if (arg2 == NULL) SWIG_fail;
22526 temp2 = true;
22527 }
22528 {
22529 PyThreadState* __tstate = wxPyBeginAllowThreads();
22530 (arg1)->SetAppName((wxString const &)*arg2);
22531 wxPyEndAllowThreads(__tstate);
22532 if (PyErr_Occurred()) SWIG_fail;
22533 }
22534 resultobj = SWIG_Py_Void();
22535 {
22536 if (temp2)
22537 delete arg2;
22538 }
22539 return resultobj;
22540 fail:
22541 {
22542 if (temp2)
22543 delete arg2;
22544 }
22545 return NULL;
22546 }
22547
22548
22549 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22550 PyObject *resultobj = 0;
22551 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22552 wxString *arg2 = 0 ;
22553 void *argp1 = 0 ;
22554 int res1 = 0 ;
22555 bool temp2 = false ;
22556 PyObject * obj0 = 0 ;
22557 PyObject * obj1 = 0 ;
22558 char * kwnames[] = {
22559 (char *) "self",(char *) "vendorName", NULL
22560 };
22561
22562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22564 if (!SWIG_IsOK(res1)) {
22565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22566 }
22567 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22568 {
22569 arg2 = wxString_in_helper(obj1);
22570 if (arg2 == NULL) SWIG_fail;
22571 temp2 = true;
22572 }
22573 {
22574 PyThreadState* __tstate = wxPyBeginAllowThreads();
22575 (arg1)->SetVendorName((wxString const &)*arg2);
22576 wxPyEndAllowThreads(__tstate);
22577 if (PyErr_Occurred()) SWIG_fail;
22578 }
22579 resultobj = SWIG_Py_Void();
22580 {
22581 if (temp2)
22582 delete arg2;
22583 }
22584 return resultobj;
22585 fail:
22586 {
22587 if (temp2)
22588 delete arg2;
22589 }
22590 return NULL;
22591 }
22592
22593
22594 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22595 PyObject *resultobj = 0;
22596 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22597 long arg2 ;
22598 void *argp1 = 0 ;
22599 int res1 = 0 ;
22600 long val2 ;
22601 int ecode2 = 0 ;
22602 PyObject * obj0 = 0 ;
22603 PyObject * obj1 = 0 ;
22604 char * kwnames[] = {
22605 (char *) "self",(char *) "style", NULL
22606 };
22607
22608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22610 if (!SWIG_IsOK(res1)) {
22611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22612 }
22613 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22614 ecode2 = SWIG_AsVal_long(obj1, &val2);
22615 if (!SWIG_IsOK(ecode2)) {
22616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22617 }
22618 arg2 = static_cast< long >(val2);
22619 {
22620 PyThreadState* __tstate = wxPyBeginAllowThreads();
22621 (arg1)->SetStyle(arg2);
22622 wxPyEndAllowThreads(__tstate);
22623 if (PyErr_Occurred()) SWIG_fail;
22624 }
22625 resultobj = SWIG_Py_Void();
22626 return resultobj;
22627 fail:
22628 return NULL;
22629 }
22630
22631
22632 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22633 PyObject *resultobj = 0;
22634 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22635 long result;
22636 void *argp1 = 0 ;
22637 int res1 = 0 ;
22638 PyObject *swig_obj[1] ;
22639
22640 if (!args) SWIG_fail;
22641 swig_obj[0] = args;
22642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22643 if (!SWIG_IsOK(res1)) {
22644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22645 }
22646 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22647 {
22648 PyThreadState* __tstate = wxPyBeginAllowThreads();
22649 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22650 wxPyEndAllowThreads(__tstate);
22651 if (PyErr_Occurred()) SWIG_fail;
22652 }
22653 resultobj = SWIG_From_long(static_cast< long >(result));
22654 return resultobj;
22655 fail:
22656 return NULL;
22657 }
22658
22659
22660 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22661 PyObject *obj;
22662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22663 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22664 return SWIG_Py_Void();
22665 }
22666
22667 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22668 PyObject *resultobj = 0;
22669 wxString const &arg1_defvalue = wxPyEmptyString ;
22670 wxString *arg1 = (wxString *) &arg1_defvalue ;
22671 wxString const &arg2_defvalue = wxPyEmptyString ;
22672 wxString *arg2 = (wxString *) &arg2_defvalue ;
22673 wxString const &arg3_defvalue = wxPyEmptyString ;
22674 wxString *arg3 = (wxString *) &arg3_defvalue ;
22675 wxString const &arg4_defvalue = wxPyEmptyString ;
22676 wxString *arg4 = (wxString *) &arg4_defvalue ;
22677 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22678 wxConfig *result = 0 ;
22679 bool temp1 = false ;
22680 bool temp2 = false ;
22681 bool temp3 = false ;
22682 bool temp4 = false ;
22683 long val5 ;
22684 int ecode5 = 0 ;
22685 PyObject * obj0 = 0 ;
22686 PyObject * obj1 = 0 ;
22687 PyObject * obj2 = 0 ;
22688 PyObject * obj3 = 0 ;
22689 PyObject * obj4 = 0 ;
22690 char * kwnames[] = {
22691 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22692 };
22693
22694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22695 if (obj0) {
22696 {
22697 arg1 = wxString_in_helper(obj0);
22698 if (arg1 == NULL) SWIG_fail;
22699 temp1 = true;
22700 }
22701 }
22702 if (obj1) {
22703 {
22704 arg2 = wxString_in_helper(obj1);
22705 if (arg2 == NULL) SWIG_fail;
22706 temp2 = true;
22707 }
22708 }
22709 if (obj2) {
22710 {
22711 arg3 = wxString_in_helper(obj2);
22712 if (arg3 == NULL) SWIG_fail;
22713 temp3 = true;
22714 }
22715 }
22716 if (obj3) {
22717 {
22718 arg4 = wxString_in_helper(obj3);
22719 if (arg4 == NULL) SWIG_fail;
22720 temp4 = true;
22721 }
22722 }
22723 if (obj4) {
22724 ecode5 = SWIG_AsVal_long(obj4, &val5);
22725 if (!SWIG_IsOK(ecode5)) {
22726 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22727 }
22728 arg5 = static_cast< long >(val5);
22729 }
22730 {
22731 PyThreadState* __tstate = wxPyBeginAllowThreads();
22732 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22733 wxPyEndAllowThreads(__tstate);
22734 if (PyErr_Occurred()) SWIG_fail;
22735 }
22736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22737 {
22738 if (temp1)
22739 delete arg1;
22740 }
22741 {
22742 if (temp2)
22743 delete arg2;
22744 }
22745 {
22746 if (temp3)
22747 delete arg3;
22748 }
22749 {
22750 if (temp4)
22751 delete arg4;
22752 }
22753 return resultobj;
22754 fail:
22755 {
22756 if (temp1)
22757 delete arg1;
22758 }
22759 {
22760 if (temp2)
22761 delete arg2;
22762 }
22763 {
22764 if (temp3)
22765 delete arg3;
22766 }
22767 {
22768 if (temp4)
22769 delete arg4;
22770 }
22771 return NULL;
22772 }
22773
22774
22775 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22776 PyObject *resultobj = 0;
22777 wxConfig *arg1 = (wxConfig *) 0 ;
22778 void *argp1 = 0 ;
22779 int res1 = 0 ;
22780 PyObject *swig_obj[1] ;
22781
22782 if (!args) SWIG_fail;
22783 swig_obj[0] = args;
22784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22785 if (!SWIG_IsOK(res1)) {
22786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22787 }
22788 arg1 = reinterpret_cast< wxConfig * >(argp1);
22789 {
22790 PyThreadState* __tstate = wxPyBeginAllowThreads();
22791 delete arg1;
22792
22793 wxPyEndAllowThreads(__tstate);
22794 if (PyErr_Occurred()) SWIG_fail;
22795 }
22796 resultobj = SWIG_Py_Void();
22797 return resultobj;
22798 fail:
22799 return NULL;
22800 }
22801
22802
22803 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22804 PyObject *obj;
22805 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22806 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22807 return SWIG_Py_Void();
22808 }
22809
22810 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22811 return SWIG_Python_InitShadowInstance(args);
22812 }
22813
22814 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22815 PyObject *resultobj = 0;
22816 wxString const &arg1_defvalue = wxPyEmptyString ;
22817 wxString *arg1 = (wxString *) &arg1_defvalue ;
22818 wxString const &arg2_defvalue = wxPyEmptyString ;
22819 wxString *arg2 = (wxString *) &arg2_defvalue ;
22820 wxString const &arg3_defvalue = wxPyEmptyString ;
22821 wxString *arg3 = (wxString *) &arg3_defvalue ;
22822 wxString const &arg4_defvalue = wxPyEmptyString ;
22823 wxString *arg4 = (wxString *) &arg4_defvalue ;
22824 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22825 wxFileConfig *result = 0 ;
22826 bool temp1 = false ;
22827 bool temp2 = false ;
22828 bool temp3 = false ;
22829 bool temp4 = false ;
22830 long val5 ;
22831 int ecode5 = 0 ;
22832 PyObject * obj0 = 0 ;
22833 PyObject * obj1 = 0 ;
22834 PyObject * obj2 = 0 ;
22835 PyObject * obj3 = 0 ;
22836 PyObject * obj4 = 0 ;
22837 char * kwnames[] = {
22838 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22839 };
22840
22841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22842 if (obj0) {
22843 {
22844 arg1 = wxString_in_helper(obj0);
22845 if (arg1 == NULL) SWIG_fail;
22846 temp1 = true;
22847 }
22848 }
22849 if (obj1) {
22850 {
22851 arg2 = wxString_in_helper(obj1);
22852 if (arg2 == NULL) SWIG_fail;
22853 temp2 = true;
22854 }
22855 }
22856 if (obj2) {
22857 {
22858 arg3 = wxString_in_helper(obj2);
22859 if (arg3 == NULL) SWIG_fail;
22860 temp3 = true;
22861 }
22862 }
22863 if (obj3) {
22864 {
22865 arg4 = wxString_in_helper(obj3);
22866 if (arg4 == NULL) SWIG_fail;
22867 temp4 = true;
22868 }
22869 }
22870 if (obj4) {
22871 ecode5 = SWIG_AsVal_long(obj4, &val5);
22872 if (!SWIG_IsOK(ecode5)) {
22873 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22874 }
22875 arg5 = static_cast< long >(val5);
22876 }
22877 {
22878 PyThreadState* __tstate = wxPyBeginAllowThreads();
22879 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22880 wxPyEndAllowThreads(__tstate);
22881 if (PyErr_Occurred()) SWIG_fail;
22882 }
22883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22884 {
22885 if (temp1)
22886 delete arg1;
22887 }
22888 {
22889 if (temp2)
22890 delete arg2;
22891 }
22892 {
22893 if (temp3)
22894 delete arg3;
22895 }
22896 {
22897 if (temp4)
22898 delete arg4;
22899 }
22900 return resultobj;
22901 fail:
22902 {
22903 if (temp1)
22904 delete arg1;
22905 }
22906 {
22907 if (temp2)
22908 delete arg2;
22909 }
22910 {
22911 if (temp3)
22912 delete arg3;
22913 }
22914 {
22915 if (temp4)
22916 delete arg4;
22917 }
22918 return NULL;
22919 }
22920
22921
22922 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22923 PyObject *resultobj = 0;
22924 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22925 void *argp1 = 0 ;
22926 int res1 = 0 ;
22927 PyObject *swig_obj[1] ;
22928
22929 if (!args) SWIG_fail;
22930 swig_obj[0] = args;
22931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22932 if (!SWIG_IsOK(res1)) {
22933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22934 }
22935 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22936 {
22937 PyThreadState* __tstate = wxPyBeginAllowThreads();
22938 delete arg1;
22939
22940 wxPyEndAllowThreads(__tstate);
22941 if (PyErr_Occurred()) SWIG_fail;
22942 }
22943 resultobj = SWIG_Py_Void();
22944 return resultobj;
22945 fail:
22946 return NULL;
22947 }
22948
22949
22950 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22951 PyObject *obj;
22952 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22953 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22954 return SWIG_Py_Void();
22955 }
22956
22957 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22958 return SWIG_Python_InitShadowInstance(args);
22959 }
22960
22961 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22962 PyObject *resultobj = 0;
22963 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22964 wxString *arg2 = 0 ;
22965 wxConfigPathChanger *result = 0 ;
22966 void *argp1 = 0 ;
22967 int res1 = 0 ;
22968 bool temp2 = false ;
22969 PyObject * obj0 = 0 ;
22970 PyObject * obj1 = 0 ;
22971 char * kwnames[] = {
22972 (char *) "config",(char *) "entry", NULL
22973 };
22974
22975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22977 if (!SWIG_IsOK(res1)) {
22978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22979 }
22980 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22981 {
22982 arg2 = wxString_in_helper(obj1);
22983 if (arg2 == NULL) SWIG_fail;
22984 temp2 = true;
22985 }
22986 {
22987 PyThreadState* __tstate = wxPyBeginAllowThreads();
22988 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22989 wxPyEndAllowThreads(__tstate);
22990 if (PyErr_Occurred()) SWIG_fail;
22991 }
22992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
22993 {
22994 if (temp2)
22995 delete arg2;
22996 }
22997 return resultobj;
22998 fail:
22999 {
23000 if (temp2)
23001 delete arg2;
23002 }
23003 return NULL;
23004 }
23005
23006
23007 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23008 PyObject *resultobj = 0;
23009 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23010 void *argp1 = 0 ;
23011 int res1 = 0 ;
23012 PyObject *swig_obj[1] ;
23013
23014 if (!args) SWIG_fail;
23015 swig_obj[0] = args;
23016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23017 if (!SWIG_IsOK(res1)) {
23018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23019 }
23020 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23021 {
23022 PyThreadState* __tstate = wxPyBeginAllowThreads();
23023 delete arg1;
23024
23025 wxPyEndAllowThreads(__tstate);
23026 if (PyErr_Occurred()) SWIG_fail;
23027 }
23028 resultobj = SWIG_Py_Void();
23029 return resultobj;
23030 fail:
23031 return NULL;
23032 }
23033
23034
23035 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23036 PyObject *resultobj = 0;
23037 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23038 wxString *result = 0 ;
23039 void *argp1 = 0 ;
23040 int res1 = 0 ;
23041 PyObject *swig_obj[1] ;
23042
23043 if (!args) SWIG_fail;
23044 swig_obj[0] = args;
23045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23046 if (!SWIG_IsOK(res1)) {
23047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23048 }
23049 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23050 {
23051 PyThreadState* __tstate = wxPyBeginAllowThreads();
23052 {
23053 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23054 result = (wxString *) &_result_ref;
23055 }
23056 wxPyEndAllowThreads(__tstate);
23057 if (PyErr_Occurred()) SWIG_fail;
23058 }
23059 {
23060 #if wxUSE_UNICODE
23061 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23062 #else
23063 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23064 #endif
23065 }
23066 return resultobj;
23067 fail:
23068 return NULL;
23069 }
23070
23071
23072 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23073 PyObject *obj;
23074 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23075 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23076 return SWIG_Py_Void();
23077 }
23078
23079 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23080 return SWIG_Python_InitShadowInstance(args);
23081 }
23082
23083 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23084 PyObject *resultobj = 0;
23085 wxString *arg1 = 0 ;
23086 wxString result;
23087 bool temp1 = false ;
23088 PyObject * obj0 = 0 ;
23089 char * kwnames[] = {
23090 (char *) "sz", NULL
23091 };
23092
23093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23094 {
23095 arg1 = wxString_in_helper(obj0);
23096 if (arg1 == NULL) SWIG_fail;
23097 temp1 = true;
23098 }
23099 {
23100 PyThreadState* __tstate = wxPyBeginAllowThreads();
23101 result = wxExpandEnvVars((wxString const &)*arg1);
23102 wxPyEndAllowThreads(__tstate);
23103 if (PyErr_Occurred()) SWIG_fail;
23104 }
23105 {
23106 #if wxUSE_UNICODE
23107 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23108 #else
23109 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23110 #endif
23111 }
23112 {
23113 if (temp1)
23114 delete arg1;
23115 }
23116 return resultobj;
23117 fail:
23118 {
23119 if (temp1)
23120 delete arg1;
23121 }
23122 return NULL;
23123 }
23124
23125
23126 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23127 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23128 return 1;
23129 }
23130
23131
23132 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23133 PyObject *pyobj = 0;
23134
23135 {
23136 #if wxUSE_UNICODE
23137 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23138 #else
23139 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23140 #endif
23141 }
23142 return pyobj;
23143 }
23144
23145
23146 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23147 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23148 return 1;
23149 }
23150
23151
23152 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23153 PyObject *pyobj = 0;
23154
23155 {
23156 #if wxUSE_UNICODE
23157 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23158 #else
23159 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23160 #endif
23161 }
23162 return pyobj;
23163 }
23164
23165
23166 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23167 PyObject *resultobj = 0;
23168 wxDateTime::Country arg1 ;
23169 int val1 ;
23170 int ecode1 = 0 ;
23171 PyObject * obj0 = 0 ;
23172 char * kwnames[] = {
23173 (char *) "country", NULL
23174 };
23175
23176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23177 ecode1 = SWIG_AsVal_int(obj0, &val1);
23178 if (!SWIG_IsOK(ecode1)) {
23179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23180 }
23181 arg1 = static_cast< wxDateTime::Country >(val1);
23182 {
23183 PyThreadState* __tstate = wxPyBeginAllowThreads();
23184 wxDateTime::SetCountry(arg1);
23185 wxPyEndAllowThreads(__tstate);
23186 if (PyErr_Occurred()) SWIG_fail;
23187 }
23188 resultobj = SWIG_Py_Void();
23189 return resultobj;
23190 fail:
23191 return NULL;
23192 }
23193
23194
23195 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23196 PyObject *resultobj = 0;
23197 wxDateTime::Country result;
23198
23199 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23200 {
23201 PyThreadState* __tstate = wxPyBeginAllowThreads();
23202 result = (wxDateTime::Country)wxDateTime::GetCountry();
23203 wxPyEndAllowThreads(__tstate);
23204 if (PyErr_Occurred()) SWIG_fail;
23205 }
23206 resultobj = SWIG_From_int(static_cast< int >(result));
23207 return resultobj;
23208 fail:
23209 return NULL;
23210 }
23211
23212
23213 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23214 PyObject *resultobj = 0;
23215 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23216 bool result;
23217 int val1 ;
23218 int ecode1 = 0 ;
23219 PyObject * obj0 = 0 ;
23220 char * kwnames[] = {
23221 (char *) "country", NULL
23222 };
23223
23224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23225 if (obj0) {
23226 ecode1 = SWIG_AsVal_int(obj0, &val1);
23227 if (!SWIG_IsOK(ecode1)) {
23228 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23229 }
23230 arg1 = static_cast< wxDateTime::Country >(val1);
23231 }
23232 {
23233 PyThreadState* __tstate = wxPyBeginAllowThreads();
23234 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23235 wxPyEndAllowThreads(__tstate);
23236 if (PyErr_Occurred()) SWIG_fail;
23237 }
23238 {
23239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23240 }
23241 return resultobj;
23242 fail:
23243 return NULL;
23244 }
23245
23246
23247 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23248 PyObject *resultobj = 0;
23249 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23250 int result;
23251 int val1 ;
23252 int ecode1 = 0 ;
23253 PyObject * obj0 = 0 ;
23254 char * kwnames[] = {
23255 (char *) "cal", NULL
23256 };
23257
23258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23259 if (obj0) {
23260 ecode1 = SWIG_AsVal_int(obj0, &val1);
23261 if (!SWIG_IsOK(ecode1)) {
23262 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23263 }
23264 arg1 = static_cast< wxDateTime::Calendar >(val1);
23265 }
23266 {
23267 PyThreadState* __tstate = wxPyBeginAllowThreads();
23268 result = (int)wxDateTime::GetCurrentYear(arg1);
23269 wxPyEndAllowThreads(__tstate);
23270 if (PyErr_Occurred()) SWIG_fail;
23271 }
23272 resultobj = SWIG_From_int(static_cast< int >(result));
23273 return resultobj;
23274 fail:
23275 return NULL;
23276 }
23277
23278
23279 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23280 PyObject *resultobj = 0;
23281 int arg1 ;
23282 int result;
23283 int val1 ;
23284 int ecode1 = 0 ;
23285 PyObject * obj0 = 0 ;
23286 char * kwnames[] = {
23287 (char *) "year", NULL
23288 };
23289
23290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23291 ecode1 = SWIG_AsVal_int(obj0, &val1);
23292 if (!SWIG_IsOK(ecode1)) {
23293 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23294 }
23295 arg1 = static_cast< int >(val1);
23296 {
23297 PyThreadState* __tstate = wxPyBeginAllowThreads();
23298 result = (int)wxDateTime::ConvertYearToBC(arg1);
23299 wxPyEndAllowThreads(__tstate);
23300 if (PyErr_Occurred()) SWIG_fail;
23301 }
23302 resultobj = SWIG_From_int(static_cast< int >(result));
23303 return resultobj;
23304 fail:
23305 return NULL;
23306 }
23307
23308
23309 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23310 PyObject *resultobj = 0;
23311 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23312 wxDateTime::Month result;
23313 int val1 ;
23314 int ecode1 = 0 ;
23315 PyObject * obj0 = 0 ;
23316 char * kwnames[] = {
23317 (char *) "cal", NULL
23318 };
23319
23320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23321 if (obj0) {
23322 ecode1 = SWIG_AsVal_int(obj0, &val1);
23323 if (!SWIG_IsOK(ecode1)) {
23324 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23325 }
23326 arg1 = static_cast< wxDateTime::Calendar >(val1);
23327 }
23328 {
23329 PyThreadState* __tstate = wxPyBeginAllowThreads();
23330 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23331 wxPyEndAllowThreads(__tstate);
23332 if (PyErr_Occurred()) SWIG_fail;
23333 }
23334 resultobj = SWIG_From_int(static_cast< int >(result));
23335 return resultobj;
23336 fail:
23337 return NULL;
23338 }
23339
23340
23341 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23342 PyObject *resultobj = 0;
23343 int arg1 = (int) wxDateTime::Inv_Year ;
23344 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23345 bool result;
23346 int val1 ;
23347 int ecode1 = 0 ;
23348 int val2 ;
23349 int ecode2 = 0 ;
23350 PyObject * obj0 = 0 ;
23351 PyObject * obj1 = 0 ;
23352 char * kwnames[] = {
23353 (char *) "year",(char *) "cal", NULL
23354 };
23355
23356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23357 if (obj0) {
23358 ecode1 = SWIG_AsVal_int(obj0, &val1);
23359 if (!SWIG_IsOK(ecode1)) {
23360 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23361 }
23362 arg1 = static_cast< int >(val1);
23363 }
23364 if (obj1) {
23365 ecode2 = SWIG_AsVal_int(obj1, &val2);
23366 if (!SWIG_IsOK(ecode2)) {
23367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23368 }
23369 arg2 = static_cast< wxDateTime::Calendar >(val2);
23370 }
23371 {
23372 PyThreadState* __tstate = wxPyBeginAllowThreads();
23373 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23374 wxPyEndAllowThreads(__tstate);
23375 if (PyErr_Occurred()) SWIG_fail;
23376 }
23377 {
23378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23379 }
23380 return resultobj;
23381 fail:
23382 return NULL;
23383 }
23384
23385
23386 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23387 PyObject *resultobj = 0;
23388 int arg1 = (int) wxDateTime::Inv_Year ;
23389 int result;
23390 int val1 ;
23391 int ecode1 = 0 ;
23392 PyObject * obj0 = 0 ;
23393 char * kwnames[] = {
23394 (char *) "year", NULL
23395 };
23396
23397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23398 if (obj0) {
23399 ecode1 = SWIG_AsVal_int(obj0, &val1);
23400 if (!SWIG_IsOK(ecode1)) {
23401 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23402 }
23403 arg1 = static_cast< int >(val1);
23404 }
23405 {
23406 PyThreadState* __tstate = wxPyBeginAllowThreads();
23407 result = (int)wxDateTime::GetCentury(arg1);
23408 wxPyEndAllowThreads(__tstate);
23409 if (PyErr_Occurred()) SWIG_fail;
23410 }
23411 resultobj = SWIG_From_int(static_cast< int >(result));
23412 return resultobj;
23413 fail:
23414 return NULL;
23415 }
23416
23417
23418 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23419 PyObject *resultobj = 0;
23420 int arg1 ;
23421 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23422 int result;
23423 int val1 ;
23424 int ecode1 = 0 ;
23425 int val2 ;
23426 int ecode2 = 0 ;
23427 PyObject * obj0 = 0 ;
23428 PyObject * obj1 = 0 ;
23429 char * kwnames[] = {
23430 (char *) "year",(char *) "cal", NULL
23431 };
23432
23433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23434 ecode1 = SWIG_AsVal_int(obj0, &val1);
23435 if (!SWIG_IsOK(ecode1)) {
23436 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23437 }
23438 arg1 = static_cast< int >(val1);
23439 if (obj1) {
23440 ecode2 = SWIG_AsVal_int(obj1, &val2);
23441 if (!SWIG_IsOK(ecode2)) {
23442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23443 }
23444 arg2 = static_cast< wxDateTime::Calendar >(val2);
23445 }
23446 {
23447 PyThreadState* __tstate = wxPyBeginAllowThreads();
23448 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23449 wxPyEndAllowThreads(__tstate);
23450 if (PyErr_Occurred()) SWIG_fail;
23451 }
23452 resultobj = SWIG_From_int(static_cast< int >(result));
23453 return resultobj;
23454 fail:
23455 return NULL;
23456 }
23457
23458
23459 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23460 PyObject *resultobj = 0;
23461 wxDateTime::Month arg1 ;
23462 int arg2 = (int) wxDateTime::Inv_Year ;
23463 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23464 int result;
23465 int val1 ;
23466 int ecode1 = 0 ;
23467 int val2 ;
23468 int ecode2 = 0 ;
23469 int val3 ;
23470 int ecode3 = 0 ;
23471 PyObject * obj0 = 0 ;
23472 PyObject * obj1 = 0 ;
23473 PyObject * obj2 = 0 ;
23474 char * kwnames[] = {
23475 (char *) "month",(char *) "year",(char *) "cal", NULL
23476 };
23477
23478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23479 ecode1 = SWIG_AsVal_int(obj0, &val1);
23480 if (!SWIG_IsOK(ecode1)) {
23481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23482 }
23483 arg1 = static_cast< wxDateTime::Month >(val1);
23484 if (obj1) {
23485 ecode2 = SWIG_AsVal_int(obj1, &val2);
23486 if (!SWIG_IsOK(ecode2)) {
23487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23488 }
23489 arg2 = static_cast< int >(val2);
23490 }
23491 if (obj2) {
23492 ecode3 = SWIG_AsVal_int(obj2, &val3);
23493 if (!SWIG_IsOK(ecode3)) {
23494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23495 }
23496 arg3 = static_cast< wxDateTime::Calendar >(val3);
23497 }
23498 {
23499 PyThreadState* __tstate = wxPyBeginAllowThreads();
23500 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23501 wxPyEndAllowThreads(__tstate);
23502 if (PyErr_Occurred()) SWIG_fail;
23503 }
23504 resultobj = SWIG_From_int(static_cast< int >(result));
23505 return resultobj;
23506 fail:
23507 return NULL;
23508 }
23509
23510
23511 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23512 PyObject *resultobj = 0;
23513 wxDateTime::Month arg1 ;
23514 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23515 wxString result;
23516 int val1 ;
23517 int ecode1 = 0 ;
23518 int val2 ;
23519 int ecode2 = 0 ;
23520 PyObject * obj0 = 0 ;
23521 PyObject * obj1 = 0 ;
23522 char * kwnames[] = {
23523 (char *) "month",(char *) "flags", NULL
23524 };
23525
23526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23527 ecode1 = SWIG_AsVal_int(obj0, &val1);
23528 if (!SWIG_IsOK(ecode1)) {
23529 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23530 }
23531 arg1 = static_cast< wxDateTime::Month >(val1);
23532 if (obj1) {
23533 ecode2 = SWIG_AsVal_int(obj1, &val2);
23534 if (!SWIG_IsOK(ecode2)) {
23535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23536 }
23537 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23538 }
23539 {
23540 PyThreadState* __tstate = wxPyBeginAllowThreads();
23541 result = wxDateTime::GetMonthName(arg1,arg2);
23542 wxPyEndAllowThreads(__tstate);
23543 if (PyErr_Occurred()) SWIG_fail;
23544 }
23545 {
23546 #if wxUSE_UNICODE
23547 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23548 #else
23549 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23550 #endif
23551 }
23552 return resultobj;
23553 fail:
23554 return NULL;
23555 }
23556
23557
23558 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23559 PyObject *resultobj = 0;
23560 wxDateTime::WeekDay arg1 ;
23561 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23562 wxString result;
23563 int val1 ;
23564 int ecode1 = 0 ;
23565 int val2 ;
23566 int ecode2 = 0 ;
23567 PyObject * obj0 = 0 ;
23568 PyObject * obj1 = 0 ;
23569 char * kwnames[] = {
23570 (char *) "weekday",(char *) "flags", NULL
23571 };
23572
23573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23574 ecode1 = SWIG_AsVal_int(obj0, &val1);
23575 if (!SWIG_IsOK(ecode1)) {
23576 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23577 }
23578 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23579 if (obj1) {
23580 ecode2 = SWIG_AsVal_int(obj1, &val2);
23581 if (!SWIG_IsOK(ecode2)) {
23582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23583 }
23584 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23585 }
23586 {
23587 PyThreadState* __tstate = wxPyBeginAllowThreads();
23588 result = wxDateTime::GetWeekDayName(arg1,arg2);
23589 wxPyEndAllowThreads(__tstate);
23590 if (PyErr_Occurred()) SWIG_fail;
23591 }
23592 {
23593 #if wxUSE_UNICODE
23594 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23595 #else
23596 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23597 #endif
23598 }
23599 return resultobj;
23600 fail:
23601 return NULL;
23602 }
23603
23604
23605 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23606 PyObject *resultobj = 0;
23607 PyObject *result = 0 ;
23608
23609 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23610 {
23611 PyThreadState* __tstate = wxPyBeginAllowThreads();
23612 result = (PyObject *)wxDateTime_GetAmPmStrings();
23613 wxPyEndAllowThreads(__tstate);
23614 if (PyErr_Occurred()) SWIG_fail;
23615 }
23616 resultobj = result;
23617 return resultobj;
23618 fail:
23619 return NULL;
23620 }
23621
23622
23623 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23624 PyObject *resultobj = 0;
23625 int arg1 = (int) wxDateTime::Inv_Year ;
23626 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23627 bool result;
23628 int val1 ;
23629 int ecode1 = 0 ;
23630 int val2 ;
23631 int ecode2 = 0 ;
23632 PyObject * obj0 = 0 ;
23633 PyObject * obj1 = 0 ;
23634 char * kwnames[] = {
23635 (char *) "year",(char *) "country", NULL
23636 };
23637
23638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23639 if (obj0) {
23640 ecode1 = SWIG_AsVal_int(obj0, &val1);
23641 if (!SWIG_IsOK(ecode1)) {
23642 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23643 }
23644 arg1 = static_cast< int >(val1);
23645 }
23646 if (obj1) {
23647 ecode2 = SWIG_AsVal_int(obj1, &val2);
23648 if (!SWIG_IsOK(ecode2)) {
23649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23650 }
23651 arg2 = static_cast< wxDateTime::Country >(val2);
23652 }
23653 {
23654 PyThreadState* __tstate = wxPyBeginAllowThreads();
23655 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23656 wxPyEndAllowThreads(__tstate);
23657 if (PyErr_Occurred()) SWIG_fail;
23658 }
23659 {
23660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23661 }
23662 return resultobj;
23663 fail:
23664 return NULL;
23665 }
23666
23667
23668 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23669 PyObject *resultobj = 0;
23670 int arg1 = (int) wxDateTime::Inv_Year ;
23671 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23672 wxDateTime result;
23673 int val1 ;
23674 int ecode1 = 0 ;
23675 int val2 ;
23676 int ecode2 = 0 ;
23677 PyObject * obj0 = 0 ;
23678 PyObject * obj1 = 0 ;
23679 char * kwnames[] = {
23680 (char *) "year",(char *) "country", NULL
23681 };
23682
23683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23684 if (obj0) {
23685 ecode1 = SWIG_AsVal_int(obj0, &val1);
23686 if (!SWIG_IsOK(ecode1)) {
23687 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23688 }
23689 arg1 = static_cast< int >(val1);
23690 }
23691 if (obj1) {
23692 ecode2 = SWIG_AsVal_int(obj1, &val2);
23693 if (!SWIG_IsOK(ecode2)) {
23694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23695 }
23696 arg2 = static_cast< wxDateTime::Country >(val2);
23697 }
23698 {
23699 PyThreadState* __tstate = wxPyBeginAllowThreads();
23700 result = wxDateTime::GetBeginDST(arg1,arg2);
23701 wxPyEndAllowThreads(__tstate);
23702 if (PyErr_Occurred()) SWIG_fail;
23703 }
23704 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23705 return resultobj;
23706 fail:
23707 return NULL;
23708 }
23709
23710
23711 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23712 PyObject *resultobj = 0;
23713 int arg1 = (int) wxDateTime::Inv_Year ;
23714 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23715 wxDateTime result;
23716 int val1 ;
23717 int ecode1 = 0 ;
23718 int val2 ;
23719 int ecode2 = 0 ;
23720 PyObject * obj0 = 0 ;
23721 PyObject * obj1 = 0 ;
23722 char * kwnames[] = {
23723 (char *) "year",(char *) "country", NULL
23724 };
23725
23726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23727 if (obj0) {
23728 ecode1 = SWIG_AsVal_int(obj0, &val1);
23729 if (!SWIG_IsOK(ecode1)) {
23730 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23731 }
23732 arg1 = static_cast< int >(val1);
23733 }
23734 if (obj1) {
23735 ecode2 = SWIG_AsVal_int(obj1, &val2);
23736 if (!SWIG_IsOK(ecode2)) {
23737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23738 }
23739 arg2 = static_cast< wxDateTime::Country >(val2);
23740 }
23741 {
23742 PyThreadState* __tstate = wxPyBeginAllowThreads();
23743 result = wxDateTime::GetEndDST(arg1,arg2);
23744 wxPyEndAllowThreads(__tstate);
23745 if (PyErr_Occurred()) SWIG_fail;
23746 }
23747 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23748 return resultobj;
23749 fail:
23750 return NULL;
23751 }
23752
23753
23754 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23755 PyObject *resultobj = 0;
23756 wxDateTime result;
23757
23758 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23759 {
23760 PyThreadState* __tstate = wxPyBeginAllowThreads();
23761 result = wxDateTime::Now();
23762 wxPyEndAllowThreads(__tstate);
23763 if (PyErr_Occurred()) SWIG_fail;
23764 }
23765 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23766 return resultobj;
23767 fail:
23768 return NULL;
23769 }
23770
23771
23772 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23773 PyObject *resultobj = 0;
23774 wxDateTime result;
23775
23776 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23777 {
23778 PyThreadState* __tstate = wxPyBeginAllowThreads();
23779 result = wxDateTime::UNow();
23780 wxPyEndAllowThreads(__tstate);
23781 if (PyErr_Occurred()) SWIG_fail;
23782 }
23783 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23784 return resultobj;
23785 fail:
23786 return NULL;
23787 }
23788
23789
23790 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23791 PyObject *resultobj = 0;
23792 wxDateTime result;
23793
23794 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23795 {
23796 PyThreadState* __tstate = wxPyBeginAllowThreads();
23797 result = wxDateTime::Today();
23798 wxPyEndAllowThreads(__tstate);
23799 if (PyErr_Occurred()) SWIG_fail;
23800 }
23801 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23802 return resultobj;
23803 fail:
23804 return NULL;
23805 }
23806
23807
23808 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23809 PyObject *resultobj = 0;
23810 wxDateTime *result = 0 ;
23811
23812 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23813 {
23814 PyThreadState* __tstate = wxPyBeginAllowThreads();
23815 result = (wxDateTime *)new wxDateTime();
23816 wxPyEndAllowThreads(__tstate);
23817 if (PyErr_Occurred()) SWIG_fail;
23818 }
23819 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23820 return resultobj;
23821 fail:
23822 return NULL;
23823 }
23824
23825
23826 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23827 PyObject *resultobj = 0;
23828 time_t arg1 ;
23829 wxDateTime *result = 0 ;
23830 unsigned int val1 ;
23831 int ecode1 = 0 ;
23832 PyObject * obj0 = 0 ;
23833 char * kwnames[] = {
23834 (char *) "timet", NULL
23835 };
23836
23837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23838 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23839 if (!SWIG_IsOK(ecode1)) {
23840 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23841 }
23842 arg1 = static_cast< time_t >(val1);
23843 {
23844 PyThreadState* __tstate = wxPyBeginAllowThreads();
23845 result = (wxDateTime *)new wxDateTime(arg1);
23846 wxPyEndAllowThreads(__tstate);
23847 if (PyErr_Occurred()) SWIG_fail;
23848 }
23849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23850 return resultobj;
23851 fail:
23852 return NULL;
23853 }
23854
23855
23856 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23857 PyObject *resultobj = 0;
23858 double arg1 ;
23859 wxDateTime *result = 0 ;
23860 double val1 ;
23861 int ecode1 = 0 ;
23862 PyObject * obj0 = 0 ;
23863 char * kwnames[] = {
23864 (char *) "jdn", NULL
23865 };
23866
23867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23868 ecode1 = SWIG_AsVal_double(obj0, &val1);
23869 if (!SWIG_IsOK(ecode1)) {
23870 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23871 }
23872 arg1 = static_cast< double >(val1);
23873 {
23874 PyThreadState* __tstate = wxPyBeginAllowThreads();
23875 result = (wxDateTime *)new wxDateTime(arg1);
23876 wxPyEndAllowThreads(__tstate);
23877 if (PyErr_Occurred()) SWIG_fail;
23878 }
23879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23880 return resultobj;
23881 fail:
23882 return NULL;
23883 }
23884
23885
23886 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23887 PyObject *resultobj = 0;
23888 int arg1 ;
23889 int arg2 = (int) 0 ;
23890 int arg3 = (int) 0 ;
23891 int arg4 = (int) 0 ;
23892 wxDateTime *result = 0 ;
23893 int val1 ;
23894 int ecode1 = 0 ;
23895 int val2 ;
23896 int ecode2 = 0 ;
23897 int val3 ;
23898 int ecode3 = 0 ;
23899 int val4 ;
23900 int ecode4 = 0 ;
23901 PyObject * obj0 = 0 ;
23902 PyObject * obj1 = 0 ;
23903 PyObject * obj2 = 0 ;
23904 PyObject * obj3 = 0 ;
23905 char * kwnames[] = {
23906 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23907 };
23908
23909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23910 ecode1 = SWIG_AsVal_int(obj0, &val1);
23911 if (!SWIG_IsOK(ecode1)) {
23912 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23913 }
23914 arg1 = static_cast< int >(val1);
23915 if (obj1) {
23916 ecode2 = SWIG_AsVal_int(obj1, &val2);
23917 if (!SWIG_IsOK(ecode2)) {
23918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23919 }
23920 arg2 = static_cast< int >(val2);
23921 }
23922 if (obj2) {
23923 ecode3 = SWIG_AsVal_int(obj2, &val3);
23924 if (!SWIG_IsOK(ecode3)) {
23925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23926 }
23927 arg3 = static_cast< int >(val3);
23928 }
23929 if (obj3) {
23930 ecode4 = SWIG_AsVal_int(obj3, &val4);
23931 if (!SWIG_IsOK(ecode4)) {
23932 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23933 }
23934 arg4 = static_cast< int >(val4);
23935 }
23936 {
23937 PyThreadState* __tstate = wxPyBeginAllowThreads();
23938 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23939 wxPyEndAllowThreads(__tstate);
23940 if (PyErr_Occurred()) SWIG_fail;
23941 }
23942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23943 return resultobj;
23944 fail:
23945 return NULL;
23946 }
23947
23948
23949 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23950 PyObject *resultobj = 0;
23951 int arg1 ;
23952 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23953 int arg3 = (int) wxDateTime::Inv_Year ;
23954 int arg4 = (int) 0 ;
23955 int arg5 = (int) 0 ;
23956 int arg6 = (int) 0 ;
23957 int arg7 = (int) 0 ;
23958 wxDateTime *result = 0 ;
23959 int val1 ;
23960 int ecode1 = 0 ;
23961 int val2 ;
23962 int ecode2 = 0 ;
23963 int val3 ;
23964 int ecode3 = 0 ;
23965 int val4 ;
23966 int ecode4 = 0 ;
23967 int val5 ;
23968 int ecode5 = 0 ;
23969 int val6 ;
23970 int ecode6 = 0 ;
23971 int val7 ;
23972 int ecode7 = 0 ;
23973 PyObject * obj0 = 0 ;
23974 PyObject * obj1 = 0 ;
23975 PyObject * obj2 = 0 ;
23976 PyObject * obj3 = 0 ;
23977 PyObject * obj4 = 0 ;
23978 PyObject * obj5 = 0 ;
23979 PyObject * obj6 = 0 ;
23980 char * kwnames[] = {
23981 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23982 };
23983
23984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23985 ecode1 = SWIG_AsVal_int(obj0, &val1);
23986 if (!SWIG_IsOK(ecode1)) {
23987 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23988 }
23989 arg1 = static_cast< int >(val1);
23990 if (obj1) {
23991 ecode2 = SWIG_AsVal_int(obj1, &val2);
23992 if (!SWIG_IsOK(ecode2)) {
23993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23994 }
23995 arg2 = static_cast< wxDateTime::Month >(val2);
23996 }
23997 if (obj2) {
23998 ecode3 = SWIG_AsVal_int(obj2, &val3);
23999 if (!SWIG_IsOK(ecode3)) {
24000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24001 }
24002 arg3 = static_cast< int >(val3);
24003 }
24004 if (obj3) {
24005 ecode4 = SWIG_AsVal_int(obj3, &val4);
24006 if (!SWIG_IsOK(ecode4)) {
24007 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24008 }
24009 arg4 = static_cast< int >(val4);
24010 }
24011 if (obj4) {
24012 ecode5 = SWIG_AsVal_int(obj4, &val5);
24013 if (!SWIG_IsOK(ecode5)) {
24014 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24015 }
24016 arg5 = static_cast< int >(val5);
24017 }
24018 if (obj5) {
24019 ecode6 = SWIG_AsVal_int(obj5, &val6);
24020 if (!SWIG_IsOK(ecode6)) {
24021 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24022 }
24023 arg6 = static_cast< int >(val6);
24024 }
24025 if (obj6) {
24026 ecode7 = SWIG_AsVal_int(obj6, &val7);
24027 if (!SWIG_IsOK(ecode7)) {
24028 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24029 }
24030 arg7 = static_cast< int >(val7);
24031 }
24032 {
24033 PyThreadState* __tstate = wxPyBeginAllowThreads();
24034 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24035 wxPyEndAllowThreads(__tstate);
24036 if (PyErr_Occurred()) SWIG_fail;
24037 }
24038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24039 return resultobj;
24040 fail:
24041 return NULL;
24042 }
24043
24044
24045 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24046 PyObject *resultobj = 0;
24047 wxDateTime *arg1 = 0 ;
24048 wxDateTime *result = 0 ;
24049 void *argp1 = 0 ;
24050 int res1 = 0 ;
24051 PyObject * obj0 = 0 ;
24052 char * kwnames[] = {
24053 (char *) "date", NULL
24054 };
24055
24056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24057 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24058 if (!SWIG_IsOK(res1)) {
24059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24060 }
24061 if (!argp1) {
24062 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24063 }
24064 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24065 {
24066 PyThreadState* __tstate = wxPyBeginAllowThreads();
24067 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24068 wxPyEndAllowThreads(__tstate);
24069 if (PyErr_Occurred()) SWIG_fail;
24070 }
24071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24072 return resultobj;
24073 fail:
24074 return NULL;
24075 }
24076
24077
24078 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24079 PyObject *resultobj = 0;
24080 wxDateTime *arg1 = (wxDateTime *) 0 ;
24081 void *argp1 = 0 ;
24082 int res1 = 0 ;
24083 PyObject *swig_obj[1] ;
24084
24085 if (!args) SWIG_fail;
24086 swig_obj[0] = args;
24087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24088 if (!SWIG_IsOK(res1)) {
24089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24090 }
24091 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24092 {
24093 PyThreadState* __tstate = wxPyBeginAllowThreads();
24094 delete arg1;
24095
24096 wxPyEndAllowThreads(__tstate);
24097 if (PyErr_Occurred()) SWIG_fail;
24098 }
24099 resultobj = SWIG_Py_Void();
24100 return resultobj;
24101 fail:
24102 return NULL;
24103 }
24104
24105
24106 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24107 PyObject *resultobj = 0;
24108 wxDateTime *arg1 = (wxDateTime *) 0 ;
24109 wxDateTime *result = 0 ;
24110 void *argp1 = 0 ;
24111 int res1 = 0 ;
24112 PyObject *swig_obj[1] ;
24113
24114 if (!args) SWIG_fail;
24115 swig_obj[0] = args;
24116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24117 if (!SWIG_IsOK(res1)) {
24118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24119 }
24120 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24121 {
24122 PyThreadState* __tstate = wxPyBeginAllowThreads();
24123 {
24124 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24125 result = (wxDateTime *) &_result_ref;
24126 }
24127 wxPyEndAllowThreads(__tstate);
24128 if (PyErr_Occurred()) SWIG_fail;
24129 }
24130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24131 return resultobj;
24132 fail:
24133 return NULL;
24134 }
24135
24136
24137 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24138 PyObject *resultobj = 0;
24139 wxDateTime *arg1 = (wxDateTime *) 0 ;
24140 time_t arg2 ;
24141 wxDateTime *result = 0 ;
24142 void *argp1 = 0 ;
24143 int res1 = 0 ;
24144 unsigned int val2 ;
24145 int ecode2 = 0 ;
24146 PyObject * obj0 = 0 ;
24147 PyObject * obj1 = 0 ;
24148 char * kwnames[] = {
24149 (char *) "self",(char *) "timet", NULL
24150 };
24151
24152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24154 if (!SWIG_IsOK(res1)) {
24155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24156 }
24157 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24158 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24159 if (!SWIG_IsOK(ecode2)) {
24160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24161 }
24162 arg2 = static_cast< time_t >(val2);
24163 {
24164 PyThreadState* __tstate = wxPyBeginAllowThreads();
24165 {
24166 wxDateTime &_result_ref = (arg1)->Set(arg2);
24167 result = (wxDateTime *) &_result_ref;
24168 }
24169 wxPyEndAllowThreads(__tstate);
24170 if (PyErr_Occurred()) SWIG_fail;
24171 }
24172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24173 return resultobj;
24174 fail:
24175 return NULL;
24176 }
24177
24178
24179 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24180 PyObject *resultobj = 0;
24181 wxDateTime *arg1 = (wxDateTime *) 0 ;
24182 double arg2 ;
24183 wxDateTime *result = 0 ;
24184 void *argp1 = 0 ;
24185 int res1 = 0 ;
24186 double val2 ;
24187 int ecode2 = 0 ;
24188 PyObject * obj0 = 0 ;
24189 PyObject * obj1 = 0 ;
24190 char * kwnames[] = {
24191 (char *) "self",(char *) "jdn", NULL
24192 };
24193
24194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24196 if (!SWIG_IsOK(res1)) {
24197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24198 }
24199 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24200 ecode2 = SWIG_AsVal_double(obj1, &val2);
24201 if (!SWIG_IsOK(ecode2)) {
24202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24203 }
24204 arg2 = static_cast< double >(val2);
24205 {
24206 PyThreadState* __tstate = wxPyBeginAllowThreads();
24207 {
24208 wxDateTime &_result_ref = (arg1)->Set(arg2);
24209 result = (wxDateTime *) &_result_ref;
24210 }
24211 wxPyEndAllowThreads(__tstate);
24212 if (PyErr_Occurred()) SWIG_fail;
24213 }
24214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24215 return resultobj;
24216 fail:
24217 return NULL;
24218 }
24219
24220
24221 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24222 PyObject *resultobj = 0;
24223 wxDateTime *arg1 = (wxDateTime *) 0 ;
24224 int arg2 ;
24225 int arg3 = (int) 0 ;
24226 int arg4 = (int) 0 ;
24227 int arg5 = (int) 0 ;
24228 wxDateTime *result = 0 ;
24229 void *argp1 = 0 ;
24230 int res1 = 0 ;
24231 int val2 ;
24232 int ecode2 = 0 ;
24233 int val3 ;
24234 int ecode3 = 0 ;
24235 int val4 ;
24236 int ecode4 = 0 ;
24237 int val5 ;
24238 int ecode5 = 0 ;
24239 PyObject * obj0 = 0 ;
24240 PyObject * obj1 = 0 ;
24241 PyObject * obj2 = 0 ;
24242 PyObject * obj3 = 0 ;
24243 PyObject * obj4 = 0 ;
24244 char * kwnames[] = {
24245 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24246 };
24247
24248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24250 if (!SWIG_IsOK(res1)) {
24251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24252 }
24253 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24254 ecode2 = SWIG_AsVal_int(obj1, &val2);
24255 if (!SWIG_IsOK(ecode2)) {
24256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24257 }
24258 arg2 = static_cast< int >(val2);
24259 if (obj2) {
24260 ecode3 = SWIG_AsVal_int(obj2, &val3);
24261 if (!SWIG_IsOK(ecode3)) {
24262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24263 }
24264 arg3 = static_cast< int >(val3);
24265 }
24266 if (obj3) {
24267 ecode4 = SWIG_AsVal_int(obj3, &val4);
24268 if (!SWIG_IsOK(ecode4)) {
24269 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24270 }
24271 arg4 = static_cast< int >(val4);
24272 }
24273 if (obj4) {
24274 ecode5 = SWIG_AsVal_int(obj4, &val5);
24275 if (!SWIG_IsOK(ecode5)) {
24276 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24277 }
24278 arg5 = static_cast< int >(val5);
24279 }
24280 {
24281 PyThreadState* __tstate = wxPyBeginAllowThreads();
24282 {
24283 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24284 result = (wxDateTime *) &_result_ref;
24285 }
24286 wxPyEndAllowThreads(__tstate);
24287 if (PyErr_Occurred()) SWIG_fail;
24288 }
24289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24290 return resultobj;
24291 fail:
24292 return NULL;
24293 }
24294
24295
24296 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24297 PyObject *resultobj = 0;
24298 wxDateTime *arg1 = (wxDateTime *) 0 ;
24299 int arg2 ;
24300 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24301 int arg4 = (int) wxDateTime::Inv_Year ;
24302 int arg5 = (int) 0 ;
24303 int arg6 = (int) 0 ;
24304 int arg7 = (int) 0 ;
24305 int arg8 = (int) 0 ;
24306 wxDateTime *result = 0 ;
24307 void *argp1 = 0 ;
24308 int res1 = 0 ;
24309 int val2 ;
24310 int ecode2 = 0 ;
24311 int val3 ;
24312 int ecode3 = 0 ;
24313 int val4 ;
24314 int ecode4 = 0 ;
24315 int val5 ;
24316 int ecode5 = 0 ;
24317 int val6 ;
24318 int ecode6 = 0 ;
24319 int val7 ;
24320 int ecode7 = 0 ;
24321 int val8 ;
24322 int ecode8 = 0 ;
24323 PyObject * obj0 = 0 ;
24324 PyObject * obj1 = 0 ;
24325 PyObject * obj2 = 0 ;
24326 PyObject * obj3 = 0 ;
24327 PyObject * obj4 = 0 ;
24328 PyObject * obj5 = 0 ;
24329 PyObject * obj6 = 0 ;
24330 PyObject * obj7 = 0 ;
24331 char * kwnames[] = {
24332 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24333 };
24334
24335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24337 if (!SWIG_IsOK(res1)) {
24338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24339 }
24340 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24341 ecode2 = SWIG_AsVal_int(obj1, &val2);
24342 if (!SWIG_IsOK(ecode2)) {
24343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24344 }
24345 arg2 = static_cast< int >(val2);
24346 if (obj2) {
24347 ecode3 = SWIG_AsVal_int(obj2, &val3);
24348 if (!SWIG_IsOK(ecode3)) {
24349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24350 }
24351 arg3 = static_cast< wxDateTime::Month >(val3);
24352 }
24353 if (obj3) {
24354 ecode4 = SWIG_AsVal_int(obj3, &val4);
24355 if (!SWIG_IsOK(ecode4)) {
24356 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24357 }
24358 arg4 = static_cast< int >(val4);
24359 }
24360 if (obj4) {
24361 ecode5 = SWIG_AsVal_int(obj4, &val5);
24362 if (!SWIG_IsOK(ecode5)) {
24363 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24364 }
24365 arg5 = static_cast< int >(val5);
24366 }
24367 if (obj5) {
24368 ecode6 = SWIG_AsVal_int(obj5, &val6);
24369 if (!SWIG_IsOK(ecode6)) {
24370 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24371 }
24372 arg6 = static_cast< int >(val6);
24373 }
24374 if (obj6) {
24375 ecode7 = SWIG_AsVal_int(obj6, &val7);
24376 if (!SWIG_IsOK(ecode7)) {
24377 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24378 }
24379 arg7 = static_cast< int >(val7);
24380 }
24381 if (obj7) {
24382 ecode8 = SWIG_AsVal_int(obj7, &val8);
24383 if (!SWIG_IsOK(ecode8)) {
24384 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24385 }
24386 arg8 = static_cast< int >(val8);
24387 }
24388 {
24389 PyThreadState* __tstate = wxPyBeginAllowThreads();
24390 {
24391 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24392 result = (wxDateTime *) &_result_ref;
24393 }
24394 wxPyEndAllowThreads(__tstate);
24395 if (PyErr_Occurred()) SWIG_fail;
24396 }
24397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24398 return resultobj;
24399 fail:
24400 return NULL;
24401 }
24402
24403
24404 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24405 PyObject *resultobj = 0;
24406 wxDateTime *arg1 = (wxDateTime *) 0 ;
24407 wxDateTime *result = 0 ;
24408 void *argp1 = 0 ;
24409 int res1 = 0 ;
24410 PyObject *swig_obj[1] ;
24411
24412 if (!args) SWIG_fail;
24413 swig_obj[0] = args;
24414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24415 if (!SWIG_IsOK(res1)) {
24416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24417 }
24418 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24419 {
24420 PyThreadState* __tstate = wxPyBeginAllowThreads();
24421 {
24422 wxDateTime &_result_ref = (arg1)->ResetTime();
24423 result = (wxDateTime *) &_result_ref;
24424 }
24425 wxPyEndAllowThreads(__tstate);
24426 if (PyErr_Occurred()) SWIG_fail;
24427 }
24428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24429 return resultobj;
24430 fail:
24431 return NULL;
24432 }
24433
24434
24435 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24436 PyObject *resultobj = 0;
24437 wxDateTime *arg1 = (wxDateTime *) 0 ;
24438 int arg2 ;
24439 wxDateTime *result = 0 ;
24440 void *argp1 = 0 ;
24441 int res1 = 0 ;
24442 int val2 ;
24443 int ecode2 = 0 ;
24444 PyObject * obj0 = 0 ;
24445 PyObject * obj1 = 0 ;
24446 char * kwnames[] = {
24447 (char *) "self",(char *) "year", NULL
24448 };
24449
24450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24452 if (!SWIG_IsOK(res1)) {
24453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24454 }
24455 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24456 ecode2 = SWIG_AsVal_int(obj1, &val2);
24457 if (!SWIG_IsOK(ecode2)) {
24458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24459 }
24460 arg2 = static_cast< int >(val2);
24461 {
24462 PyThreadState* __tstate = wxPyBeginAllowThreads();
24463 {
24464 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24465 result = (wxDateTime *) &_result_ref;
24466 }
24467 wxPyEndAllowThreads(__tstate);
24468 if (PyErr_Occurred()) SWIG_fail;
24469 }
24470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24471 return resultobj;
24472 fail:
24473 return NULL;
24474 }
24475
24476
24477 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24478 PyObject *resultobj = 0;
24479 wxDateTime *arg1 = (wxDateTime *) 0 ;
24480 wxDateTime::Month arg2 ;
24481 wxDateTime *result = 0 ;
24482 void *argp1 = 0 ;
24483 int res1 = 0 ;
24484 int val2 ;
24485 int ecode2 = 0 ;
24486 PyObject * obj0 = 0 ;
24487 PyObject * obj1 = 0 ;
24488 char * kwnames[] = {
24489 (char *) "self",(char *) "month", NULL
24490 };
24491
24492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24494 if (!SWIG_IsOK(res1)) {
24495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24496 }
24497 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24498 ecode2 = SWIG_AsVal_int(obj1, &val2);
24499 if (!SWIG_IsOK(ecode2)) {
24500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24501 }
24502 arg2 = static_cast< wxDateTime::Month >(val2);
24503 {
24504 PyThreadState* __tstate = wxPyBeginAllowThreads();
24505 {
24506 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24507 result = (wxDateTime *) &_result_ref;
24508 }
24509 wxPyEndAllowThreads(__tstate);
24510 if (PyErr_Occurred()) SWIG_fail;
24511 }
24512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24513 return resultobj;
24514 fail:
24515 return NULL;
24516 }
24517
24518
24519 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24520 PyObject *resultobj = 0;
24521 wxDateTime *arg1 = (wxDateTime *) 0 ;
24522 int arg2 ;
24523 wxDateTime *result = 0 ;
24524 void *argp1 = 0 ;
24525 int res1 = 0 ;
24526 int val2 ;
24527 int ecode2 = 0 ;
24528 PyObject * obj0 = 0 ;
24529 PyObject * obj1 = 0 ;
24530 char * kwnames[] = {
24531 (char *) "self",(char *) "day", NULL
24532 };
24533
24534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24536 if (!SWIG_IsOK(res1)) {
24537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24538 }
24539 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24540 ecode2 = SWIG_AsVal_int(obj1, &val2);
24541 if (!SWIG_IsOK(ecode2)) {
24542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24543 }
24544 arg2 = static_cast< int >(val2);
24545 {
24546 PyThreadState* __tstate = wxPyBeginAllowThreads();
24547 {
24548 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24549 result = (wxDateTime *) &_result_ref;
24550 }
24551 wxPyEndAllowThreads(__tstate);
24552 if (PyErr_Occurred()) SWIG_fail;
24553 }
24554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24555 return resultobj;
24556 fail:
24557 return NULL;
24558 }
24559
24560
24561 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24562 PyObject *resultobj = 0;
24563 wxDateTime *arg1 = (wxDateTime *) 0 ;
24564 int arg2 ;
24565 wxDateTime *result = 0 ;
24566 void *argp1 = 0 ;
24567 int res1 = 0 ;
24568 int val2 ;
24569 int ecode2 = 0 ;
24570 PyObject * obj0 = 0 ;
24571 PyObject * obj1 = 0 ;
24572 char * kwnames[] = {
24573 (char *) "self",(char *) "hour", NULL
24574 };
24575
24576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24578 if (!SWIG_IsOK(res1)) {
24579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24580 }
24581 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24582 ecode2 = SWIG_AsVal_int(obj1, &val2);
24583 if (!SWIG_IsOK(ecode2)) {
24584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24585 }
24586 arg2 = static_cast< int >(val2);
24587 {
24588 PyThreadState* __tstate = wxPyBeginAllowThreads();
24589 {
24590 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24591 result = (wxDateTime *) &_result_ref;
24592 }
24593 wxPyEndAllowThreads(__tstate);
24594 if (PyErr_Occurred()) SWIG_fail;
24595 }
24596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24597 return resultobj;
24598 fail:
24599 return NULL;
24600 }
24601
24602
24603 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24604 PyObject *resultobj = 0;
24605 wxDateTime *arg1 = (wxDateTime *) 0 ;
24606 int arg2 ;
24607 wxDateTime *result = 0 ;
24608 void *argp1 = 0 ;
24609 int res1 = 0 ;
24610 int val2 ;
24611 int ecode2 = 0 ;
24612 PyObject * obj0 = 0 ;
24613 PyObject * obj1 = 0 ;
24614 char * kwnames[] = {
24615 (char *) "self",(char *) "minute", NULL
24616 };
24617
24618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24620 if (!SWIG_IsOK(res1)) {
24621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24622 }
24623 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24624 ecode2 = SWIG_AsVal_int(obj1, &val2);
24625 if (!SWIG_IsOK(ecode2)) {
24626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24627 }
24628 arg2 = static_cast< int >(val2);
24629 {
24630 PyThreadState* __tstate = wxPyBeginAllowThreads();
24631 {
24632 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24633 result = (wxDateTime *) &_result_ref;
24634 }
24635 wxPyEndAllowThreads(__tstate);
24636 if (PyErr_Occurred()) SWIG_fail;
24637 }
24638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24639 return resultobj;
24640 fail:
24641 return NULL;
24642 }
24643
24644
24645 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24646 PyObject *resultobj = 0;
24647 wxDateTime *arg1 = (wxDateTime *) 0 ;
24648 int arg2 ;
24649 wxDateTime *result = 0 ;
24650 void *argp1 = 0 ;
24651 int res1 = 0 ;
24652 int val2 ;
24653 int ecode2 = 0 ;
24654 PyObject * obj0 = 0 ;
24655 PyObject * obj1 = 0 ;
24656 char * kwnames[] = {
24657 (char *) "self",(char *) "second", NULL
24658 };
24659
24660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24662 if (!SWIG_IsOK(res1)) {
24663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24664 }
24665 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24666 ecode2 = SWIG_AsVal_int(obj1, &val2);
24667 if (!SWIG_IsOK(ecode2)) {
24668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24669 }
24670 arg2 = static_cast< int >(val2);
24671 {
24672 PyThreadState* __tstate = wxPyBeginAllowThreads();
24673 {
24674 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24675 result = (wxDateTime *) &_result_ref;
24676 }
24677 wxPyEndAllowThreads(__tstate);
24678 if (PyErr_Occurred()) SWIG_fail;
24679 }
24680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24681 return resultobj;
24682 fail:
24683 return NULL;
24684 }
24685
24686
24687 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24688 PyObject *resultobj = 0;
24689 wxDateTime *arg1 = (wxDateTime *) 0 ;
24690 int arg2 ;
24691 wxDateTime *result = 0 ;
24692 void *argp1 = 0 ;
24693 int res1 = 0 ;
24694 int val2 ;
24695 int ecode2 = 0 ;
24696 PyObject * obj0 = 0 ;
24697 PyObject * obj1 = 0 ;
24698 char * kwnames[] = {
24699 (char *) "self",(char *) "millisecond", NULL
24700 };
24701
24702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24704 if (!SWIG_IsOK(res1)) {
24705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24706 }
24707 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24708 ecode2 = SWIG_AsVal_int(obj1, &val2);
24709 if (!SWIG_IsOK(ecode2)) {
24710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24711 }
24712 arg2 = static_cast< int >(val2);
24713 {
24714 PyThreadState* __tstate = wxPyBeginAllowThreads();
24715 {
24716 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24717 result = (wxDateTime *) &_result_ref;
24718 }
24719 wxPyEndAllowThreads(__tstate);
24720 if (PyErr_Occurred()) SWIG_fail;
24721 }
24722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24723 return resultobj;
24724 fail:
24725 return NULL;
24726 }
24727
24728
24729 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24730 PyObject *resultobj = 0;
24731 wxDateTime *arg1 = (wxDateTime *) 0 ;
24732 wxDateTime::WeekDay arg2 ;
24733 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24734 wxDateTime *result = 0 ;
24735 void *argp1 = 0 ;
24736 int res1 = 0 ;
24737 int val2 ;
24738 int ecode2 = 0 ;
24739 int val3 ;
24740 int ecode3 = 0 ;
24741 PyObject * obj0 = 0 ;
24742 PyObject * obj1 = 0 ;
24743 PyObject * obj2 = 0 ;
24744 char * kwnames[] = {
24745 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24746 };
24747
24748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24750 if (!SWIG_IsOK(res1)) {
24751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24752 }
24753 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24754 ecode2 = SWIG_AsVal_int(obj1, &val2);
24755 if (!SWIG_IsOK(ecode2)) {
24756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24757 }
24758 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24759 if (obj2) {
24760 ecode3 = SWIG_AsVal_int(obj2, &val3);
24761 if (!SWIG_IsOK(ecode3)) {
24762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24763 }
24764 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24765 }
24766 {
24767 PyThreadState* __tstate = wxPyBeginAllowThreads();
24768 {
24769 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24770 result = (wxDateTime *) &_result_ref;
24771 }
24772 wxPyEndAllowThreads(__tstate);
24773 if (PyErr_Occurred()) SWIG_fail;
24774 }
24775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24776 return resultobj;
24777 fail:
24778 return NULL;
24779 }
24780
24781
24782 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24783 PyObject *resultobj = 0;
24784 wxDateTime *arg1 = (wxDateTime *) 0 ;
24785 wxDateTime::WeekDay arg2 ;
24786 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24787 wxDateTime result;
24788 void *argp1 = 0 ;
24789 int res1 = 0 ;
24790 int val2 ;
24791 int ecode2 = 0 ;
24792 int val3 ;
24793 int ecode3 = 0 ;
24794 PyObject * obj0 = 0 ;
24795 PyObject * obj1 = 0 ;
24796 PyObject * obj2 = 0 ;
24797 char * kwnames[] = {
24798 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24799 };
24800
24801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24803 if (!SWIG_IsOK(res1)) {
24804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24805 }
24806 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24807 ecode2 = SWIG_AsVal_int(obj1, &val2);
24808 if (!SWIG_IsOK(ecode2)) {
24809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24810 }
24811 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24812 if (obj2) {
24813 ecode3 = SWIG_AsVal_int(obj2, &val3);
24814 if (!SWIG_IsOK(ecode3)) {
24815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24816 }
24817 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24818 }
24819 {
24820 PyThreadState* __tstate = wxPyBeginAllowThreads();
24821 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24822 wxPyEndAllowThreads(__tstate);
24823 if (PyErr_Occurred()) SWIG_fail;
24824 }
24825 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24826 return resultobj;
24827 fail:
24828 return NULL;
24829 }
24830
24831
24832 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24833 PyObject *resultobj = 0;
24834 wxDateTime *arg1 = (wxDateTime *) 0 ;
24835 wxDateTime::WeekDay arg2 ;
24836 wxDateTime *result = 0 ;
24837 void *argp1 = 0 ;
24838 int res1 = 0 ;
24839 int val2 ;
24840 int ecode2 = 0 ;
24841 PyObject * obj0 = 0 ;
24842 PyObject * obj1 = 0 ;
24843 char * kwnames[] = {
24844 (char *) "self",(char *) "weekday", NULL
24845 };
24846
24847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24849 if (!SWIG_IsOK(res1)) {
24850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24851 }
24852 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24853 ecode2 = SWIG_AsVal_int(obj1, &val2);
24854 if (!SWIG_IsOK(ecode2)) {
24855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24856 }
24857 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24858 {
24859 PyThreadState* __tstate = wxPyBeginAllowThreads();
24860 {
24861 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24862 result = (wxDateTime *) &_result_ref;
24863 }
24864 wxPyEndAllowThreads(__tstate);
24865 if (PyErr_Occurred()) SWIG_fail;
24866 }
24867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24868 return resultobj;
24869 fail:
24870 return NULL;
24871 }
24872
24873
24874 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24875 PyObject *resultobj = 0;
24876 wxDateTime *arg1 = (wxDateTime *) 0 ;
24877 wxDateTime::WeekDay arg2 ;
24878 wxDateTime result;
24879 void *argp1 = 0 ;
24880 int res1 = 0 ;
24881 int val2 ;
24882 int ecode2 = 0 ;
24883 PyObject * obj0 = 0 ;
24884 PyObject * obj1 = 0 ;
24885 char * kwnames[] = {
24886 (char *) "self",(char *) "weekday", NULL
24887 };
24888
24889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24891 if (!SWIG_IsOK(res1)) {
24892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24893 }
24894 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24895 ecode2 = SWIG_AsVal_int(obj1, &val2);
24896 if (!SWIG_IsOK(ecode2)) {
24897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24898 }
24899 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24900 {
24901 PyThreadState* __tstate = wxPyBeginAllowThreads();
24902 result = (arg1)->GetNextWeekDay(arg2);
24903 wxPyEndAllowThreads(__tstate);
24904 if (PyErr_Occurred()) SWIG_fail;
24905 }
24906 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24907 return resultobj;
24908 fail:
24909 return NULL;
24910 }
24911
24912
24913 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24914 PyObject *resultobj = 0;
24915 wxDateTime *arg1 = (wxDateTime *) 0 ;
24916 wxDateTime::WeekDay arg2 ;
24917 wxDateTime *result = 0 ;
24918 void *argp1 = 0 ;
24919 int res1 = 0 ;
24920 int val2 ;
24921 int ecode2 = 0 ;
24922 PyObject * obj0 = 0 ;
24923 PyObject * obj1 = 0 ;
24924 char * kwnames[] = {
24925 (char *) "self",(char *) "weekday", NULL
24926 };
24927
24928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24930 if (!SWIG_IsOK(res1)) {
24931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24932 }
24933 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24934 ecode2 = SWIG_AsVal_int(obj1, &val2);
24935 if (!SWIG_IsOK(ecode2)) {
24936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24937 }
24938 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24939 {
24940 PyThreadState* __tstate = wxPyBeginAllowThreads();
24941 {
24942 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24943 result = (wxDateTime *) &_result_ref;
24944 }
24945 wxPyEndAllowThreads(__tstate);
24946 if (PyErr_Occurred()) SWIG_fail;
24947 }
24948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24949 return resultobj;
24950 fail:
24951 return NULL;
24952 }
24953
24954
24955 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24956 PyObject *resultobj = 0;
24957 wxDateTime *arg1 = (wxDateTime *) 0 ;
24958 wxDateTime::WeekDay arg2 ;
24959 wxDateTime result;
24960 void *argp1 = 0 ;
24961 int res1 = 0 ;
24962 int val2 ;
24963 int ecode2 = 0 ;
24964 PyObject * obj0 = 0 ;
24965 PyObject * obj1 = 0 ;
24966 char * kwnames[] = {
24967 (char *) "self",(char *) "weekday", NULL
24968 };
24969
24970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24972 if (!SWIG_IsOK(res1)) {
24973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24974 }
24975 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24976 ecode2 = SWIG_AsVal_int(obj1, &val2);
24977 if (!SWIG_IsOK(ecode2)) {
24978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24979 }
24980 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24981 {
24982 PyThreadState* __tstate = wxPyBeginAllowThreads();
24983 result = (arg1)->GetPrevWeekDay(arg2);
24984 wxPyEndAllowThreads(__tstate);
24985 if (PyErr_Occurred()) SWIG_fail;
24986 }
24987 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24988 return resultobj;
24989 fail:
24990 return NULL;
24991 }
24992
24993
24994 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24995 PyObject *resultobj = 0;
24996 wxDateTime *arg1 = (wxDateTime *) 0 ;
24997 wxDateTime::WeekDay arg2 ;
24998 int arg3 = (int) 1 ;
24999 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25000 int arg5 = (int) wxDateTime::Inv_Year ;
25001 bool result;
25002 void *argp1 = 0 ;
25003 int res1 = 0 ;
25004 int val2 ;
25005 int ecode2 = 0 ;
25006 int val3 ;
25007 int ecode3 = 0 ;
25008 int val4 ;
25009 int ecode4 = 0 ;
25010 int val5 ;
25011 int ecode5 = 0 ;
25012 PyObject * obj0 = 0 ;
25013 PyObject * obj1 = 0 ;
25014 PyObject * obj2 = 0 ;
25015 PyObject * obj3 = 0 ;
25016 PyObject * obj4 = 0 ;
25017 char * kwnames[] = {
25018 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25019 };
25020
25021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25023 if (!SWIG_IsOK(res1)) {
25024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25025 }
25026 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25027 ecode2 = SWIG_AsVal_int(obj1, &val2);
25028 if (!SWIG_IsOK(ecode2)) {
25029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25030 }
25031 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25032 if (obj2) {
25033 ecode3 = SWIG_AsVal_int(obj2, &val3);
25034 if (!SWIG_IsOK(ecode3)) {
25035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25036 }
25037 arg3 = static_cast< int >(val3);
25038 }
25039 if (obj3) {
25040 ecode4 = SWIG_AsVal_int(obj3, &val4);
25041 if (!SWIG_IsOK(ecode4)) {
25042 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25043 }
25044 arg4 = static_cast< wxDateTime::Month >(val4);
25045 }
25046 if (obj4) {
25047 ecode5 = SWIG_AsVal_int(obj4, &val5);
25048 if (!SWIG_IsOK(ecode5)) {
25049 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25050 }
25051 arg5 = static_cast< int >(val5);
25052 }
25053 {
25054 PyThreadState* __tstate = wxPyBeginAllowThreads();
25055 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25056 wxPyEndAllowThreads(__tstate);
25057 if (PyErr_Occurred()) SWIG_fail;
25058 }
25059 {
25060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25061 }
25062 return resultobj;
25063 fail:
25064 return NULL;
25065 }
25066
25067
25068 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25069 PyObject *resultobj = 0;
25070 wxDateTime *arg1 = (wxDateTime *) 0 ;
25071 wxDateTime::WeekDay arg2 ;
25072 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25073 int arg4 = (int) wxDateTime::Inv_Year ;
25074 bool result;
25075 void *argp1 = 0 ;
25076 int res1 = 0 ;
25077 int val2 ;
25078 int ecode2 = 0 ;
25079 int val3 ;
25080 int ecode3 = 0 ;
25081 int val4 ;
25082 int ecode4 = 0 ;
25083 PyObject * obj0 = 0 ;
25084 PyObject * obj1 = 0 ;
25085 PyObject * obj2 = 0 ;
25086 PyObject * obj3 = 0 ;
25087 char * kwnames[] = {
25088 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25089 };
25090
25091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25093 if (!SWIG_IsOK(res1)) {
25094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25095 }
25096 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25097 ecode2 = SWIG_AsVal_int(obj1, &val2);
25098 if (!SWIG_IsOK(ecode2)) {
25099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25100 }
25101 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25102 if (obj2) {
25103 ecode3 = SWIG_AsVal_int(obj2, &val3);
25104 if (!SWIG_IsOK(ecode3)) {
25105 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25106 }
25107 arg3 = static_cast< wxDateTime::Month >(val3);
25108 }
25109 if (obj3) {
25110 ecode4 = SWIG_AsVal_int(obj3, &val4);
25111 if (!SWIG_IsOK(ecode4)) {
25112 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25113 }
25114 arg4 = static_cast< int >(val4);
25115 }
25116 {
25117 PyThreadState* __tstate = wxPyBeginAllowThreads();
25118 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25119 wxPyEndAllowThreads(__tstate);
25120 if (PyErr_Occurred()) SWIG_fail;
25121 }
25122 {
25123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25124 }
25125 return resultobj;
25126 fail:
25127 return NULL;
25128 }
25129
25130
25131 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25132 PyObject *resultobj = 0;
25133 wxDateTime *arg1 = (wxDateTime *) 0 ;
25134 wxDateTime::WeekDay arg2 ;
25135 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25136 int arg4 = (int) wxDateTime::Inv_Year ;
25137 wxDateTime result;
25138 void *argp1 = 0 ;
25139 int res1 = 0 ;
25140 int val2 ;
25141 int ecode2 = 0 ;
25142 int val3 ;
25143 int ecode3 = 0 ;
25144 int val4 ;
25145 int ecode4 = 0 ;
25146 PyObject * obj0 = 0 ;
25147 PyObject * obj1 = 0 ;
25148 PyObject * obj2 = 0 ;
25149 PyObject * obj3 = 0 ;
25150 char * kwnames[] = {
25151 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25152 };
25153
25154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25156 if (!SWIG_IsOK(res1)) {
25157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25158 }
25159 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25160 ecode2 = SWIG_AsVal_int(obj1, &val2);
25161 if (!SWIG_IsOK(ecode2)) {
25162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25163 }
25164 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25165 if (obj2) {
25166 ecode3 = SWIG_AsVal_int(obj2, &val3);
25167 if (!SWIG_IsOK(ecode3)) {
25168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25169 }
25170 arg3 = static_cast< wxDateTime::Month >(val3);
25171 }
25172 if (obj3) {
25173 ecode4 = SWIG_AsVal_int(obj3, &val4);
25174 if (!SWIG_IsOK(ecode4)) {
25175 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25176 }
25177 arg4 = static_cast< int >(val4);
25178 }
25179 {
25180 PyThreadState* __tstate = wxPyBeginAllowThreads();
25181 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25182 wxPyEndAllowThreads(__tstate);
25183 if (PyErr_Occurred()) SWIG_fail;
25184 }
25185 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25186 return resultobj;
25187 fail:
25188 return NULL;
25189 }
25190
25191
25192 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25193 PyObject *resultobj = 0;
25194 wxDateTime *arg1 = (wxDateTime *) 0 ;
25195 int arg2 ;
25196 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25197 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25198 bool result;
25199 void *argp1 = 0 ;
25200 int res1 = 0 ;
25201 int val2 ;
25202 int ecode2 = 0 ;
25203 int val3 ;
25204 int ecode3 = 0 ;
25205 int val4 ;
25206 int ecode4 = 0 ;
25207 PyObject * obj0 = 0 ;
25208 PyObject * obj1 = 0 ;
25209 PyObject * obj2 = 0 ;
25210 PyObject * obj3 = 0 ;
25211 char * kwnames[] = {
25212 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25213 };
25214
25215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25217 if (!SWIG_IsOK(res1)) {
25218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25219 }
25220 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25221 ecode2 = SWIG_AsVal_int(obj1, &val2);
25222 if (!SWIG_IsOK(ecode2)) {
25223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25224 }
25225 arg2 = static_cast< int >(val2);
25226 if (obj2) {
25227 ecode3 = SWIG_AsVal_int(obj2, &val3);
25228 if (!SWIG_IsOK(ecode3)) {
25229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25230 }
25231 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25232 }
25233 if (obj3) {
25234 ecode4 = SWIG_AsVal_int(obj3, &val4);
25235 if (!SWIG_IsOK(ecode4)) {
25236 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25237 }
25238 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25239 }
25240 {
25241 PyThreadState* __tstate = wxPyBeginAllowThreads();
25242 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25243 wxPyEndAllowThreads(__tstate);
25244 if (PyErr_Occurred()) SWIG_fail;
25245 }
25246 {
25247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25248 }
25249 return resultobj;
25250 fail:
25251 return NULL;
25252 }
25253
25254
25255 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25256 PyObject *resultobj = 0;
25257 wxDateTime *arg1 = (wxDateTime *) 0 ;
25258 int arg2 ;
25259 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25260 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25261 wxDateTime result;
25262 void *argp1 = 0 ;
25263 int res1 = 0 ;
25264 int val2 ;
25265 int ecode2 = 0 ;
25266 int val3 ;
25267 int ecode3 = 0 ;
25268 int val4 ;
25269 int ecode4 = 0 ;
25270 PyObject * obj0 = 0 ;
25271 PyObject * obj1 = 0 ;
25272 PyObject * obj2 = 0 ;
25273 PyObject * obj3 = 0 ;
25274 char * kwnames[] = {
25275 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25276 };
25277
25278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25280 if (!SWIG_IsOK(res1)) {
25281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25282 }
25283 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25284 ecode2 = SWIG_AsVal_int(obj1, &val2);
25285 if (!SWIG_IsOK(ecode2)) {
25286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25287 }
25288 arg2 = static_cast< int >(val2);
25289 if (obj2) {
25290 ecode3 = SWIG_AsVal_int(obj2, &val3);
25291 if (!SWIG_IsOK(ecode3)) {
25292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25293 }
25294 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25295 }
25296 if (obj3) {
25297 ecode4 = SWIG_AsVal_int(obj3, &val4);
25298 if (!SWIG_IsOK(ecode4)) {
25299 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25300 }
25301 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25302 }
25303 {
25304 PyThreadState* __tstate = wxPyBeginAllowThreads();
25305 result = (arg1)->GetWeek(arg2,arg3,arg4);
25306 wxPyEndAllowThreads(__tstate);
25307 if (PyErr_Occurred()) SWIG_fail;
25308 }
25309 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25310 return resultobj;
25311 fail:
25312 return NULL;
25313 }
25314
25315
25316 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25317 PyObject *resultobj = 0;
25318 int arg1 ;
25319 int arg2 ;
25320 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25321 wxDateTime result;
25322 int val1 ;
25323 int ecode1 = 0 ;
25324 int val2 ;
25325 int ecode2 = 0 ;
25326 int val3 ;
25327 int ecode3 = 0 ;
25328 PyObject * obj0 = 0 ;
25329 PyObject * obj1 = 0 ;
25330 PyObject * obj2 = 0 ;
25331 char * kwnames[] = {
25332 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25333 };
25334
25335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25336 ecode1 = SWIG_AsVal_int(obj0, &val1);
25337 if (!SWIG_IsOK(ecode1)) {
25338 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25339 }
25340 arg1 = static_cast< int >(val1);
25341 ecode2 = SWIG_AsVal_int(obj1, &val2);
25342 if (!SWIG_IsOK(ecode2)) {
25343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25344 }
25345 arg2 = static_cast< int >(val2);
25346 if (obj2) {
25347 ecode3 = SWIG_AsVal_int(obj2, &val3);
25348 if (!SWIG_IsOK(ecode3)) {
25349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25350 }
25351 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25352 }
25353 {
25354 PyThreadState* __tstate = wxPyBeginAllowThreads();
25355 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25356 wxPyEndAllowThreads(__tstate);
25357 if (PyErr_Occurred()) SWIG_fail;
25358 }
25359 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25360 return resultobj;
25361 fail:
25362 return NULL;
25363 }
25364
25365
25366 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25367 PyObject *resultobj = 0;
25368 wxDateTime *arg1 = (wxDateTime *) 0 ;
25369 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25370 int arg3 = (int) wxDateTime::Inv_Year ;
25371 wxDateTime *result = 0 ;
25372 void *argp1 = 0 ;
25373 int res1 = 0 ;
25374 int val2 ;
25375 int ecode2 = 0 ;
25376 int val3 ;
25377 int ecode3 = 0 ;
25378 PyObject * obj0 = 0 ;
25379 PyObject * obj1 = 0 ;
25380 PyObject * obj2 = 0 ;
25381 char * kwnames[] = {
25382 (char *) "self",(char *) "month",(char *) "year", NULL
25383 };
25384
25385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25387 if (!SWIG_IsOK(res1)) {
25388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25389 }
25390 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25391 if (obj1) {
25392 ecode2 = SWIG_AsVal_int(obj1, &val2);
25393 if (!SWIG_IsOK(ecode2)) {
25394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25395 }
25396 arg2 = static_cast< wxDateTime::Month >(val2);
25397 }
25398 if (obj2) {
25399 ecode3 = SWIG_AsVal_int(obj2, &val3);
25400 if (!SWIG_IsOK(ecode3)) {
25401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25402 }
25403 arg3 = static_cast< int >(val3);
25404 }
25405 {
25406 PyThreadState* __tstate = wxPyBeginAllowThreads();
25407 {
25408 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25409 result = (wxDateTime *) &_result_ref;
25410 }
25411 wxPyEndAllowThreads(__tstate);
25412 if (PyErr_Occurred()) SWIG_fail;
25413 }
25414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25415 return resultobj;
25416 fail:
25417 return NULL;
25418 }
25419
25420
25421 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25422 PyObject *resultobj = 0;
25423 wxDateTime *arg1 = (wxDateTime *) 0 ;
25424 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25425 int arg3 = (int) wxDateTime::Inv_Year ;
25426 wxDateTime result;
25427 void *argp1 = 0 ;
25428 int res1 = 0 ;
25429 int val2 ;
25430 int ecode2 = 0 ;
25431 int val3 ;
25432 int ecode3 = 0 ;
25433 PyObject * obj0 = 0 ;
25434 PyObject * obj1 = 0 ;
25435 PyObject * obj2 = 0 ;
25436 char * kwnames[] = {
25437 (char *) "self",(char *) "month",(char *) "year", NULL
25438 };
25439
25440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25442 if (!SWIG_IsOK(res1)) {
25443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25444 }
25445 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25446 if (obj1) {
25447 ecode2 = SWIG_AsVal_int(obj1, &val2);
25448 if (!SWIG_IsOK(ecode2)) {
25449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25450 }
25451 arg2 = static_cast< wxDateTime::Month >(val2);
25452 }
25453 if (obj2) {
25454 ecode3 = SWIG_AsVal_int(obj2, &val3);
25455 if (!SWIG_IsOK(ecode3)) {
25456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25457 }
25458 arg3 = static_cast< int >(val3);
25459 }
25460 {
25461 PyThreadState* __tstate = wxPyBeginAllowThreads();
25462 result = (arg1)->GetLastMonthDay(arg2,arg3);
25463 wxPyEndAllowThreads(__tstate);
25464 if (PyErr_Occurred()) SWIG_fail;
25465 }
25466 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25467 return resultobj;
25468 fail:
25469 return NULL;
25470 }
25471
25472
25473 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25474 PyObject *resultobj = 0;
25475 wxDateTime *arg1 = (wxDateTime *) 0 ;
25476 int arg2 ;
25477 wxDateTime *result = 0 ;
25478 void *argp1 = 0 ;
25479 int res1 = 0 ;
25480 int val2 ;
25481 int ecode2 = 0 ;
25482 PyObject * obj0 = 0 ;
25483 PyObject * obj1 = 0 ;
25484 char * kwnames[] = {
25485 (char *) "self",(char *) "yday", NULL
25486 };
25487
25488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25490 if (!SWIG_IsOK(res1)) {
25491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25492 }
25493 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25494 ecode2 = SWIG_AsVal_int(obj1, &val2);
25495 if (!SWIG_IsOK(ecode2)) {
25496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25497 }
25498 arg2 = static_cast< int >(val2);
25499 {
25500 PyThreadState* __tstate = wxPyBeginAllowThreads();
25501 {
25502 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25503 result = (wxDateTime *) &_result_ref;
25504 }
25505 wxPyEndAllowThreads(__tstate);
25506 if (PyErr_Occurred()) SWIG_fail;
25507 }
25508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25509 return resultobj;
25510 fail:
25511 return NULL;
25512 }
25513
25514
25515 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25516 PyObject *resultobj = 0;
25517 wxDateTime *arg1 = (wxDateTime *) 0 ;
25518 int arg2 ;
25519 wxDateTime result;
25520 void *argp1 = 0 ;
25521 int res1 = 0 ;
25522 int val2 ;
25523 int ecode2 = 0 ;
25524 PyObject * obj0 = 0 ;
25525 PyObject * obj1 = 0 ;
25526 char * kwnames[] = {
25527 (char *) "self",(char *) "yday", NULL
25528 };
25529
25530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25532 if (!SWIG_IsOK(res1)) {
25533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25534 }
25535 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25536 ecode2 = SWIG_AsVal_int(obj1, &val2);
25537 if (!SWIG_IsOK(ecode2)) {
25538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25539 }
25540 arg2 = static_cast< int >(val2);
25541 {
25542 PyThreadState* __tstate = wxPyBeginAllowThreads();
25543 result = (arg1)->GetYearDay(arg2);
25544 wxPyEndAllowThreads(__tstate);
25545 if (PyErr_Occurred()) SWIG_fail;
25546 }
25547 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25548 return resultobj;
25549 fail:
25550 return NULL;
25551 }
25552
25553
25554 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25555 PyObject *resultobj = 0;
25556 wxDateTime *arg1 = (wxDateTime *) 0 ;
25557 double result;
25558 void *argp1 = 0 ;
25559 int res1 = 0 ;
25560 PyObject *swig_obj[1] ;
25561
25562 if (!args) SWIG_fail;
25563 swig_obj[0] = args;
25564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25565 if (!SWIG_IsOK(res1)) {
25566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25567 }
25568 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25569 {
25570 PyThreadState* __tstate = wxPyBeginAllowThreads();
25571 result = (double)(arg1)->GetJulianDayNumber();
25572 wxPyEndAllowThreads(__tstate);
25573 if (PyErr_Occurred()) SWIG_fail;
25574 }
25575 resultobj = SWIG_From_double(static_cast< double >(result));
25576 return resultobj;
25577 fail:
25578 return NULL;
25579 }
25580
25581
25582 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25583 PyObject *resultobj = 0;
25584 wxDateTime *arg1 = (wxDateTime *) 0 ;
25585 double result;
25586 void *argp1 = 0 ;
25587 int res1 = 0 ;
25588 PyObject *swig_obj[1] ;
25589
25590 if (!args) SWIG_fail;
25591 swig_obj[0] = args;
25592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25593 if (!SWIG_IsOK(res1)) {
25594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25595 }
25596 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25597 {
25598 PyThreadState* __tstate = wxPyBeginAllowThreads();
25599 result = (double)(arg1)->GetJDN();
25600 wxPyEndAllowThreads(__tstate);
25601 if (PyErr_Occurred()) SWIG_fail;
25602 }
25603 resultobj = SWIG_From_double(static_cast< double >(result));
25604 return resultobj;
25605 fail:
25606 return NULL;
25607 }
25608
25609
25610 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25611 PyObject *resultobj = 0;
25612 wxDateTime *arg1 = (wxDateTime *) 0 ;
25613 double result;
25614 void *argp1 = 0 ;
25615 int res1 = 0 ;
25616 PyObject *swig_obj[1] ;
25617
25618 if (!args) SWIG_fail;
25619 swig_obj[0] = args;
25620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25621 if (!SWIG_IsOK(res1)) {
25622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25623 }
25624 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25625 {
25626 PyThreadState* __tstate = wxPyBeginAllowThreads();
25627 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25628 wxPyEndAllowThreads(__tstate);
25629 if (PyErr_Occurred()) SWIG_fail;
25630 }
25631 resultobj = SWIG_From_double(static_cast< double >(result));
25632 return resultobj;
25633 fail:
25634 return NULL;
25635 }
25636
25637
25638 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25639 PyObject *resultobj = 0;
25640 wxDateTime *arg1 = (wxDateTime *) 0 ;
25641 double result;
25642 void *argp1 = 0 ;
25643 int res1 = 0 ;
25644 PyObject *swig_obj[1] ;
25645
25646 if (!args) SWIG_fail;
25647 swig_obj[0] = args;
25648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25649 if (!SWIG_IsOK(res1)) {
25650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25651 }
25652 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25653 {
25654 PyThreadState* __tstate = wxPyBeginAllowThreads();
25655 result = (double)(arg1)->GetMJD();
25656 wxPyEndAllowThreads(__tstate);
25657 if (PyErr_Occurred()) SWIG_fail;
25658 }
25659 resultobj = SWIG_From_double(static_cast< double >(result));
25660 return resultobj;
25661 fail:
25662 return NULL;
25663 }
25664
25665
25666 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25667 PyObject *resultobj = 0;
25668 wxDateTime *arg1 = (wxDateTime *) 0 ;
25669 double result;
25670 void *argp1 = 0 ;
25671 int res1 = 0 ;
25672 PyObject *swig_obj[1] ;
25673
25674 if (!args) SWIG_fail;
25675 swig_obj[0] = args;
25676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25677 if (!SWIG_IsOK(res1)) {
25678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25679 }
25680 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25681 {
25682 PyThreadState* __tstate = wxPyBeginAllowThreads();
25683 result = (double)(arg1)->GetRataDie();
25684 wxPyEndAllowThreads(__tstate);
25685 if (PyErr_Occurred()) SWIG_fail;
25686 }
25687 resultobj = SWIG_From_double(static_cast< double >(result));
25688 return resultobj;
25689 fail:
25690 return NULL;
25691 }
25692
25693
25694 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25695 PyObject *resultobj = 0;
25696 wxDateTime *arg1 = (wxDateTime *) 0 ;
25697 wxDateTime::TimeZone *arg2 = 0 ;
25698 bool arg3 = (bool) false ;
25699 wxDateTime result;
25700 void *argp1 = 0 ;
25701 int res1 = 0 ;
25702 bool temp2 = false ;
25703 bool val3 ;
25704 int ecode3 = 0 ;
25705 PyObject * obj0 = 0 ;
25706 PyObject * obj1 = 0 ;
25707 PyObject * obj2 = 0 ;
25708 char * kwnames[] = {
25709 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25710 };
25711
25712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25714 if (!SWIG_IsOK(res1)) {
25715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25716 }
25717 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25718 {
25719 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25720 temp2 = true;
25721 }
25722 if (obj2) {
25723 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25724 if (!SWIG_IsOK(ecode3)) {
25725 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25726 }
25727 arg3 = static_cast< bool >(val3);
25728 }
25729 {
25730 PyThreadState* __tstate = wxPyBeginAllowThreads();
25731 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25732 wxPyEndAllowThreads(__tstate);
25733 if (PyErr_Occurred()) SWIG_fail;
25734 }
25735 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25736 {
25737 if (temp2) delete arg2;
25738 }
25739 return resultobj;
25740 fail:
25741 {
25742 if (temp2) delete arg2;
25743 }
25744 return NULL;
25745 }
25746
25747
25748 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25749 PyObject *resultobj = 0;
25750 wxDateTime *arg1 = (wxDateTime *) 0 ;
25751 wxDateTime::TimeZone *arg2 = 0 ;
25752 bool arg3 = (bool) false ;
25753 wxDateTime *result = 0 ;
25754 void *argp1 = 0 ;
25755 int res1 = 0 ;
25756 bool temp2 = false ;
25757 bool val3 ;
25758 int ecode3 = 0 ;
25759 PyObject * obj0 = 0 ;
25760 PyObject * obj1 = 0 ;
25761 PyObject * obj2 = 0 ;
25762 char * kwnames[] = {
25763 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25764 };
25765
25766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25768 if (!SWIG_IsOK(res1)) {
25769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25770 }
25771 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25772 {
25773 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25774 temp2 = true;
25775 }
25776 if (obj2) {
25777 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25778 if (!SWIG_IsOK(ecode3)) {
25779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25780 }
25781 arg3 = static_cast< bool >(val3);
25782 }
25783 {
25784 PyThreadState* __tstate = wxPyBeginAllowThreads();
25785 {
25786 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25787 result = (wxDateTime *) &_result_ref;
25788 }
25789 wxPyEndAllowThreads(__tstate);
25790 if (PyErr_Occurred()) SWIG_fail;
25791 }
25792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25793 {
25794 if (temp2) delete arg2;
25795 }
25796 return resultobj;
25797 fail:
25798 {
25799 if (temp2) delete arg2;
25800 }
25801 return NULL;
25802 }
25803
25804
25805 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25806 PyObject *resultobj = 0;
25807 wxDateTime *arg1 = (wxDateTime *) 0 ;
25808 wxDateTime::TimeZone *arg2 = 0 ;
25809 bool arg3 = (bool) false ;
25810 wxDateTime result;
25811 void *argp1 = 0 ;
25812 int res1 = 0 ;
25813 bool temp2 = false ;
25814 bool val3 ;
25815 int ecode3 = 0 ;
25816 PyObject * obj0 = 0 ;
25817 PyObject * obj1 = 0 ;
25818 PyObject * obj2 = 0 ;
25819 char * kwnames[] = {
25820 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25821 };
25822
25823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25825 if (!SWIG_IsOK(res1)) {
25826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25827 }
25828 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25829 {
25830 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25831 temp2 = true;
25832 }
25833 if (obj2) {
25834 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25835 if (!SWIG_IsOK(ecode3)) {
25836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25837 }
25838 arg3 = static_cast< bool >(val3);
25839 }
25840 {
25841 PyThreadState* __tstate = wxPyBeginAllowThreads();
25842 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25843 wxPyEndAllowThreads(__tstate);
25844 if (PyErr_Occurred()) SWIG_fail;
25845 }
25846 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25847 {
25848 if (temp2) delete arg2;
25849 }
25850 return resultobj;
25851 fail:
25852 {
25853 if (temp2) delete arg2;
25854 }
25855 return NULL;
25856 }
25857
25858
25859 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25860 PyObject *resultobj = 0;
25861 wxDateTime *arg1 = (wxDateTime *) 0 ;
25862 wxDateTime::TimeZone *arg2 = 0 ;
25863 bool arg3 = (bool) false ;
25864 wxDateTime *result = 0 ;
25865 void *argp1 = 0 ;
25866 int res1 = 0 ;
25867 bool temp2 = false ;
25868 bool val3 ;
25869 int ecode3 = 0 ;
25870 PyObject * obj0 = 0 ;
25871 PyObject * obj1 = 0 ;
25872 PyObject * obj2 = 0 ;
25873 char * kwnames[] = {
25874 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25875 };
25876
25877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25879 if (!SWIG_IsOK(res1)) {
25880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25881 }
25882 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25883 {
25884 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25885 temp2 = true;
25886 }
25887 if (obj2) {
25888 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25889 if (!SWIG_IsOK(ecode3)) {
25890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25891 }
25892 arg3 = static_cast< bool >(val3);
25893 }
25894 {
25895 PyThreadState* __tstate = wxPyBeginAllowThreads();
25896 {
25897 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25898 result = (wxDateTime *) &_result_ref;
25899 }
25900 wxPyEndAllowThreads(__tstate);
25901 if (PyErr_Occurred()) SWIG_fail;
25902 }
25903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25904 {
25905 if (temp2) delete arg2;
25906 }
25907 return resultobj;
25908 fail:
25909 {
25910 if (temp2) delete arg2;
25911 }
25912 return NULL;
25913 }
25914
25915
25916 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25917 PyObject *resultobj = 0;
25918 wxDateTime *arg1 = (wxDateTime *) 0 ;
25919 bool arg2 = (bool) false ;
25920 wxDateTime result;
25921 void *argp1 = 0 ;
25922 int res1 = 0 ;
25923 bool val2 ;
25924 int ecode2 = 0 ;
25925 PyObject * obj0 = 0 ;
25926 PyObject * obj1 = 0 ;
25927 char * kwnames[] = {
25928 (char *) "self",(char *) "noDST", NULL
25929 };
25930
25931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25933 if (!SWIG_IsOK(res1)) {
25934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25935 }
25936 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25937 if (obj1) {
25938 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25939 if (!SWIG_IsOK(ecode2)) {
25940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25941 }
25942 arg2 = static_cast< bool >(val2);
25943 }
25944 {
25945 PyThreadState* __tstate = wxPyBeginAllowThreads();
25946 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25947 wxPyEndAllowThreads(__tstate);
25948 if (PyErr_Occurred()) SWIG_fail;
25949 }
25950 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25951 return resultobj;
25952 fail:
25953 return NULL;
25954 }
25955
25956
25957 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25958 PyObject *resultobj = 0;
25959 wxDateTime *arg1 = (wxDateTime *) 0 ;
25960 bool arg2 = (bool) false ;
25961 wxDateTime *result = 0 ;
25962 void *argp1 = 0 ;
25963 int res1 = 0 ;
25964 bool val2 ;
25965 int ecode2 = 0 ;
25966 PyObject * obj0 = 0 ;
25967 PyObject * obj1 = 0 ;
25968 char * kwnames[] = {
25969 (char *) "self",(char *) "noDST", NULL
25970 };
25971
25972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25974 if (!SWIG_IsOK(res1)) {
25975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25976 }
25977 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25978 if (obj1) {
25979 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25980 if (!SWIG_IsOK(ecode2)) {
25981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25982 }
25983 arg2 = static_cast< bool >(val2);
25984 }
25985 {
25986 PyThreadState* __tstate = wxPyBeginAllowThreads();
25987 {
25988 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25989 result = (wxDateTime *) &_result_ref;
25990 }
25991 wxPyEndAllowThreads(__tstate);
25992 if (PyErr_Occurred()) SWIG_fail;
25993 }
25994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25995 return resultobj;
25996 fail:
25997 return NULL;
25998 }
25999
26000
26001 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26002 PyObject *resultobj = 0;
26003 wxDateTime *arg1 = (wxDateTime *) 0 ;
26004 bool arg2 = (bool) false ;
26005 wxDateTime result;
26006 void *argp1 = 0 ;
26007 int res1 = 0 ;
26008 bool val2 ;
26009 int ecode2 = 0 ;
26010 PyObject * obj0 = 0 ;
26011 PyObject * obj1 = 0 ;
26012 char * kwnames[] = {
26013 (char *) "self",(char *) "noDST", NULL
26014 };
26015
26016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26018 if (!SWIG_IsOK(res1)) {
26019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26020 }
26021 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26022 if (obj1) {
26023 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26024 if (!SWIG_IsOK(ecode2)) {
26025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26026 }
26027 arg2 = static_cast< bool >(val2);
26028 }
26029 {
26030 PyThreadState* __tstate = wxPyBeginAllowThreads();
26031 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26032 wxPyEndAllowThreads(__tstate);
26033 if (PyErr_Occurred()) SWIG_fail;
26034 }
26035 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26036 return resultobj;
26037 fail:
26038 return NULL;
26039 }
26040
26041
26042 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26043 PyObject *resultobj = 0;
26044 wxDateTime *arg1 = (wxDateTime *) 0 ;
26045 bool arg2 = (bool) false ;
26046 wxDateTime *result = 0 ;
26047 void *argp1 = 0 ;
26048 int res1 = 0 ;
26049 bool val2 ;
26050 int ecode2 = 0 ;
26051 PyObject * obj0 = 0 ;
26052 PyObject * obj1 = 0 ;
26053 char * kwnames[] = {
26054 (char *) "self",(char *) "noDST", NULL
26055 };
26056
26057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26059 if (!SWIG_IsOK(res1)) {
26060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26061 }
26062 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26063 if (obj1) {
26064 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26065 if (!SWIG_IsOK(ecode2)) {
26066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26067 }
26068 arg2 = static_cast< bool >(val2);
26069 }
26070 {
26071 PyThreadState* __tstate = wxPyBeginAllowThreads();
26072 {
26073 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26074 result = (wxDateTime *) &_result_ref;
26075 }
26076 wxPyEndAllowThreads(__tstate);
26077 if (PyErr_Occurred()) SWIG_fail;
26078 }
26079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26080 return resultobj;
26081 fail:
26082 return NULL;
26083 }
26084
26085
26086 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26087 PyObject *resultobj = 0;
26088 wxDateTime *arg1 = (wxDateTime *) 0 ;
26089 bool arg2 = (bool) false ;
26090 wxDateTime result;
26091 void *argp1 = 0 ;
26092 int res1 = 0 ;
26093 bool val2 ;
26094 int ecode2 = 0 ;
26095 PyObject * obj0 = 0 ;
26096 PyObject * obj1 = 0 ;
26097 char * kwnames[] = {
26098 (char *) "self",(char *) "noDST", NULL
26099 };
26100
26101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26103 if (!SWIG_IsOK(res1)) {
26104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26105 }
26106 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26107 if (obj1) {
26108 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26109 if (!SWIG_IsOK(ecode2)) {
26110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26111 }
26112 arg2 = static_cast< bool >(val2);
26113 }
26114 {
26115 PyThreadState* __tstate = wxPyBeginAllowThreads();
26116 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26117 wxPyEndAllowThreads(__tstate);
26118 if (PyErr_Occurred()) SWIG_fail;
26119 }
26120 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26121 return resultobj;
26122 fail:
26123 return NULL;
26124 }
26125
26126
26127 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26128 PyObject *resultobj = 0;
26129 wxDateTime *arg1 = (wxDateTime *) 0 ;
26130 bool arg2 = (bool) false ;
26131 wxDateTime *result = 0 ;
26132 void *argp1 = 0 ;
26133 int res1 = 0 ;
26134 bool val2 ;
26135 int ecode2 = 0 ;
26136 PyObject * obj0 = 0 ;
26137 PyObject * obj1 = 0 ;
26138 char * kwnames[] = {
26139 (char *) "self",(char *) "noDST", NULL
26140 };
26141
26142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26144 if (!SWIG_IsOK(res1)) {
26145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26146 }
26147 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26148 if (obj1) {
26149 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26150 if (!SWIG_IsOK(ecode2)) {
26151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26152 }
26153 arg2 = static_cast< bool >(val2);
26154 }
26155 {
26156 PyThreadState* __tstate = wxPyBeginAllowThreads();
26157 {
26158 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26159 result = (wxDateTime *) &_result_ref;
26160 }
26161 wxPyEndAllowThreads(__tstate);
26162 if (PyErr_Occurred()) SWIG_fail;
26163 }
26164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26165 return resultobj;
26166 fail:
26167 return NULL;
26168 }
26169
26170
26171 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26172 PyObject *resultobj = 0;
26173 wxDateTime *arg1 = (wxDateTime *) 0 ;
26174 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26175 int result;
26176 void *argp1 = 0 ;
26177 int res1 = 0 ;
26178 int val2 ;
26179 int ecode2 = 0 ;
26180 PyObject * obj0 = 0 ;
26181 PyObject * obj1 = 0 ;
26182 char * kwnames[] = {
26183 (char *) "self",(char *) "country", NULL
26184 };
26185
26186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26188 if (!SWIG_IsOK(res1)) {
26189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26190 }
26191 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26192 if (obj1) {
26193 ecode2 = SWIG_AsVal_int(obj1, &val2);
26194 if (!SWIG_IsOK(ecode2)) {
26195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26196 }
26197 arg2 = static_cast< wxDateTime::Country >(val2);
26198 }
26199 {
26200 PyThreadState* __tstate = wxPyBeginAllowThreads();
26201 result = (int)(arg1)->IsDST(arg2);
26202 wxPyEndAllowThreads(__tstate);
26203 if (PyErr_Occurred()) SWIG_fail;
26204 }
26205 resultobj = SWIG_From_int(static_cast< int >(result));
26206 return resultobj;
26207 fail:
26208 return NULL;
26209 }
26210
26211
26212 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26213 PyObject *resultobj = 0;
26214 wxDateTime *arg1 = (wxDateTime *) 0 ;
26215 bool result;
26216 void *argp1 = 0 ;
26217 int res1 = 0 ;
26218 PyObject *swig_obj[1] ;
26219
26220 if (!args) SWIG_fail;
26221 swig_obj[0] = args;
26222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26223 if (!SWIG_IsOK(res1)) {
26224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26225 }
26226 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26227 {
26228 PyThreadState* __tstate = wxPyBeginAllowThreads();
26229 result = (bool)((wxDateTime const *)arg1)->IsValid();
26230 wxPyEndAllowThreads(__tstate);
26231 if (PyErr_Occurred()) SWIG_fail;
26232 }
26233 {
26234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26235 }
26236 return resultobj;
26237 fail:
26238 return NULL;
26239 }
26240
26241
26242 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26243 PyObject *resultobj = 0;
26244 wxDateTime *arg1 = (wxDateTime *) 0 ;
26245 time_t result;
26246 void *argp1 = 0 ;
26247 int res1 = 0 ;
26248 PyObject *swig_obj[1] ;
26249
26250 if (!args) SWIG_fail;
26251 swig_obj[0] = args;
26252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26253 if (!SWIG_IsOK(res1)) {
26254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26255 }
26256 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26257 {
26258 PyThreadState* __tstate = wxPyBeginAllowThreads();
26259 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26260 wxPyEndAllowThreads(__tstate);
26261 if (PyErr_Occurred()) SWIG_fail;
26262 }
26263 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26264 return resultobj;
26265 fail:
26266 return NULL;
26267 }
26268
26269
26270 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26271 PyObject *resultobj = 0;
26272 wxDateTime *arg1 = (wxDateTime *) 0 ;
26273 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26274 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26275 int result;
26276 void *argp1 = 0 ;
26277 int res1 = 0 ;
26278 bool temp2 = false ;
26279 PyObject * obj0 = 0 ;
26280 PyObject * obj1 = 0 ;
26281 char * kwnames[] = {
26282 (char *) "self",(char *) "tz", NULL
26283 };
26284
26285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26287 if (!SWIG_IsOK(res1)) {
26288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26289 }
26290 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26291 if (obj1) {
26292 {
26293 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26294 temp2 = true;
26295 }
26296 }
26297 {
26298 PyThreadState* __tstate = wxPyBeginAllowThreads();
26299 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26300 wxPyEndAllowThreads(__tstate);
26301 if (PyErr_Occurred()) SWIG_fail;
26302 }
26303 resultobj = SWIG_From_int(static_cast< int >(result));
26304 {
26305 if (temp2) delete arg2;
26306 }
26307 return resultobj;
26308 fail:
26309 {
26310 if (temp2) delete arg2;
26311 }
26312 return NULL;
26313 }
26314
26315
26316 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26317 PyObject *resultobj = 0;
26318 wxDateTime *arg1 = (wxDateTime *) 0 ;
26319 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26320 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26321 wxDateTime::Month result;
26322 void *argp1 = 0 ;
26323 int res1 = 0 ;
26324 bool temp2 = false ;
26325 PyObject * obj0 = 0 ;
26326 PyObject * obj1 = 0 ;
26327 char * kwnames[] = {
26328 (char *) "self",(char *) "tz", NULL
26329 };
26330
26331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26333 if (!SWIG_IsOK(res1)) {
26334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26335 }
26336 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26337 if (obj1) {
26338 {
26339 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26340 temp2 = true;
26341 }
26342 }
26343 {
26344 PyThreadState* __tstate = wxPyBeginAllowThreads();
26345 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26346 wxPyEndAllowThreads(__tstate);
26347 if (PyErr_Occurred()) SWIG_fail;
26348 }
26349 resultobj = SWIG_From_int(static_cast< int >(result));
26350 {
26351 if (temp2) delete arg2;
26352 }
26353 return resultobj;
26354 fail:
26355 {
26356 if (temp2) delete arg2;
26357 }
26358 return NULL;
26359 }
26360
26361
26362 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26363 PyObject *resultobj = 0;
26364 wxDateTime *arg1 = (wxDateTime *) 0 ;
26365 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26366 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26367 int result;
26368 void *argp1 = 0 ;
26369 int res1 = 0 ;
26370 bool temp2 = false ;
26371 PyObject * obj0 = 0 ;
26372 PyObject * obj1 = 0 ;
26373 char * kwnames[] = {
26374 (char *) "self",(char *) "tz", NULL
26375 };
26376
26377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26379 if (!SWIG_IsOK(res1)) {
26380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26381 }
26382 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26383 if (obj1) {
26384 {
26385 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26386 temp2 = true;
26387 }
26388 }
26389 {
26390 PyThreadState* __tstate = wxPyBeginAllowThreads();
26391 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26392 wxPyEndAllowThreads(__tstate);
26393 if (PyErr_Occurred()) SWIG_fail;
26394 }
26395 resultobj = SWIG_From_int(static_cast< int >(result));
26396 {
26397 if (temp2) delete arg2;
26398 }
26399 return resultobj;
26400 fail:
26401 {
26402 if (temp2) delete arg2;
26403 }
26404 return NULL;
26405 }
26406
26407
26408 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26409 PyObject *resultobj = 0;
26410 wxDateTime *arg1 = (wxDateTime *) 0 ;
26411 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26412 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26413 wxDateTime::WeekDay result;
26414 void *argp1 = 0 ;
26415 int res1 = 0 ;
26416 bool temp2 = false ;
26417 PyObject * obj0 = 0 ;
26418 PyObject * obj1 = 0 ;
26419 char * kwnames[] = {
26420 (char *) "self",(char *) "tz", NULL
26421 };
26422
26423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26425 if (!SWIG_IsOK(res1)) {
26426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26427 }
26428 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26429 if (obj1) {
26430 {
26431 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26432 temp2 = true;
26433 }
26434 }
26435 {
26436 PyThreadState* __tstate = wxPyBeginAllowThreads();
26437 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26438 wxPyEndAllowThreads(__tstate);
26439 if (PyErr_Occurred()) SWIG_fail;
26440 }
26441 resultobj = SWIG_From_int(static_cast< int >(result));
26442 {
26443 if (temp2) delete arg2;
26444 }
26445 return resultobj;
26446 fail:
26447 {
26448 if (temp2) delete arg2;
26449 }
26450 return NULL;
26451 }
26452
26453
26454 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26455 PyObject *resultobj = 0;
26456 wxDateTime *arg1 = (wxDateTime *) 0 ;
26457 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26458 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26459 int result;
26460 void *argp1 = 0 ;
26461 int res1 = 0 ;
26462 bool temp2 = false ;
26463 PyObject * obj0 = 0 ;
26464 PyObject * obj1 = 0 ;
26465 char * kwnames[] = {
26466 (char *) "self",(char *) "tz", NULL
26467 };
26468
26469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26471 if (!SWIG_IsOK(res1)) {
26472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26473 }
26474 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26475 if (obj1) {
26476 {
26477 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26478 temp2 = true;
26479 }
26480 }
26481 {
26482 PyThreadState* __tstate = wxPyBeginAllowThreads();
26483 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26484 wxPyEndAllowThreads(__tstate);
26485 if (PyErr_Occurred()) SWIG_fail;
26486 }
26487 resultobj = SWIG_From_int(static_cast< int >(result));
26488 {
26489 if (temp2) delete arg2;
26490 }
26491 return resultobj;
26492 fail:
26493 {
26494 if (temp2) delete arg2;
26495 }
26496 return NULL;
26497 }
26498
26499
26500 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26501 PyObject *resultobj = 0;
26502 wxDateTime *arg1 = (wxDateTime *) 0 ;
26503 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26504 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26505 int result;
26506 void *argp1 = 0 ;
26507 int res1 = 0 ;
26508 bool temp2 = false ;
26509 PyObject * obj0 = 0 ;
26510 PyObject * obj1 = 0 ;
26511 char * kwnames[] = {
26512 (char *) "self",(char *) "tz", NULL
26513 };
26514
26515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26517 if (!SWIG_IsOK(res1)) {
26518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26519 }
26520 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26521 if (obj1) {
26522 {
26523 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26524 temp2 = true;
26525 }
26526 }
26527 {
26528 PyThreadState* __tstate = wxPyBeginAllowThreads();
26529 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26530 wxPyEndAllowThreads(__tstate);
26531 if (PyErr_Occurred()) SWIG_fail;
26532 }
26533 resultobj = SWIG_From_int(static_cast< int >(result));
26534 {
26535 if (temp2) delete arg2;
26536 }
26537 return resultobj;
26538 fail:
26539 {
26540 if (temp2) delete arg2;
26541 }
26542 return NULL;
26543 }
26544
26545
26546 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26547 PyObject *resultobj = 0;
26548 wxDateTime *arg1 = (wxDateTime *) 0 ;
26549 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26550 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26551 int result;
26552 void *argp1 = 0 ;
26553 int res1 = 0 ;
26554 bool temp2 = false ;
26555 PyObject * obj0 = 0 ;
26556 PyObject * obj1 = 0 ;
26557 char * kwnames[] = {
26558 (char *) "self",(char *) "tz", NULL
26559 };
26560
26561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26563 if (!SWIG_IsOK(res1)) {
26564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26565 }
26566 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26567 if (obj1) {
26568 {
26569 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26570 temp2 = true;
26571 }
26572 }
26573 {
26574 PyThreadState* __tstate = wxPyBeginAllowThreads();
26575 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26576 wxPyEndAllowThreads(__tstate);
26577 if (PyErr_Occurred()) SWIG_fail;
26578 }
26579 resultobj = SWIG_From_int(static_cast< int >(result));
26580 {
26581 if (temp2) delete arg2;
26582 }
26583 return resultobj;
26584 fail:
26585 {
26586 if (temp2) delete arg2;
26587 }
26588 return NULL;
26589 }
26590
26591
26592 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26593 PyObject *resultobj = 0;
26594 wxDateTime *arg1 = (wxDateTime *) 0 ;
26595 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26596 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26597 int result;
26598 void *argp1 = 0 ;
26599 int res1 = 0 ;
26600 bool temp2 = false ;
26601 PyObject * obj0 = 0 ;
26602 PyObject * obj1 = 0 ;
26603 char * kwnames[] = {
26604 (char *) "self",(char *) "tz", NULL
26605 };
26606
26607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26609 if (!SWIG_IsOK(res1)) {
26610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26611 }
26612 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26613 if (obj1) {
26614 {
26615 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26616 temp2 = true;
26617 }
26618 }
26619 {
26620 PyThreadState* __tstate = wxPyBeginAllowThreads();
26621 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26622 wxPyEndAllowThreads(__tstate);
26623 if (PyErr_Occurred()) SWIG_fail;
26624 }
26625 resultobj = SWIG_From_int(static_cast< int >(result));
26626 {
26627 if (temp2) delete arg2;
26628 }
26629 return resultobj;
26630 fail:
26631 {
26632 if (temp2) delete arg2;
26633 }
26634 return NULL;
26635 }
26636
26637
26638 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26639 PyObject *resultobj = 0;
26640 wxDateTime *arg1 = (wxDateTime *) 0 ;
26641 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26642 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26643 int result;
26644 void *argp1 = 0 ;
26645 int res1 = 0 ;
26646 bool temp2 = false ;
26647 PyObject * obj0 = 0 ;
26648 PyObject * obj1 = 0 ;
26649 char * kwnames[] = {
26650 (char *) "self",(char *) "tz", NULL
26651 };
26652
26653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26655 if (!SWIG_IsOK(res1)) {
26656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26657 }
26658 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26659 if (obj1) {
26660 {
26661 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26662 temp2 = true;
26663 }
26664 }
26665 {
26666 PyThreadState* __tstate = wxPyBeginAllowThreads();
26667 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26668 wxPyEndAllowThreads(__tstate);
26669 if (PyErr_Occurred()) SWIG_fail;
26670 }
26671 resultobj = SWIG_From_int(static_cast< int >(result));
26672 {
26673 if (temp2) delete arg2;
26674 }
26675 return resultobj;
26676 fail:
26677 {
26678 if (temp2) delete arg2;
26679 }
26680 return NULL;
26681 }
26682
26683
26684 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26685 PyObject *resultobj = 0;
26686 wxDateTime *arg1 = (wxDateTime *) 0 ;
26687 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26688 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26689 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26690 int result;
26691 void *argp1 = 0 ;
26692 int res1 = 0 ;
26693 int val2 ;
26694 int ecode2 = 0 ;
26695 bool temp3 = false ;
26696 PyObject * obj0 = 0 ;
26697 PyObject * obj1 = 0 ;
26698 PyObject * obj2 = 0 ;
26699 char * kwnames[] = {
26700 (char *) "self",(char *) "flags",(char *) "tz", NULL
26701 };
26702
26703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26705 if (!SWIG_IsOK(res1)) {
26706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26707 }
26708 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26709 if (obj1) {
26710 ecode2 = SWIG_AsVal_int(obj1, &val2);
26711 if (!SWIG_IsOK(ecode2)) {
26712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26713 }
26714 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26715 }
26716 if (obj2) {
26717 {
26718 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26719 temp3 = true;
26720 }
26721 }
26722 {
26723 PyThreadState* __tstate = wxPyBeginAllowThreads();
26724 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26725 wxPyEndAllowThreads(__tstate);
26726 if (PyErr_Occurred()) SWIG_fail;
26727 }
26728 resultobj = SWIG_From_int(static_cast< int >(result));
26729 {
26730 if (temp3) delete arg3;
26731 }
26732 return resultobj;
26733 fail:
26734 {
26735 if (temp3) delete arg3;
26736 }
26737 return NULL;
26738 }
26739
26740
26741 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26742 PyObject *resultobj = 0;
26743 wxDateTime *arg1 = (wxDateTime *) 0 ;
26744 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26745 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26746 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26747 int result;
26748 void *argp1 = 0 ;
26749 int res1 = 0 ;
26750 int val2 ;
26751 int ecode2 = 0 ;
26752 bool temp3 = false ;
26753 PyObject * obj0 = 0 ;
26754 PyObject * obj1 = 0 ;
26755 PyObject * obj2 = 0 ;
26756 char * kwnames[] = {
26757 (char *) "self",(char *) "flags",(char *) "tz", NULL
26758 };
26759
26760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26762 if (!SWIG_IsOK(res1)) {
26763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26764 }
26765 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26766 if (obj1) {
26767 ecode2 = SWIG_AsVal_int(obj1, &val2);
26768 if (!SWIG_IsOK(ecode2)) {
26769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26770 }
26771 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26772 }
26773 if (obj2) {
26774 {
26775 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26776 temp3 = true;
26777 }
26778 }
26779 {
26780 PyThreadState* __tstate = wxPyBeginAllowThreads();
26781 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26782 wxPyEndAllowThreads(__tstate);
26783 if (PyErr_Occurred()) SWIG_fail;
26784 }
26785 resultobj = SWIG_From_int(static_cast< int >(result));
26786 {
26787 if (temp3) delete arg3;
26788 }
26789 return resultobj;
26790 fail:
26791 {
26792 if (temp3) delete arg3;
26793 }
26794 return NULL;
26795 }
26796
26797
26798 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26799 PyObject *resultobj = 0;
26800 wxDateTime *arg1 = (wxDateTime *) 0 ;
26801 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26802 bool result;
26803 void *argp1 = 0 ;
26804 int res1 = 0 ;
26805 int val2 ;
26806 int ecode2 = 0 ;
26807 PyObject * obj0 = 0 ;
26808 PyObject * obj1 = 0 ;
26809 char * kwnames[] = {
26810 (char *) "self",(char *) "country", NULL
26811 };
26812
26813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26815 if (!SWIG_IsOK(res1)) {
26816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26817 }
26818 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26819 if (obj1) {
26820 ecode2 = SWIG_AsVal_int(obj1, &val2);
26821 if (!SWIG_IsOK(ecode2)) {
26822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26823 }
26824 arg2 = static_cast< wxDateTime::Country >(val2);
26825 }
26826 {
26827 PyThreadState* __tstate = wxPyBeginAllowThreads();
26828 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26829 wxPyEndAllowThreads(__tstate);
26830 if (PyErr_Occurred()) SWIG_fail;
26831 }
26832 {
26833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26834 }
26835 return resultobj;
26836 fail:
26837 return NULL;
26838 }
26839
26840
26841 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26842 PyObject *resultobj = 0;
26843 wxDateTime *arg1 = (wxDateTime *) 0 ;
26844 wxDateTime *arg2 = 0 ;
26845 bool result;
26846 void *argp1 = 0 ;
26847 int res1 = 0 ;
26848 void *argp2 = 0 ;
26849 int res2 = 0 ;
26850 PyObject * obj0 = 0 ;
26851 PyObject * obj1 = 0 ;
26852 char * kwnames[] = {
26853 (char *) "self",(char *) "datetime", NULL
26854 };
26855
26856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26858 if (!SWIG_IsOK(res1)) {
26859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26860 }
26861 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26862 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26863 if (!SWIG_IsOK(res2)) {
26864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26865 }
26866 if (!argp2) {
26867 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26868 }
26869 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26870 {
26871 PyThreadState* __tstate = wxPyBeginAllowThreads();
26872 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26873 wxPyEndAllowThreads(__tstate);
26874 if (PyErr_Occurred()) SWIG_fail;
26875 }
26876 {
26877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26878 }
26879 return resultobj;
26880 fail:
26881 return NULL;
26882 }
26883
26884
26885 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26886 PyObject *resultobj = 0;
26887 wxDateTime *arg1 = (wxDateTime *) 0 ;
26888 wxDateTime *arg2 = 0 ;
26889 bool result;
26890 void *argp1 = 0 ;
26891 int res1 = 0 ;
26892 void *argp2 = 0 ;
26893 int res2 = 0 ;
26894 PyObject * obj0 = 0 ;
26895 PyObject * obj1 = 0 ;
26896 char * kwnames[] = {
26897 (char *) "self",(char *) "datetime", NULL
26898 };
26899
26900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26902 if (!SWIG_IsOK(res1)) {
26903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26904 }
26905 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26906 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26907 if (!SWIG_IsOK(res2)) {
26908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26909 }
26910 if (!argp2) {
26911 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26912 }
26913 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26914 {
26915 PyThreadState* __tstate = wxPyBeginAllowThreads();
26916 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26917 wxPyEndAllowThreads(__tstate);
26918 if (PyErr_Occurred()) SWIG_fail;
26919 }
26920 {
26921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26922 }
26923 return resultobj;
26924 fail:
26925 return NULL;
26926 }
26927
26928
26929 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26930 PyObject *resultobj = 0;
26931 wxDateTime *arg1 = (wxDateTime *) 0 ;
26932 wxDateTime *arg2 = 0 ;
26933 bool result;
26934 void *argp1 = 0 ;
26935 int res1 = 0 ;
26936 void *argp2 = 0 ;
26937 int res2 = 0 ;
26938 PyObject * obj0 = 0 ;
26939 PyObject * obj1 = 0 ;
26940 char * kwnames[] = {
26941 (char *) "self",(char *) "datetime", NULL
26942 };
26943
26944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26946 if (!SWIG_IsOK(res1)) {
26947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26948 }
26949 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26950 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26951 if (!SWIG_IsOK(res2)) {
26952 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26953 }
26954 if (!argp2) {
26955 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26956 }
26957 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26958 {
26959 PyThreadState* __tstate = wxPyBeginAllowThreads();
26960 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26961 wxPyEndAllowThreads(__tstate);
26962 if (PyErr_Occurred()) SWIG_fail;
26963 }
26964 {
26965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26966 }
26967 return resultobj;
26968 fail:
26969 return NULL;
26970 }
26971
26972
26973 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26974 PyObject *resultobj = 0;
26975 wxDateTime *arg1 = (wxDateTime *) 0 ;
26976 wxDateTime *arg2 = 0 ;
26977 wxDateTime *arg3 = 0 ;
26978 bool result;
26979 void *argp1 = 0 ;
26980 int res1 = 0 ;
26981 void *argp2 = 0 ;
26982 int res2 = 0 ;
26983 void *argp3 = 0 ;
26984 int res3 = 0 ;
26985 PyObject * obj0 = 0 ;
26986 PyObject * obj1 = 0 ;
26987 PyObject * obj2 = 0 ;
26988 char * kwnames[] = {
26989 (char *) "self",(char *) "t1",(char *) "t2", NULL
26990 };
26991
26992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26994 if (!SWIG_IsOK(res1)) {
26995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26996 }
26997 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26998 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26999 if (!SWIG_IsOK(res2)) {
27000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27001 }
27002 if (!argp2) {
27003 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27004 }
27005 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27006 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27007 if (!SWIG_IsOK(res3)) {
27008 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27009 }
27010 if (!argp3) {
27011 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27012 }
27013 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27014 {
27015 PyThreadState* __tstate = wxPyBeginAllowThreads();
27016 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27017 wxPyEndAllowThreads(__tstate);
27018 if (PyErr_Occurred()) SWIG_fail;
27019 }
27020 {
27021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27022 }
27023 return resultobj;
27024 fail:
27025 return NULL;
27026 }
27027
27028
27029 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27030 PyObject *resultobj = 0;
27031 wxDateTime *arg1 = (wxDateTime *) 0 ;
27032 wxDateTime *arg2 = 0 ;
27033 wxDateTime *arg3 = 0 ;
27034 bool result;
27035 void *argp1 = 0 ;
27036 int res1 = 0 ;
27037 void *argp2 = 0 ;
27038 int res2 = 0 ;
27039 void *argp3 = 0 ;
27040 int res3 = 0 ;
27041 PyObject * obj0 = 0 ;
27042 PyObject * obj1 = 0 ;
27043 PyObject * obj2 = 0 ;
27044 char * kwnames[] = {
27045 (char *) "self",(char *) "t1",(char *) "t2", NULL
27046 };
27047
27048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27050 if (!SWIG_IsOK(res1)) {
27051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27052 }
27053 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27054 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27055 if (!SWIG_IsOK(res2)) {
27056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27057 }
27058 if (!argp2) {
27059 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27060 }
27061 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27062 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27063 if (!SWIG_IsOK(res3)) {
27064 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27065 }
27066 if (!argp3) {
27067 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27068 }
27069 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27070 {
27071 PyThreadState* __tstate = wxPyBeginAllowThreads();
27072 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27073 wxPyEndAllowThreads(__tstate);
27074 if (PyErr_Occurred()) SWIG_fail;
27075 }
27076 {
27077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27078 }
27079 return resultobj;
27080 fail:
27081 return NULL;
27082 }
27083
27084
27085 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27086 PyObject *resultobj = 0;
27087 wxDateTime *arg1 = (wxDateTime *) 0 ;
27088 wxDateTime *arg2 = 0 ;
27089 bool result;
27090 void *argp1 = 0 ;
27091 int res1 = 0 ;
27092 void *argp2 = 0 ;
27093 int res2 = 0 ;
27094 PyObject * obj0 = 0 ;
27095 PyObject * obj1 = 0 ;
27096 char * kwnames[] = {
27097 (char *) "self",(char *) "dt", NULL
27098 };
27099
27100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27102 if (!SWIG_IsOK(res1)) {
27103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27104 }
27105 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27106 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27107 if (!SWIG_IsOK(res2)) {
27108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27109 }
27110 if (!argp2) {
27111 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27112 }
27113 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27114 {
27115 PyThreadState* __tstate = wxPyBeginAllowThreads();
27116 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27117 wxPyEndAllowThreads(__tstate);
27118 if (PyErr_Occurred()) SWIG_fail;
27119 }
27120 {
27121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27122 }
27123 return resultobj;
27124 fail:
27125 return NULL;
27126 }
27127
27128
27129 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27130 PyObject *resultobj = 0;
27131 wxDateTime *arg1 = (wxDateTime *) 0 ;
27132 wxDateTime *arg2 = 0 ;
27133 bool result;
27134 void *argp1 = 0 ;
27135 int res1 = 0 ;
27136 void *argp2 = 0 ;
27137 int res2 = 0 ;
27138 PyObject * obj0 = 0 ;
27139 PyObject * obj1 = 0 ;
27140 char * kwnames[] = {
27141 (char *) "self",(char *) "dt", NULL
27142 };
27143
27144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27146 if (!SWIG_IsOK(res1)) {
27147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27148 }
27149 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27150 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27151 if (!SWIG_IsOK(res2)) {
27152 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27153 }
27154 if (!argp2) {
27155 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27156 }
27157 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27158 {
27159 PyThreadState* __tstate = wxPyBeginAllowThreads();
27160 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27161 wxPyEndAllowThreads(__tstate);
27162 if (PyErr_Occurred()) SWIG_fail;
27163 }
27164 {
27165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27166 }
27167 return resultobj;
27168 fail:
27169 return NULL;
27170 }
27171
27172
27173 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27174 PyObject *resultobj = 0;
27175 wxDateTime *arg1 = (wxDateTime *) 0 ;
27176 wxDateTime *arg2 = 0 ;
27177 wxTimeSpan *arg3 = 0 ;
27178 bool result;
27179 void *argp1 = 0 ;
27180 int res1 = 0 ;
27181 void *argp2 = 0 ;
27182 int res2 = 0 ;
27183 void *argp3 = 0 ;
27184 int res3 = 0 ;
27185 PyObject * obj0 = 0 ;
27186 PyObject * obj1 = 0 ;
27187 PyObject * obj2 = 0 ;
27188 char * kwnames[] = {
27189 (char *) "self",(char *) "dt",(char *) "ts", NULL
27190 };
27191
27192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27194 if (!SWIG_IsOK(res1)) {
27195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27196 }
27197 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27198 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27199 if (!SWIG_IsOK(res2)) {
27200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27201 }
27202 if (!argp2) {
27203 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27204 }
27205 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27206 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27207 if (!SWIG_IsOK(res3)) {
27208 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27209 }
27210 if (!argp3) {
27211 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27212 }
27213 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27214 {
27215 PyThreadState* __tstate = wxPyBeginAllowThreads();
27216 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27217 wxPyEndAllowThreads(__tstate);
27218 if (PyErr_Occurred()) SWIG_fail;
27219 }
27220 {
27221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27222 }
27223 return resultobj;
27224 fail:
27225 return NULL;
27226 }
27227
27228
27229 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27230 PyObject *resultobj = 0;
27231 wxDateTime *arg1 = (wxDateTime *) 0 ;
27232 wxTimeSpan *arg2 = 0 ;
27233 wxDateTime *result = 0 ;
27234 void *argp1 = 0 ;
27235 int res1 = 0 ;
27236 void *argp2 = 0 ;
27237 int res2 = 0 ;
27238 PyObject * obj0 = 0 ;
27239 PyObject * obj1 = 0 ;
27240 char * kwnames[] = {
27241 (char *) "self",(char *) "diff", NULL
27242 };
27243
27244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27246 if (!SWIG_IsOK(res1)) {
27247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27248 }
27249 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27250 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27251 if (!SWIG_IsOK(res2)) {
27252 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27253 }
27254 if (!argp2) {
27255 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27256 }
27257 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27258 {
27259 PyThreadState* __tstate = wxPyBeginAllowThreads();
27260 {
27261 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27262 result = (wxDateTime *) &_result_ref;
27263 }
27264 wxPyEndAllowThreads(__tstate);
27265 if (PyErr_Occurred()) SWIG_fail;
27266 }
27267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27268 return resultobj;
27269 fail:
27270 return NULL;
27271 }
27272
27273
27274 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27275 PyObject *resultobj = 0;
27276 wxDateTime *arg1 = (wxDateTime *) 0 ;
27277 wxDateSpan *arg2 = 0 ;
27278 wxDateTime *result = 0 ;
27279 void *argp1 = 0 ;
27280 int res1 = 0 ;
27281 void *argp2 = 0 ;
27282 int res2 = 0 ;
27283 PyObject * obj0 = 0 ;
27284 PyObject * obj1 = 0 ;
27285 char * kwnames[] = {
27286 (char *) "self",(char *) "diff", NULL
27287 };
27288
27289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27291 if (!SWIG_IsOK(res1)) {
27292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27293 }
27294 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27295 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27296 if (!SWIG_IsOK(res2)) {
27297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27298 }
27299 if (!argp2) {
27300 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27301 }
27302 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27303 {
27304 PyThreadState* __tstate = wxPyBeginAllowThreads();
27305 {
27306 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27307 result = (wxDateTime *) &_result_ref;
27308 }
27309 wxPyEndAllowThreads(__tstate);
27310 if (PyErr_Occurred()) SWIG_fail;
27311 }
27312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27313 return resultobj;
27314 fail:
27315 return NULL;
27316 }
27317
27318
27319 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27320 PyObject *resultobj = 0;
27321 wxDateTime *arg1 = (wxDateTime *) 0 ;
27322 wxTimeSpan *arg2 = 0 ;
27323 wxDateTime *result = 0 ;
27324 void *argp1 = 0 ;
27325 int res1 = 0 ;
27326 void *argp2 = 0 ;
27327 int res2 = 0 ;
27328 PyObject * obj0 = 0 ;
27329 PyObject * obj1 = 0 ;
27330 char * kwnames[] = {
27331 (char *) "self",(char *) "diff", NULL
27332 };
27333
27334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27336 if (!SWIG_IsOK(res1)) {
27337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27338 }
27339 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27340 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27341 if (!SWIG_IsOK(res2)) {
27342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27343 }
27344 if (!argp2) {
27345 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27346 }
27347 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27348 {
27349 PyThreadState* __tstate = wxPyBeginAllowThreads();
27350 {
27351 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27352 result = (wxDateTime *) &_result_ref;
27353 }
27354 wxPyEndAllowThreads(__tstate);
27355 if (PyErr_Occurred()) SWIG_fail;
27356 }
27357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27358 return resultobj;
27359 fail:
27360 return NULL;
27361 }
27362
27363
27364 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27365 PyObject *resultobj = 0;
27366 wxDateTime *arg1 = (wxDateTime *) 0 ;
27367 wxDateSpan *arg2 = 0 ;
27368 wxDateTime *result = 0 ;
27369 void *argp1 = 0 ;
27370 int res1 = 0 ;
27371 void *argp2 = 0 ;
27372 int res2 = 0 ;
27373 PyObject * obj0 = 0 ;
27374 PyObject * obj1 = 0 ;
27375 char * kwnames[] = {
27376 (char *) "self",(char *) "diff", NULL
27377 };
27378
27379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27381 if (!SWIG_IsOK(res1)) {
27382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27383 }
27384 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27385 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27386 if (!SWIG_IsOK(res2)) {
27387 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27388 }
27389 if (!argp2) {
27390 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27391 }
27392 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27393 {
27394 PyThreadState* __tstate = wxPyBeginAllowThreads();
27395 {
27396 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27397 result = (wxDateTime *) &_result_ref;
27398 }
27399 wxPyEndAllowThreads(__tstate);
27400 if (PyErr_Occurred()) SWIG_fail;
27401 }
27402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27403 return resultobj;
27404 fail:
27405 return NULL;
27406 }
27407
27408
27409 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27410 PyObject *resultobj = 0;
27411 wxDateTime *arg1 = (wxDateTime *) 0 ;
27412 wxDateTime *arg2 = 0 ;
27413 wxTimeSpan result;
27414 void *argp1 = 0 ;
27415 int res1 = 0 ;
27416 void *argp2 = 0 ;
27417 int res2 = 0 ;
27418 PyObject * obj0 = 0 ;
27419 PyObject * obj1 = 0 ;
27420 char * kwnames[] = {
27421 (char *) "self",(char *) "dt", NULL
27422 };
27423
27424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27426 if (!SWIG_IsOK(res1)) {
27427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27428 }
27429 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27430 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27431 if (!SWIG_IsOK(res2)) {
27432 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27433 }
27434 if (!argp2) {
27435 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27436 }
27437 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27438 {
27439 PyThreadState* __tstate = wxPyBeginAllowThreads();
27440 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27441 wxPyEndAllowThreads(__tstate);
27442 if (PyErr_Occurred()) SWIG_fail;
27443 }
27444 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27445 return resultobj;
27446 fail:
27447 return NULL;
27448 }
27449
27450
27451 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27452 PyObject *resultobj = 0;
27453 wxDateTime *arg1 = (wxDateTime *) 0 ;
27454 wxTimeSpan *arg2 = 0 ;
27455 wxDateTime *result = 0 ;
27456 void *argp1 = 0 ;
27457 int res1 = 0 ;
27458 void *argp2 = 0 ;
27459 int res2 = 0 ;
27460
27461 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27463 if (!SWIG_IsOK(res1)) {
27464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27465 }
27466 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27467 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27468 if (!SWIG_IsOK(res2)) {
27469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27470 }
27471 if (!argp2) {
27472 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27473 }
27474 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27475 {
27476 PyThreadState* __tstate = wxPyBeginAllowThreads();
27477 {
27478 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27479 result = (wxDateTime *) &_result_ref;
27480 }
27481 wxPyEndAllowThreads(__tstate);
27482 if (PyErr_Occurred()) SWIG_fail;
27483 }
27484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27485 return resultobj;
27486 fail:
27487 return NULL;
27488 }
27489
27490
27491 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27492 PyObject *resultobj = 0;
27493 wxDateTime *arg1 = (wxDateTime *) 0 ;
27494 wxDateSpan *arg2 = 0 ;
27495 wxDateTime *result = 0 ;
27496 void *argp1 = 0 ;
27497 int res1 = 0 ;
27498 void *argp2 = 0 ;
27499 int res2 = 0 ;
27500
27501 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27503 if (!SWIG_IsOK(res1)) {
27504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27505 }
27506 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27507 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27508 if (!SWIG_IsOK(res2)) {
27509 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27510 }
27511 if (!argp2) {
27512 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27513 }
27514 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27515 {
27516 PyThreadState* __tstate = wxPyBeginAllowThreads();
27517 {
27518 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27519 result = (wxDateTime *) &_result_ref;
27520 }
27521 wxPyEndAllowThreads(__tstate);
27522 if (PyErr_Occurred()) SWIG_fail;
27523 }
27524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27525 return resultobj;
27526 fail:
27527 return NULL;
27528 }
27529
27530
27531 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27532 int argc;
27533 PyObject *argv[3];
27534
27535 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27536 --argc;
27537 if (argc == 2) {
27538 int _v = 0;
27539 {
27540 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27541 _v = SWIG_CheckState(res);
27542 }
27543 if (!_v) goto check_1;
27544 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27545 }
27546 check_1:
27547
27548 if (argc == 2) {
27549 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27550 }
27551
27552 fail:
27553 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27554 return NULL;
27555 }
27556
27557
27558 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27559 PyObject *resultobj = 0;
27560 wxDateTime *arg1 = (wxDateTime *) 0 ;
27561 wxTimeSpan *arg2 = 0 ;
27562 wxDateTime *result = 0 ;
27563 void *argp1 = 0 ;
27564 int res1 = 0 ;
27565 void *argp2 = 0 ;
27566 int res2 = 0 ;
27567
27568 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27570 if (!SWIG_IsOK(res1)) {
27571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27572 }
27573 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27574 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27575 if (!SWIG_IsOK(res2)) {
27576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27577 }
27578 if (!argp2) {
27579 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27580 }
27581 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27582 {
27583 PyThreadState* __tstate = wxPyBeginAllowThreads();
27584 {
27585 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27586 result = (wxDateTime *) &_result_ref;
27587 }
27588 wxPyEndAllowThreads(__tstate);
27589 if (PyErr_Occurred()) SWIG_fail;
27590 }
27591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27592 return resultobj;
27593 fail:
27594 return NULL;
27595 }
27596
27597
27598 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27599 PyObject *resultobj = 0;
27600 wxDateTime *arg1 = (wxDateTime *) 0 ;
27601 wxDateSpan *arg2 = 0 ;
27602 wxDateTime *result = 0 ;
27603 void *argp1 = 0 ;
27604 int res1 = 0 ;
27605 void *argp2 = 0 ;
27606 int res2 = 0 ;
27607
27608 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27610 if (!SWIG_IsOK(res1)) {
27611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27612 }
27613 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27614 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27615 if (!SWIG_IsOK(res2)) {
27616 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27617 }
27618 if (!argp2) {
27619 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27620 }
27621 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27622 {
27623 PyThreadState* __tstate = wxPyBeginAllowThreads();
27624 {
27625 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27626 result = (wxDateTime *) &_result_ref;
27627 }
27628 wxPyEndAllowThreads(__tstate);
27629 if (PyErr_Occurred()) SWIG_fail;
27630 }
27631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27632 return resultobj;
27633 fail:
27634 return NULL;
27635 }
27636
27637
27638 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27639 int argc;
27640 PyObject *argv[3];
27641
27642 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27643 --argc;
27644 if (argc == 2) {
27645 int _v = 0;
27646 {
27647 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27648 _v = SWIG_CheckState(res);
27649 }
27650 if (!_v) goto check_1;
27651 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27652 }
27653 check_1:
27654
27655 if (argc == 2) {
27656 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27657 }
27658
27659 fail:
27660 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27661 return NULL;
27662 }
27663
27664
27665 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27666 PyObject *resultobj = 0;
27667 wxDateTime *arg1 = (wxDateTime *) 0 ;
27668 wxTimeSpan *arg2 = 0 ;
27669 wxDateTime result;
27670 void *argp1 = 0 ;
27671 int res1 = 0 ;
27672 void *argp2 = 0 ;
27673 int res2 = 0 ;
27674
27675 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27677 if (!SWIG_IsOK(res1)) {
27678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27679 }
27680 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27681 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27682 if (!SWIG_IsOK(res2)) {
27683 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27684 }
27685 if (!argp2) {
27686 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27687 }
27688 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27689 {
27690 PyThreadState* __tstate = wxPyBeginAllowThreads();
27691 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27692 wxPyEndAllowThreads(__tstate);
27693 if (PyErr_Occurred()) SWIG_fail;
27694 }
27695 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27696 return resultobj;
27697 fail:
27698 return NULL;
27699 }
27700
27701
27702 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27703 PyObject *resultobj = 0;
27704 wxDateTime *arg1 = (wxDateTime *) 0 ;
27705 wxDateSpan *arg2 = 0 ;
27706 wxDateTime result;
27707 void *argp1 = 0 ;
27708 int res1 = 0 ;
27709 void *argp2 = 0 ;
27710 int res2 = 0 ;
27711
27712 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27714 if (!SWIG_IsOK(res1)) {
27715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27716 }
27717 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27718 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27719 if (!SWIG_IsOK(res2)) {
27720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27721 }
27722 if (!argp2) {
27723 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27724 }
27725 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27726 {
27727 PyThreadState* __tstate = wxPyBeginAllowThreads();
27728 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27729 wxPyEndAllowThreads(__tstate);
27730 if (PyErr_Occurred()) SWIG_fail;
27731 }
27732 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27733 return resultobj;
27734 fail:
27735 return NULL;
27736 }
27737
27738
27739 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27740 int argc;
27741 PyObject *argv[3];
27742
27743 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27744 --argc;
27745 if (argc == 2) {
27746 int _v = 0;
27747 {
27748 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27749 _v = SWIG_CheckState(res);
27750 }
27751 if (!_v) goto check_1;
27752 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27753 }
27754 check_1:
27755
27756 if (argc == 2) {
27757 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27758 }
27759
27760 fail:
27761 Py_INCREF(Py_NotImplemented);
27762 return Py_NotImplemented;
27763 }
27764
27765
27766 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27767 PyObject *resultobj = 0;
27768 wxDateTime *arg1 = (wxDateTime *) 0 ;
27769 wxDateTime *arg2 = 0 ;
27770 wxTimeSpan result;
27771 void *argp1 = 0 ;
27772 int res1 = 0 ;
27773 void *argp2 = 0 ;
27774 int res2 = 0 ;
27775
27776 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27778 if (!SWIG_IsOK(res1)) {
27779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27780 }
27781 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27782 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27783 if (!SWIG_IsOK(res2)) {
27784 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27785 }
27786 if (!argp2) {
27787 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27788 }
27789 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27790 {
27791 PyThreadState* __tstate = wxPyBeginAllowThreads();
27792 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27793 wxPyEndAllowThreads(__tstate);
27794 if (PyErr_Occurred()) SWIG_fail;
27795 }
27796 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27797 return resultobj;
27798 fail:
27799 return NULL;
27800 }
27801
27802
27803 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27804 PyObject *resultobj = 0;
27805 wxDateTime *arg1 = (wxDateTime *) 0 ;
27806 wxTimeSpan *arg2 = 0 ;
27807 wxDateTime result;
27808 void *argp1 = 0 ;
27809 int res1 = 0 ;
27810 void *argp2 = 0 ;
27811 int res2 = 0 ;
27812
27813 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27815 if (!SWIG_IsOK(res1)) {
27816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27817 }
27818 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27819 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27820 if (!SWIG_IsOK(res2)) {
27821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27822 }
27823 if (!argp2) {
27824 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27825 }
27826 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27827 {
27828 PyThreadState* __tstate = wxPyBeginAllowThreads();
27829 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27830 wxPyEndAllowThreads(__tstate);
27831 if (PyErr_Occurred()) SWIG_fail;
27832 }
27833 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27834 return resultobj;
27835 fail:
27836 return NULL;
27837 }
27838
27839
27840 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27841 PyObject *resultobj = 0;
27842 wxDateTime *arg1 = (wxDateTime *) 0 ;
27843 wxDateSpan *arg2 = 0 ;
27844 wxDateTime result;
27845 void *argp1 = 0 ;
27846 int res1 = 0 ;
27847 void *argp2 = 0 ;
27848 int res2 = 0 ;
27849
27850 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27852 if (!SWIG_IsOK(res1)) {
27853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27854 }
27855 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27856 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27857 if (!SWIG_IsOK(res2)) {
27858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27859 }
27860 if (!argp2) {
27861 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27862 }
27863 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27864 {
27865 PyThreadState* __tstate = wxPyBeginAllowThreads();
27866 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27867 wxPyEndAllowThreads(__tstate);
27868 if (PyErr_Occurred()) SWIG_fail;
27869 }
27870 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27871 return resultobj;
27872 fail:
27873 return NULL;
27874 }
27875
27876
27877 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27878 int argc;
27879 PyObject *argv[3];
27880
27881 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27882 --argc;
27883 if (argc == 2) {
27884 int _v = 0;
27885 {
27886 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27887 _v = SWIG_CheckState(res);
27888 }
27889 if (!_v) goto check_1;
27890 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27891 }
27892 check_1:
27893
27894 if (argc == 2) {
27895 int _v = 0;
27896 {
27897 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27898 _v = SWIG_CheckState(res);
27899 }
27900 if (!_v) goto check_2;
27901 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27902 }
27903 check_2:
27904
27905 if (argc == 2) {
27906 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27907 }
27908
27909 fail:
27910 Py_INCREF(Py_NotImplemented);
27911 return Py_NotImplemented;
27912 }
27913
27914
27915 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27916 PyObject *resultobj = 0;
27917 wxDateTime *arg1 = (wxDateTime *) 0 ;
27918 wxDateTime *arg2 = (wxDateTime *) 0 ;
27919 bool result;
27920 void *argp1 = 0 ;
27921 int res1 = 0 ;
27922 void *argp2 = 0 ;
27923 int res2 = 0 ;
27924 PyObject * obj0 = 0 ;
27925 PyObject * obj1 = 0 ;
27926 char * kwnames[] = {
27927 (char *) "self",(char *) "other", NULL
27928 };
27929
27930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27932 if (!SWIG_IsOK(res1)) {
27933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27934 }
27935 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27936 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27937 if (!SWIG_IsOK(res2)) {
27938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27939 }
27940 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27941 {
27942 PyThreadState* __tstate = wxPyBeginAllowThreads();
27943 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27944 wxPyEndAllowThreads(__tstate);
27945 if (PyErr_Occurred()) SWIG_fail;
27946 }
27947 {
27948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27949 }
27950 return resultobj;
27951 fail:
27952 return NULL;
27953 }
27954
27955
27956 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27957 PyObject *resultobj = 0;
27958 wxDateTime *arg1 = (wxDateTime *) 0 ;
27959 wxDateTime *arg2 = (wxDateTime *) 0 ;
27960 bool result;
27961 void *argp1 = 0 ;
27962 int res1 = 0 ;
27963 void *argp2 = 0 ;
27964 int res2 = 0 ;
27965 PyObject * obj0 = 0 ;
27966 PyObject * obj1 = 0 ;
27967 char * kwnames[] = {
27968 (char *) "self",(char *) "other", NULL
27969 };
27970
27971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27973 if (!SWIG_IsOK(res1)) {
27974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27975 }
27976 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27977 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27978 if (!SWIG_IsOK(res2)) {
27979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27980 }
27981 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27982 {
27983 PyThreadState* __tstate = wxPyBeginAllowThreads();
27984 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27985 wxPyEndAllowThreads(__tstate);
27986 if (PyErr_Occurred()) SWIG_fail;
27987 }
27988 {
27989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27990 }
27991 return resultobj;
27992 fail:
27993 return NULL;
27994 }
27995
27996
27997 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27998 PyObject *resultobj = 0;
27999 wxDateTime *arg1 = (wxDateTime *) 0 ;
28000 wxDateTime *arg2 = (wxDateTime *) 0 ;
28001 bool result;
28002 void *argp1 = 0 ;
28003 int res1 = 0 ;
28004 void *argp2 = 0 ;
28005 int res2 = 0 ;
28006 PyObject * obj0 = 0 ;
28007 PyObject * obj1 = 0 ;
28008 char * kwnames[] = {
28009 (char *) "self",(char *) "other", NULL
28010 };
28011
28012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) 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___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28016 }
28017 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28018 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28019 if (!SWIG_IsOK(res2)) {
28020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28021 }
28022 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28023 {
28024 PyThreadState* __tstate = wxPyBeginAllowThreads();
28025 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28026 wxPyEndAllowThreads(__tstate);
28027 if (PyErr_Occurred()) SWIG_fail;
28028 }
28029 {
28030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28031 }
28032 return resultobj;
28033 fail:
28034 return NULL;
28035 }
28036
28037
28038 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28039 PyObject *resultobj = 0;
28040 wxDateTime *arg1 = (wxDateTime *) 0 ;
28041 wxDateTime *arg2 = (wxDateTime *) 0 ;
28042 bool result;
28043 void *argp1 = 0 ;
28044 int res1 = 0 ;
28045 void *argp2 = 0 ;
28046 int res2 = 0 ;
28047 PyObject * obj0 = 0 ;
28048 PyObject * obj1 = 0 ;
28049 char * kwnames[] = {
28050 (char *) "self",(char *) "other", NULL
28051 };
28052
28053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28055 if (!SWIG_IsOK(res1)) {
28056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28057 }
28058 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28059 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28060 if (!SWIG_IsOK(res2)) {
28061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28062 }
28063 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28064 {
28065 PyThreadState* __tstate = wxPyBeginAllowThreads();
28066 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28067 wxPyEndAllowThreads(__tstate);
28068 if (PyErr_Occurred()) SWIG_fail;
28069 }
28070 {
28071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28072 }
28073 return resultobj;
28074 fail:
28075 return NULL;
28076 }
28077
28078
28079 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28080 PyObject *resultobj = 0;
28081 wxDateTime *arg1 = (wxDateTime *) 0 ;
28082 wxDateTime *arg2 = (wxDateTime *) 0 ;
28083 bool result;
28084 void *argp1 = 0 ;
28085 int res1 = 0 ;
28086 void *argp2 = 0 ;
28087 int res2 = 0 ;
28088 PyObject * obj0 = 0 ;
28089 PyObject * obj1 = 0 ;
28090 char * kwnames[] = {
28091 (char *) "self",(char *) "other", NULL
28092 };
28093
28094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28096 if (!SWIG_IsOK(res1)) {
28097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28098 }
28099 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28100 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28101 if (!SWIG_IsOK(res2)) {
28102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28103 }
28104 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28105 {
28106 PyThreadState* __tstate = wxPyBeginAllowThreads();
28107 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28108 wxPyEndAllowThreads(__tstate);
28109 if (PyErr_Occurred()) SWIG_fail;
28110 }
28111 {
28112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28113 }
28114 return resultobj;
28115 fail:
28116 return NULL;
28117 }
28118
28119
28120 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28121 PyObject *resultobj = 0;
28122 wxDateTime *arg1 = (wxDateTime *) 0 ;
28123 wxDateTime *arg2 = (wxDateTime *) 0 ;
28124 bool result;
28125 void *argp1 = 0 ;
28126 int res1 = 0 ;
28127 void *argp2 = 0 ;
28128 int res2 = 0 ;
28129 PyObject * obj0 = 0 ;
28130 PyObject * obj1 = 0 ;
28131 char * kwnames[] = {
28132 (char *) "self",(char *) "other", NULL
28133 };
28134
28135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28137 if (!SWIG_IsOK(res1)) {
28138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28139 }
28140 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28141 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28142 if (!SWIG_IsOK(res2)) {
28143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28144 }
28145 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28146 {
28147 PyThreadState* __tstate = wxPyBeginAllowThreads();
28148 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28149 wxPyEndAllowThreads(__tstate);
28150 if (PyErr_Occurred()) SWIG_fail;
28151 }
28152 {
28153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28154 }
28155 return resultobj;
28156 fail:
28157 return NULL;
28158 }
28159
28160
28161 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(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 *) "date", NULL
28173 };
28174
28175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",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_ParseRfc822Date" "', 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_ParseRfc822Date(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_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28208 PyObject *resultobj = 0;
28209 wxDateTime *arg1 = (wxDateTime *) 0 ;
28210 wxString *arg2 = 0 ;
28211 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28212 wxString *arg3 = (wxString *) &arg3_defvalue ;
28213 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28214 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28215 int result;
28216 void *argp1 = 0 ;
28217 int res1 = 0 ;
28218 bool temp2 = false ;
28219 bool temp3 = false ;
28220 void *argp4 = 0 ;
28221 int res4 = 0 ;
28222 PyObject * obj0 = 0 ;
28223 PyObject * obj1 = 0 ;
28224 PyObject * obj2 = 0 ;
28225 PyObject * obj3 = 0 ;
28226 char * kwnames[] = {
28227 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28228 };
28229
28230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28232 if (!SWIG_IsOK(res1)) {
28233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28234 }
28235 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28236 {
28237 arg2 = wxString_in_helper(obj1);
28238 if (arg2 == NULL) SWIG_fail;
28239 temp2 = true;
28240 }
28241 if (obj2) {
28242 {
28243 arg3 = wxString_in_helper(obj2);
28244 if (arg3 == NULL) SWIG_fail;
28245 temp3 = true;
28246 }
28247 }
28248 if (obj3) {
28249 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28250 if (!SWIG_IsOK(res4)) {
28251 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28252 }
28253 if (!argp4) {
28254 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28255 }
28256 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28257 }
28258 {
28259 PyThreadState* __tstate = wxPyBeginAllowThreads();
28260 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28261 wxPyEndAllowThreads(__tstate);
28262 if (PyErr_Occurred()) SWIG_fail;
28263 }
28264 resultobj = SWIG_From_int(static_cast< int >(result));
28265 {
28266 if (temp2)
28267 delete arg2;
28268 }
28269 {
28270 if (temp3)
28271 delete arg3;
28272 }
28273 return resultobj;
28274 fail:
28275 {
28276 if (temp2)
28277 delete arg2;
28278 }
28279 {
28280 if (temp3)
28281 delete arg3;
28282 }
28283 return NULL;
28284 }
28285
28286
28287 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28288 PyObject *resultobj = 0;
28289 wxDateTime *arg1 = (wxDateTime *) 0 ;
28290 wxString *arg2 = 0 ;
28291 int result;
28292 void *argp1 = 0 ;
28293 int res1 = 0 ;
28294 bool temp2 = false ;
28295 PyObject * obj0 = 0 ;
28296 PyObject * obj1 = 0 ;
28297 char * kwnames[] = {
28298 (char *) "self",(char *) "datetime", NULL
28299 };
28300
28301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28303 if (!SWIG_IsOK(res1)) {
28304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28305 }
28306 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28307 {
28308 arg2 = wxString_in_helper(obj1);
28309 if (arg2 == NULL) SWIG_fail;
28310 temp2 = true;
28311 }
28312 {
28313 PyThreadState* __tstate = wxPyBeginAllowThreads();
28314 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28315 wxPyEndAllowThreads(__tstate);
28316 if (PyErr_Occurred()) SWIG_fail;
28317 }
28318 resultobj = SWIG_From_int(static_cast< int >(result));
28319 {
28320 if (temp2)
28321 delete arg2;
28322 }
28323 return resultobj;
28324 fail:
28325 {
28326 if (temp2)
28327 delete arg2;
28328 }
28329 return NULL;
28330 }
28331
28332
28333 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28334 PyObject *resultobj = 0;
28335 wxDateTime *arg1 = (wxDateTime *) 0 ;
28336 wxString *arg2 = 0 ;
28337 int result;
28338 void *argp1 = 0 ;
28339 int res1 = 0 ;
28340 bool temp2 = false ;
28341 PyObject * obj0 = 0 ;
28342 PyObject * obj1 = 0 ;
28343 char * kwnames[] = {
28344 (char *) "self",(char *) "date", NULL
28345 };
28346
28347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28349 if (!SWIG_IsOK(res1)) {
28350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28351 }
28352 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28353 {
28354 arg2 = wxString_in_helper(obj1);
28355 if (arg2 == NULL) SWIG_fail;
28356 temp2 = true;
28357 }
28358 {
28359 PyThreadState* __tstate = wxPyBeginAllowThreads();
28360 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28361 wxPyEndAllowThreads(__tstate);
28362 if (PyErr_Occurred()) SWIG_fail;
28363 }
28364 resultobj = SWIG_From_int(static_cast< int >(result));
28365 {
28366 if (temp2)
28367 delete arg2;
28368 }
28369 return resultobj;
28370 fail:
28371 {
28372 if (temp2)
28373 delete arg2;
28374 }
28375 return NULL;
28376 }
28377
28378
28379 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28380 PyObject *resultobj = 0;
28381 wxDateTime *arg1 = (wxDateTime *) 0 ;
28382 wxString *arg2 = 0 ;
28383 int result;
28384 void *argp1 = 0 ;
28385 int res1 = 0 ;
28386 bool temp2 = false ;
28387 PyObject * obj0 = 0 ;
28388 PyObject * obj1 = 0 ;
28389 char * kwnames[] = {
28390 (char *) "self",(char *) "time", NULL
28391 };
28392
28393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28395 if (!SWIG_IsOK(res1)) {
28396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28397 }
28398 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28399 {
28400 arg2 = wxString_in_helper(obj1);
28401 if (arg2 == NULL) SWIG_fail;
28402 temp2 = true;
28403 }
28404 {
28405 PyThreadState* __tstate = wxPyBeginAllowThreads();
28406 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28407 wxPyEndAllowThreads(__tstate);
28408 if (PyErr_Occurred()) SWIG_fail;
28409 }
28410 resultobj = SWIG_From_int(static_cast< int >(result));
28411 {
28412 if (temp2)
28413 delete arg2;
28414 }
28415 return resultobj;
28416 fail:
28417 {
28418 if (temp2)
28419 delete arg2;
28420 }
28421 return NULL;
28422 }
28423
28424
28425 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28426 PyObject *resultobj = 0;
28427 wxDateTime *arg1 = (wxDateTime *) 0 ;
28428 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28429 wxString *arg2 = (wxString *) &arg2_defvalue ;
28430 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28431 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28432 wxString result;
28433 void *argp1 = 0 ;
28434 int res1 = 0 ;
28435 bool temp2 = false ;
28436 bool temp3 = false ;
28437 PyObject * obj0 = 0 ;
28438 PyObject * obj1 = 0 ;
28439 PyObject * obj2 = 0 ;
28440 char * kwnames[] = {
28441 (char *) "self",(char *) "format",(char *) "tz", NULL
28442 };
28443
28444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28446 if (!SWIG_IsOK(res1)) {
28447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28448 }
28449 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28450 if (obj1) {
28451 {
28452 arg2 = wxString_in_helper(obj1);
28453 if (arg2 == NULL) SWIG_fail;
28454 temp2 = true;
28455 }
28456 }
28457 if (obj2) {
28458 {
28459 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28460 temp3 = true;
28461 }
28462 }
28463 {
28464 PyThreadState* __tstate = wxPyBeginAllowThreads();
28465 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28466 wxPyEndAllowThreads(__tstate);
28467 if (PyErr_Occurred()) SWIG_fail;
28468 }
28469 {
28470 #if wxUSE_UNICODE
28471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28472 #else
28473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28474 #endif
28475 }
28476 {
28477 if (temp2)
28478 delete arg2;
28479 }
28480 {
28481 if (temp3) delete arg3;
28482 }
28483 return resultobj;
28484 fail:
28485 {
28486 if (temp2)
28487 delete arg2;
28488 }
28489 {
28490 if (temp3) delete arg3;
28491 }
28492 return NULL;
28493 }
28494
28495
28496 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28497 PyObject *resultobj = 0;
28498 wxDateTime *arg1 = (wxDateTime *) 0 ;
28499 wxString result;
28500 void *argp1 = 0 ;
28501 int res1 = 0 ;
28502 PyObject *swig_obj[1] ;
28503
28504 if (!args) SWIG_fail;
28505 swig_obj[0] = args;
28506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28507 if (!SWIG_IsOK(res1)) {
28508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28509 }
28510 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28511 {
28512 PyThreadState* __tstate = wxPyBeginAllowThreads();
28513 result = ((wxDateTime const *)arg1)->FormatDate();
28514 wxPyEndAllowThreads(__tstate);
28515 if (PyErr_Occurred()) SWIG_fail;
28516 }
28517 {
28518 #if wxUSE_UNICODE
28519 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28520 #else
28521 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28522 #endif
28523 }
28524 return resultobj;
28525 fail:
28526 return NULL;
28527 }
28528
28529
28530 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28531 PyObject *resultobj = 0;
28532 wxDateTime *arg1 = (wxDateTime *) 0 ;
28533 wxString result;
28534 void *argp1 = 0 ;
28535 int res1 = 0 ;
28536 PyObject *swig_obj[1] ;
28537
28538 if (!args) SWIG_fail;
28539 swig_obj[0] = args;
28540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28541 if (!SWIG_IsOK(res1)) {
28542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28543 }
28544 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28545 {
28546 PyThreadState* __tstate = wxPyBeginAllowThreads();
28547 result = ((wxDateTime const *)arg1)->FormatTime();
28548 wxPyEndAllowThreads(__tstate);
28549 if (PyErr_Occurred()) SWIG_fail;
28550 }
28551 {
28552 #if wxUSE_UNICODE
28553 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28554 #else
28555 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28556 #endif
28557 }
28558 return resultobj;
28559 fail:
28560 return NULL;
28561 }
28562
28563
28564 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28565 PyObject *resultobj = 0;
28566 wxDateTime *arg1 = (wxDateTime *) 0 ;
28567 wxString result;
28568 void *argp1 = 0 ;
28569 int res1 = 0 ;
28570 PyObject *swig_obj[1] ;
28571
28572 if (!args) SWIG_fail;
28573 swig_obj[0] = args;
28574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28575 if (!SWIG_IsOK(res1)) {
28576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28577 }
28578 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28579 {
28580 PyThreadState* __tstate = wxPyBeginAllowThreads();
28581 result = ((wxDateTime const *)arg1)->FormatISODate();
28582 wxPyEndAllowThreads(__tstate);
28583 if (PyErr_Occurred()) SWIG_fail;
28584 }
28585 {
28586 #if wxUSE_UNICODE
28587 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28588 #else
28589 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28590 #endif
28591 }
28592 return resultobj;
28593 fail:
28594 return NULL;
28595 }
28596
28597
28598 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28599 PyObject *resultobj = 0;
28600 wxDateTime *arg1 = (wxDateTime *) 0 ;
28601 wxString result;
28602 void *argp1 = 0 ;
28603 int res1 = 0 ;
28604 PyObject *swig_obj[1] ;
28605
28606 if (!args) SWIG_fail;
28607 swig_obj[0] = args;
28608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28609 if (!SWIG_IsOK(res1)) {
28610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28611 }
28612 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28613 {
28614 PyThreadState* __tstate = wxPyBeginAllowThreads();
28615 result = ((wxDateTime const *)arg1)->FormatISOTime();
28616 wxPyEndAllowThreads(__tstate);
28617 if (PyErr_Occurred()) SWIG_fail;
28618 }
28619 {
28620 #if wxUSE_UNICODE
28621 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28622 #else
28623 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28624 #endif
28625 }
28626 return resultobj;
28627 fail:
28628 return NULL;
28629 }
28630
28631
28632 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28633 PyObject *obj;
28634 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28635 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28636 return SWIG_Py_Void();
28637 }
28638
28639 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28640 return SWIG_Python_InitShadowInstance(args);
28641 }
28642
28643 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28644 PyObject *resultobj = 0;
28645 long arg1 ;
28646 wxTimeSpan result;
28647 long val1 ;
28648 int ecode1 = 0 ;
28649 PyObject * obj0 = 0 ;
28650 char * kwnames[] = {
28651 (char *) "ms", NULL
28652 };
28653
28654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28655 ecode1 = SWIG_AsVal_long(obj0, &val1);
28656 if (!SWIG_IsOK(ecode1)) {
28657 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28658 }
28659 arg1 = static_cast< long >(val1);
28660 {
28661 PyThreadState* __tstate = wxPyBeginAllowThreads();
28662 result = wxTimeSpan::Milliseconds(arg1);
28663 wxPyEndAllowThreads(__tstate);
28664 if (PyErr_Occurred()) SWIG_fail;
28665 }
28666 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28667 return resultobj;
28668 fail:
28669 return NULL;
28670 }
28671
28672
28673 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28674 PyObject *resultobj = 0;
28675 wxTimeSpan result;
28676
28677 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28678 {
28679 PyThreadState* __tstate = wxPyBeginAllowThreads();
28680 result = wxTimeSpan::Millisecond();
28681 wxPyEndAllowThreads(__tstate);
28682 if (PyErr_Occurred()) SWIG_fail;
28683 }
28684 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28685 return resultobj;
28686 fail:
28687 return NULL;
28688 }
28689
28690
28691 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28692 PyObject *resultobj = 0;
28693 long arg1 ;
28694 wxTimeSpan result;
28695 long val1 ;
28696 int ecode1 = 0 ;
28697 PyObject * obj0 = 0 ;
28698 char * kwnames[] = {
28699 (char *) "sec", NULL
28700 };
28701
28702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28703 ecode1 = SWIG_AsVal_long(obj0, &val1);
28704 if (!SWIG_IsOK(ecode1)) {
28705 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28706 }
28707 arg1 = static_cast< long >(val1);
28708 {
28709 PyThreadState* __tstate = wxPyBeginAllowThreads();
28710 result = wxTimeSpan::Seconds(arg1);
28711 wxPyEndAllowThreads(__tstate);
28712 if (PyErr_Occurred()) SWIG_fail;
28713 }
28714 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28715 return resultobj;
28716 fail:
28717 return NULL;
28718 }
28719
28720
28721 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28722 PyObject *resultobj = 0;
28723 wxTimeSpan result;
28724
28725 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28726 {
28727 PyThreadState* __tstate = wxPyBeginAllowThreads();
28728 result = wxTimeSpan::Second();
28729 wxPyEndAllowThreads(__tstate);
28730 if (PyErr_Occurred()) SWIG_fail;
28731 }
28732 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28733 return resultobj;
28734 fail:
28735 return NULL;
28736 }
28737
28738
28739 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28740 PyObject *resultobj = 0;
28741 long arg1 ;
28742 wxTimeSpan result;
28743 long val1 ;
28744 int ecode1 = 0 ;
28745 PyObject * obj0 = 0 ;
28746 char * kwnames[] = {
28747 (char *) "min", NULL
28748 };
28749
28750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28751 ecode1 = SWIG_AsVal_long(obj0, &val1);
28752 if (!SWIG_IsOK(ecode1)) {
28753 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28754 }
28755 arg1 = static_cast< long >(val1);
28756 {
28757 PyThreadState* __tstate = wxPyBeginAllowThreads();
28758 result = wxTimeSpan::Minutes(arg1);
28759 wxPyEndAllowThreads(__tstate);
28760 if (PyErr_Occurred()) SWIG_fail;
28761 }
28762 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28763 return resultobj;
28764 fail:
28765 return NULL;
28766 }
28767
28768
28769 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28770 PyObject *resultobj = 0;
28771 wxTimeSpan result;
28772
28773 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28774 {
28775 PyThreadState* __tstate = wxPyBeginAllowThreads();
28776 result = wxTimeSpan::Minute();
28777 wxPyEndAllowThreads(__tstate);
28778 if (PyErr_Occurred()) SWIG_fail;
28779 }
28780 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28781 return resultobj;
28782 fail:
28783 return NULL;
28784 }
28785
28786
28787 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28788 PyObject *resultobj = 0;
28789 long arg1 ;
28790 wxTimeSpan result;
28791 long val1 ;
28792 int ecode1 = 0 ;
28793 PyObject * obj0 = 0 ;
28794 char * kwnames[] = {
28795 (char *) "hours", NULL
28796 };
28797
28798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28799 ecode1 = SWIG_AsVal_long(obj0, &val1);
28800 if (!SWIG_IsOK(ecode1)) {
28801 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28802 }
28803 arg1 = static_cast< long >(val1);
28804 {
28805 PyThreadState* __tstate = wxPyBeginAllowThreads();
28806 result = wxTimeSpan::Hours(arg1);
28807 wxPyEndAllowThreads(__tstate);
28808 if (PyErr_Occurred()) SWIG_fail;
28809 }
28810 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28811 return resultobj;
28812 fail:
28813 return NULL;
28814 }
28815
28816
28817 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28818 PyObject *resultobj = 0;
28819 wxTimeSpan result;
28820
28821 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28822 {
28823 PyThreadState* __tstate = wxPyBeginAllowThreads();
28824 result = wxTimeSpan::Hour();
28825 wxPyEndAllowThreads(__tstate);
28826 if (PyErr_Occurred()) SWIG_fail;
28827 }
28828 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28829 return resultobj;
28830 fail:
28831 return NULL;
28832 }
28833
28834
28835 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28836 PyObject *resultobj = 0;
28837 long arg1 ;
28838 wxTimeSpan result;
28839 long val1 ;
28840 int ecode1 = 0 ;
28841 PyObject * obj0 = 0 ;
28842 char * kwnames[] = {
28843 (char *) "days", NULL
28844 };
28845
28846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28847 ecode1 = SWIG_AsVal_long(obj0, &val1);
28848 if (!SWIG_IsOK(ecode1)) {
28849 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28850 }
28851 arg1 = static_cast< long >(val1);
28852 {
28853 PyThreadState* __tstate = wxPyBeginAllowThreads();
28854 result = wxTimeSpan::Days(arg1);
28855 wxPyEndAllowThreads(__tstate);
28856 if (PyErr_Occurred()) SWIG_fail;
28857 }
28858 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28859 return resultobj;
28860 fail:
28861 return NULL;
28862 }
28863
28864
28865 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28866 PyObject *resultobj = 0;
28867 wxTimeSpan result;
28868
28869 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28870 {
28871 PyThreadState* __tstate = wxPyBeginAllowThreads();
28872 result = wxTimeSpan::Day();
28873 wxPyEndAllowThreads(__tstate);
28874 if (PyErr_Occurred()) SWIG_fail;
28875 }
28876 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28877 return resultobj;
28878 fail:
28879 return NULL;
28880 }
28881
28882
28883 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28884 PyObject *resultobj = 0;
28885 long arg1 ;
28886 wxTimeSpan result;
28887 long val1 ;
28888 int ecode1 = 0 ;
28889 PyObject * obj0 = 0 ;
28890 char * kwnames[] = {
28891 (char *) "days", NULL
28892 };
28893
28894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28895 ecode1 = SWIG_AsVal_long(obj0, &val1);
28896 if (!SWIG_IsOK(ecode1)) {
28897 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28898 }
28899 arg1 = static_cast< long >(val1);
28900 {
28901 PyThreadState* __tstate = wxPyBeginAllowThreads();
28902 result = wxTimeSpan::Weeks(arg1);
28903 wxPyEndAllowThreads(__tstate);
28904 if (PyErr_Occurred()) SWIG_fail;
28905 }
28906 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28907 return resultobj;
28908 fail:
28909 return NULL;
28910 }
28911
28912
28913 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28914 PyObject *resultobj = 0;
28915 wxTimeSpan result;
28916
28917 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28918 {
28919 PyThreadState* __tstate = wxPyBeginAllowThreads();
28920 result = wxTimeSpan::Week();
28921 wxPyEndAllowThreads(__tstate);
28922 if (PyErr_Occurred()) SWIG_fail;
28923 }
28924 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28925 return resultobj;
28926 fail:
28927 return NULL;
28928 }
28929
28930
28931 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28932 PyObject *resultobj = 0;
28933 long arg1 = (long) 0 ;
28934 long arg2 = (long) 0 ;
28935 long arg3 = (long) 0 ;
28936 long arg4 = (long) 0 ;
28937 wxTimeSpan *result = 0 ;
28938 long val1 ;
28939 int ecode1 = 0 ;
28940 long val2 ;
28941 int ecode2 = 0 ;
28942 long val3 ;
28943 int ecode3 = 0 ;
28944 long val4 ;
28945 int ecode4 = 0 ;
28946 PyObject * obj0 = 0 ;
28947 PyObject * obj1 = 0 ;
28948 PyObject * obj2 = 0 ;
28949 PyObject * obj3 = 0 ;
28950 char * kwnames[] = {
28951 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28952 };
28953
28954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28955 if (obj0) {
28956 ecode1 = SWIG_AsVal_long(obj0, &val1);
28957 if (!SWIG_IsOK(ecode1)) {
28958 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28959 }
28960 arg1 = static_cast< long >(val1);
28961 }
28962 if (obj1) {
28963 ecode2 = SWIG_AsVal_long(obj1, &val2);
28964 if (!SWIG_IsOK(ecode2)) {
28965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28966 }
28967 arg2 = static_cast< long >(val2);
28968 }
28969 if (obj2) {
28970 ecode3 = SWIG_AsVal_long(obj2, &val3);
28971 if (!SWIG_IsOK(ecode3)) {
28972 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28973 }
28974 arg3 = static_cast< long >(val3);
28975 }
28976 if (obj3) {
28977 ecode4 = SWIG_AsVal_long(obj3, &val4);
28978 if (!SWIG_IsOK(ecode4)) {
28979 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28980 }
28981 arg4 = static_cast< long >(val4);
28982 }
28983 {
28984 PyThreadState* __tstate = wxPyBeginAllowThreads();
28985 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28986 wxPyEndAllowThreads(__tstate);
28987 if (PyErr_Occurred()) SWIG_fail;
28988 }
28989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28990 return resultobj;
28991 fail:
28992 return NULL;
28993 }
28994
28995
28996 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28997 PyObject *resultobj = 0;
28998 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28999 void *argp1 = 0 ;
29000 int res1 = 0 ;
29001 PyObject *swig_obj[1] ;
29002
29003 if (!args) SWIG_fail;
29004 swig_obj[0] = args;
29005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29006 if (!SWIG_IsOK(res1)) {
29007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29008 }
29009 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29010 {
29011 PyThreadState* __tstate = wxPyBeginAllowThreads();
29012 delete arg1;
29013
29014 wxPyEndAllowThreads(__tstate);
29015 if (PyErr_Occurred()) SWIG_fail;
29016 }
29017 resultobj = SWIG_Py_Void();
29018 return resultobj;
29019 fail:
29020 return NULL;
29021 }
29022
29023
29024 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29025 PyObject *resultobj = 0;
29026 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29027 wxTimeSpan *arg2 = 0 ;
29028 wxTimeSpan *result = 0 ;
29029 void *argp1 = 0 ;
29030 int res1 = 0 ;
29031 void *argp2 = 0 ;
29032 int res2 = 0 ;
29033 PyObject * obj0 = 0 ;
29034 PyObject * obj1 = 0 ;
29035 char * kwnames[] = {
29036 (char *) "self",(char *) "diff", NULL
29037 };
29038
29039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29041 if (!SWIG_IsOK(res1)) {
29042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29043 }
29044 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29045 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29046 if (!SWIG_IsOK(res2)) {
29047 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29048 }
29049 if (!argp2) {
29050 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29051 }
29052 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29053 {
29054 PyThreadState* __tstate = wxPyBeginAllowThreads();
29055 {
29056 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29057 result = (wxTimeSpan *) &_result_ref;
29058 }
29059 wxPyEndAllowThreads(__tstate);
29060 if (PyErr_Occurred()) SWIG_fail;
29061 }
29062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29063 return resultobj;
29064 fail:
29065 return NULL;
29066 }
29067
29068
29069 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29070 PyObject *resultobj = 0;
29071 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29072 wxTimeSpan *arg2 = 0 ;
29073 wxTimeSpan *result = 0 ;
29074 void *argp1 = 0 ;
29075 int res1 = 0 ;
29076 void *argp2 = 0 ;
29077 int res2 = 0 ;
29078 PyObject * obj0 = 0 ;
29079 PyObject * obj1 = 0 ;
29080 char * kwnames[] = {
29081 (char *) "self",(char *) "diff", NULL
29082 };
29083
29084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29086 if (!SWIG_IsOK(res1)) {
29087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29088 }
29089 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29090 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29091 if (!SWIG_IsOK(res2)) {
29092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29093 }
29094 if (!argp2) {
29095 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29096 }
29097 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 {
29101 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29102 result = (wxTimeSpan *) &_result_ref;
29103 }
29104 wxPyEndAllowThreads(__tstate);
29105 if (PyErr_Occurred()) SWIG_fail;
29106 }
29107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29108 return resultobj;
29109 fail:
29110 return NULL;
29111 }
29112
29113
29114 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29115 PyObject *resultobj = 0;
29116 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29117 int arg2 ;
29118 wxTimeSpan *result = 0 ;
29119 void *argp1 = 0 ;
29120 int res1 = 0 ;
29121 int val2 ;
29122 int ecode2 = 0 ;
29123 PyObject * obj0 = 0 ;
29124 PyObject * obj1 = 0 ;
29125 char * kwnames[] = {
29126 (char *) "self",(char *) "n", NULL
29127 };
29128
29129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29131 if (!SWIG_IsOK(res1)) {
29132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29133 }
29134 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29135 ecode2 = SWIG_AsVal_int(obj1, &val2);
29136 if (!SWIG_IsOK(ecode2)) {
29137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29138 }
29139 arg2 = static_cast< int >(val2);
29140 {
29141 PyThreadState* __tstate = wxPyBeginAllowThreads();
29142 {
29143 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29144 result = (wxTimeSpan *) &_result_ref;
29145 }
29146 wxPyEndAllowThreads(__tstate);
29147 if (PyErr_Occurred()) SWIG_fail;
29148 }
29149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29150 return resultobj;
29151 fail:
29152 return NULL;
29153 }
29154
29155
29156 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29157 PyObject *resultobj = 0;
29158 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29159 wxTimeSpan *result = 0 ;
29160 void *argp1 = 0 ;
29161 int res1 = 0 ;
29162 PyObject *swig_obj[1] ;
29163
29164 if (!args) SWIG_fail;
29165 swig_obj[0] = args;
29166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29167 if (!SWIG_IsOK(res1)) {
29168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29169 }
29170 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29171 {
29172 PyThreadState* __tstate = wxPyBeginAllowThreads();
29173 {
29174 wxTimeSpan &_result_ref = (arg1)->Neg();
29175 result = (wxTimeSpan *) &_result_ref;
29176 }
29177 wxPyEndAllowThreads(__tstate);
29178 if (PyErr_Occurred()) SWIG_fail;
29179 }
29180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29181 return resultobj;
29182 fail:
29183 return NULL;
29184 }
29185
29186
29187 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29188 PyObject *resultobj = 0;
29189 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29190 wxTimeSpan result;
29191 void *argp1 = 0 ;
29192 int res1 = 0 ;
29193 PyObject *swig_obj[1] ;
29194
29195 if (!args) SWIG_fail;
29196 swig_obj[0] = args;
29197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29198 if (!SWIG_IsOK(res1)) {
29199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29200 }
29201 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29202 {
29203 PyThreadState* __tstate = wxPyBeginAllowThreads();
29204 result = ((wxTimeSpan const *)arg1)->Abs();
29205 wxPyEndAllowThreads(__tstate);
29206 if (PyErr_Occurred()) SWIG_fail;
29207 }
29208 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29209 return resultobj;
29210 fail:
29211 return NULL;
29212 }
29213
29214
29215 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29216 PyObject *resultobj = 0;
29217 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29218 wxTimeSpan *arg2 = 0 ;
29219 wxTimeSpan *result = 0 ;
29220 void *argp1 = 0 ;
29221 int res1 = 0 ;
29222 void *argp2 = 0 ;
29223 int res2 = 0 ;
29224 PyObject * obj0 = 0 ;
29225 PyObject * obj1 = 0 ;
29226 char * kwnames[] = {
29227 (char *) "self",(char *) "diff", NULL
29228 };
29229
29230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29232 if (!SWIG_IsOK(res1)) {
29233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29234 }
29235 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29236 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29237 if (!SWIG_IsOK(res2)) {
29238 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29239 }
29240 if (!argp2) {
29241 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29242 }
29243 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29244 {
29245 PyThreadState* __tstate = wxPyBeginAllowThreads();
29246 {
29247 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29248 result = (wxTimeSpan *) &_result_ref;
29249 }
29250 wxPyEndAllowThreads(__tstate);
29251 if (PyErr_Occurred()) SWIG_fail;
29252 }
29253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29254 return resultobj;
29255 fail:
29256 return NULL;
29257 }
29258
29259
29260 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29261 PyObject *resultobj = 0;
29262 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29263 wxTimeSpan *arg2 = 0 ;
29264 wxTimeSpan *result = 0 ;
29265 void *argp1 = 0 ;
29266 int res1 = 0 ;
29267 void *argp2 = 0 ;
29268 int res2 = 0 ;
29269 PyObject * obj0 = 0 ;
29270 PyObject * obj1 = 0 ;
29271 char * kwnames[] = {
29272 (char *) "self",(char *) "diff", NULL
29273 };
29274
29275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29277 if (!SWIG_IsOK(res1)) {
29278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29279 }
29280 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29281 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29282 if (!SWIG_IsOK(res2)) {
29283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29284 }
29285 if (!argp2) {
29286 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29287 }
29288 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29289 {
29290 PyThreadState* __tstate = wxPyBeginAllowThreads();
29291 {
29292 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29293 result = (wxTimeSpan *) &_result_ref;
29294 }
29295 wxPyEndAllowThreads(__tstate);
29296 if (PyErr_Occurred()) SWIG_fail;
29297 }
29298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29299 return resultobj;
29300 fail:
29301 return NULL;
29302 }
29303
29304
29305 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29306 PyObject *resultobj = 0;
29307 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29308 int arg2 ;
29309 wxTimeSpan *result = 0 ;
29310 void *argp1 = 0 ;
29311 int res1 = 0 ;
29312 int val2 ;
29313 int ecode2 = 0 ;
29314 PyObject * obj0 = 0 ;
29315 PyObject * obj1 = 0 ;
29316 char * kwnames[] = {
29317 (char *) "self",(char *) "n", NULL
29318 };
29319
29320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29322 if (!SWIG_IsOK(res1)) {
29323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29324 }
29325 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29326 ecode2 = SWIG_AsVal_int(obj1, &val2);
29327 if (!SWIG_IsOK(ecode2)) {
29328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29329 }
29330 arg2 = static_cast< int >(val2);
29331 {
29332 PyThreadState* __tstate = wxPyBeginAllowThreads();
29333 {
29334 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29335 result = (wxTimeSpan *) &_result_ref;
29336 }
29337 wxPyEndAllowThreads(__tstate);
29338 if (PyErr_Occurred()) SWIG_fail;
29339 }
29340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29341 return resultobj;
29342 fail:
29343 return NULL;
29344 }
29345
29346
29347 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29348 PyObject *resultobj = 0;
29349 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29350 wxTimeSpan *result = 0 ;
29351 void *argp1 = 0 ;
29352 int res1 = 0 ;
29353 PyObject *swig_obj[1] ;
29354
29355 if (!args) SWIG_fail;
29356 swig_obj[0] = args;
29357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29358 if (!SWIG_IsOK(res1)) {
29359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29360 }
29361 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 {
29365 wxTimeSpan &_result_ref = (arg1)->operator -();
29366 result = (wxTimeSpan *) &_result_ref;
29367 }
29368 wxPyEndAllowThreads(__tstate);
29369 if (PyErr_Occurred()) SWIG_fail;
29370 }
29371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29372 return resultobj;
29373 fail:
29374 return NULL;
29375 }
29376
29377
29378 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29379 PyObject *resultobj = 0;
29380 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29381 wxTimeSpan *arg2 = 0 ;
29382 wxTimeSpan result;
29383 void *argp1 = 0 ;
29384 int res1 = 0 ;
29385 void *argp2 = 0 ;
29386 int res2 = 0 ;
29387 PyObject * obj0 = 0 ;
29388 PyObject * obj1 = 0 ;
29389 char * kwnames[] = {
29390 (char *) "self",(char *) "other", NULL
29391 };
29392
29393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29395 if (!SWIG_IsOK(res1)) {
29396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29397 }
29398 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29399 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29400 if (!SWIG_IsOK(res2)) {
29401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29402 }
29403 if (!argp2) {
29404 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29405 }
29406 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29407 {
29408 PyThreadState* __tstate = wxPyBeginAllowThreads();
29409 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29410 wxPyEndAllowThreads(__tstate);
29411 if (PyErr_Occurred()) SWIG_fail;
29412 }
29413 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29414 return resultobj;
29415 fail:
29416 return NULL;
29417 }
29418
29419
29420 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29421 PyObject *resultobj = 0;
29422 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29423 wxTimeSpan *arg2 = 0 ;
29424 wxTimeSpan result;
29425 void *argp1 = 0 ;
29426 int res1 = 0 ;
29427 void *argp2 = 0 ;
29428 int res2 = 0 ;
29429 PyObject * obj0 = 0 ;
29430 PyObject * obj1 = 0 ;
29431 char * kwnames[] = {
29432 (char *) "self",(char *) "other", NULL
29433 };
29434
29435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29437 if (!SWIG_IsOK(res1)) {
29438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29439 }
29440 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29441 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29442 if (!SWIG_IsOK(res2)) {
29443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29444 }
29445 if (!argp2) {
29446 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29447 }
29448 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29449 {
29450 PyThreadState* __tstate = wxPyBeginAllowThreads();
29451 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29452 wxPyEndAllowThreads(__tstate);
29453 if (PyErr_Occurred()) SWIG_fail;
29454 }
29455 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29456 return resultobj;
29457 fail:
29458 return NULL;
29459 }
29460
29461
29462 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29463 PyObject *resultobj = 0;
29464 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29465 int arg2 ;
29466 wxTimeSpan result;
29467 void *argp1 = 0 ;
29468 int res1 = 0 ;
29469 int val2 ;
29470 int ecode2 = 0 ;
29471 PyObject * obj0 = 0 ;
29472 PyObject * obj1 = 0 ;
29473 char * kwnames[] = {
29474 (char *) "self",(char *) "n", NULL
29475 };
29476
29477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29479 if (!SWIG_IsOK(res1)) {
29480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29481 }
29482 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29483 ecode2 = SWIG_AsVal_int(obj1, &val2);
29484 if (!SWIG_IsOK(ecode2)) {
29485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29486 }
29487 arg2 = static_cast< int >(val2);
29488 {
29489 PyThreadState* __tstate = wxPyBeginAllowThreads();
29490 result = wxTimeSpan___mul__(arg1,arg2);
29491 wxPyEndAllowThreads(__tstate);
29492 if (PyErr_Occurred()) SWIG_fail;
29493 }
29494 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29495 return resultobj;
29496 fail:
29497 return NULL;
29498 }
29499
29500
29501 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29502 PyObject *resultobj = 0;
29503 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29504 int arg2 ;
29505 wxTimeSpan result;
29506 void *argp1 = 0 ;
29507 int res1 = 0 ;
29508 int val2 ;
29509 int ecode2 = 0 ;
29510 PyObject * obj0 = 0 ;
29511 PyObject * obj1 = 0 ;
29512 char * kwnames[] = {
29513 (char *) "self",(char *) "n", NULL
29514 };
29515
29516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29518 if (!SWIG_IsOK(res1)) {
29519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29520 }
29521 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29522 ecode2 = SWIG_AsVal_int(obj1, &val2);
29523 if (!SWIG_IsOK(ecode2)) {
29524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29525 }
29526 arg2 = static_cast< int >(val2);
29527 {
29528 PyThreadState* __tstate = wxPyBeginAllowThreads();
29529 result = wxTimeSpan___rmul__(arg1,arg2);
29530 wxPyEndAllowThreads(__tstate);
29531 if (PyErr_Occurred()) SWIG_fail;
29532 }
29533 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29534 return resultobj;
29535 fail:
29536 return NULL;
29537 }
29538
29539
29540 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29541 PyObject *resultobj = 0;
29542 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29543 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29544 bool result;
29545 void *argp1 = 0 ;
29546 int res1 = 0 ;
29547 void *argp2 = 0 ;
29548 int res2 = 0 ;
29549 PyObject * obj0 = 0 ;
29550 PyObject * obj1 = 0 ;
29551 char * kwnames[] = {
29552 (char *) "self",(char *) "other", NULL
29553 };
29554
29555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29557 if (!SWIG_IsOK(res1)) {
29558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29559 }
29560 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29561 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29562 if (!SWIG_IsOK(res2)) {
29563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29564 }
29565 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29566 {
29567 PyThreadState* __tstate = wxPyBeginAllowThreads();
29568 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29569 wxPyEndAllowThreads(__tstate);
29570 if (PyErr_Occurred()) SWIG_fail;
29571 }
29572 {
29573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29574 }
29575 return resultobj;
29576 fail:
29577 return NULL;
29578 }
29579
29580
29581 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29582 PyObject *resultobj = 0;
29583 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29584 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29585 bool result;
29586 void *argp1 = 0 ;
29587 int res1 = 0 ;
29588 void *argp2 = 0 ;
29589 int res2 = 0 ;
29590 PyObject * obj0 = 0 ;
29591 PyObject * obj1 = 0 ;
29592 char * kwnames[] = {
29593 (char *) "self",(char *) "other", NULL
29594 };
29595
29596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29598 if (!SWIG_IsOK(res1)) {
29599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29600 }
29601 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29602 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29603 if (!SWIG_IsOK(res2)) {
29604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29605 }
29606 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29607 {
29608 PyThreadState* __tstate = wxPyBeginAllowThreads();
29609 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29610 wxPyEndAllowThreads(__tstate);
29611 if (PyErr_Occurred()) SWIG_fail;
29612 }
29613 {
29614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29615 }
29616 return resultobj;
29617 fail:
29618 return NULL;
29619 }
29620
29621
29622 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29623 PyObject *resultobj = 0;
29624 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29625 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29626 bool result;
29627 void *argp1 = 0 ;
29628 int res1 = 0 ;
29629 void *argp2 = 0 ;
29630 int res2 = 0 ;
29631 PyObject * obj0 = 0 ;
29632 PyObject * obj1 = 0 ;
29633 char * kwnames[] = {
29634 (char *) "self",(char *) "other", NULL
29635 };
29636
29637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29639 if (!SWIG_IsOK(res1)) {
29640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29641 }
29642 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29643 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29644 if (!SWIG_IsOK(res2)) {
29645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29646 }
29647 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29648 {
29649 PyThreadState* __tstate = wxPyBeginAllowThreads();
29650 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29651 wxPyEndAllowThreads(__tstate);
29652 if (PyErr_Occurred()) SWIG_fail;
29653 }
29654 {
29655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29656 }
29657 return resultobj;
29658 fail:
29659 return NULL;
29660 }
29661
29662
29663 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29664 PyObject *resultobj = 0;
29665 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29666 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29667 bool result;
29668 void *argp1 = 0 ;
29669 int res1 = 0 ;
29670 void *argp2 = 0 ;
29671 int res2 = 0 ;
29672 PyObject * obj0 = 0 ;
29673 PyObject * obj1 = 0 ;
29674 char * kwnames[] = {
29675 (char *) "self",(char *) "other", NULL
29676 };
29677
29678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29680 if (!SWIG_IsOK(res1)) {
29681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29682 }
29683 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29684 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29685 if (!SWIG_IsOK(res2)) {
29686 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29687 }
29688 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29689 {
29690 PyThreadState* __tstate = wxPyBeginAllowThreads();
29691 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29692 wxPyEndAllowThreads(__tstate);
29693 if (PyErr_Occurred()) SWIG_fail;
29694 }
29695 {
29696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29697 }
29698 return resultobj;
29699 fail:
29700 return NULL;
29701 }
29702
29703
29704 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29705 PyObject *resultobj = 0;
29706 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29707 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29708 bool result;
29709 void *argp1 = 0 ;
29710 int res1 = 0 ;
29711 void *argp2 = 0 ;
29712 int res2 = 0 ;
29713 PyObject * obj0 = 0 ;
29714 PyObject * obj1 = 0 ;
29715 char * kwnames[] = {
29716 (char *) "self",(char *) "other", NULL
29717 };
29718
29719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29721 if (!SWIG_IsOK(res1)) {
29722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29723 }
29724 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29725 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29726 if (!SWIG_IsOK(res2)) {
29727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29728 }
29729 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29730 {
29731 PyThreadState* __tstate = wxPyBeginAllowThreads();
29732 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29733 wxPyEndAllowThreads(__tstate);
29734 if (PyErr_Occurred()) SWIG_fail;
29735 }
29736 {
29737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29738 }
29739 return resultobj;
29740 fail:
29741 return NULL;
29742 }
29743
29744
29745 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29746 PyObject *resultobj = 0;
29747 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29748 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29749 bool result;
29750 void *argp1 = 0 ;
29751 int res1 = 0 ;
29752 void *argp2 = 0 ;
29753 int res2 = 0 ;
29754 PyObject * obj0 = 0 ;
29755 PyObject * obj1 = 0 ;
29756 char * kwnames[] = {
29757 (char *) "self",(char *) "other", NULL
29758 };
29759
29760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29762 if (!SWIG_IsOK(res1)) {
29763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29764 }
29765 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29766 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29767 if (!SWIG_IsOK(res2)) {
29768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29769 }
29770 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29771 {
29772 PyThreadState* __tstate = wxPyBeginAllowThreads();
29773 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29774 wxPyEndAllowThreads(__tstate);
29775 if (PyErr_Occurred()) SWIG_fail;
29776 }
29777 {
29778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29779 }
29780 return resultobj;
29781 fail:
29782 return NULL;
29783 }
29784
29785
29786 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29787 PyObject *resultobj = 0;
29788 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29789 bool result;
29790 void *argp1 = 0 ;
29791 int res1 = 0 ;
29792 PyObject *swig_obj[1] ;
29793
29794 if (!args) SWIG_fail;
29795 swig_obj[0] = args;
29796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29797 if (!SWIG_IsOK(res1)) {
29798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29799 }
29800 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29801 {
29802 PyThreadState* __tstate = wxPyBeginAllowThreads();
29803 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29804 wxPyEndAllowThreads(__tstate);
29805 if (PyErr_Occurred()) SWIG_fail;
29806 }
29807 {
29808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29809 }
29810 return resultobj;
29811 fail:
29812 return NULL;
29813 }
29814
29815
29816 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29817 PyObject *resultobj = 0;
29818 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29819 bool result;
29820 void *argp1 = 0 ;
29821 int res1 = 0 ;
29822 PyObject *swig_obj[1] ;
29823
29824 if (!args) SWIG_fail;
29825 swig_obj[0] = args;
29826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29827 if (!SWIG_IsOK(res1)) {
29828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29829 }
29830 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29831 {
29832 PyThreadState* __tstate = wxPyBeginAllowThreads();
29833 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29834 wxPyEndAllowThreads(__tstate);
29835 if (PyErr_Occurred()) SWIG_fail;
29836 }
29837 {
29838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29839 }
29840 return resultobj;
29841 fail:
29842 return NULL;
29843 }
29844
29845
29846 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29847 PyObject *resultobj = 0;
29848 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29849 bool 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_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29859 }
29860 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29861 {
29862 PyThreadState* __tstate = wxPyBeginAllowThreads();
29863 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29864 wxPyEndAllowThreads(__tstate);
29865 if (PyErr_Occurred()) SWIG_fail;
29866 }
29867 {
29868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29869 }
29870 return resultobj;
29871 fail:
29872 return NULL;
29873 }
29874
29875
29876 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29877 PyObject *resultobj = 0;
29878 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29879 wxTimeSpan *arg2 = 0 ;
29880 bool result;
29881 void *argp1 = 0 ;
29882 int res1 = 0 ;
29883 void *argp2 = 0 ;
29884 int res2 = 0 ;
29885 PyObject * obj0 = 0 ;
29886 PyObject * obj1 = 0 ;
29887 char * kwnames[] = {
29888 (char *) "self",(char *) "ts", NULL
29889 };
29890
29891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29893 if (!SWIG_IsOK(res1)) {
29894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29895 }
29896 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29897 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29898 if (!SWIG_IsOK(res2)) {
29899 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29900 }
29901 if (!argp2) {
29902 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29903 }
29904 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29905 {
29906 PyThreadState* __tstate = wxPyBeginAllowThreads();
29907 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29908 wxPyEndAllowThreads(__tstate);
29909 if (PyErr_Occurred()) SWIG_fail;
29910 }
29911 {
29912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29913 }
29914 return resultobj;
29915 fail:
29916 return NULL;
29917 }
29918
29919
29920 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29921 PyObject *resultobj = 0;
29922 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29923 wxTimeSpan *arg2 = 0 ;
29924 bool result;
29925 void *argp1 = 0 ;
29926 int res1 = 0 ;
29927 void *argp2 = 0 ;
29928 int res2 = 0 ;
29929 PyObject * obj0 = 0 ;
29930 PyObject * obj1 = 0 ;
29931 char * kwnames[] = {
29932 (char *) "self",(char *) "ts", NULL
29933 };
29934
29935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29937 if (!SWIG_IsOK(res1)) {
29938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29939 }
29940 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29941 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29942 if (!SWIG_IsOK(res2)) {
29943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29944 }
29945 if (!argp2) {
29946 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29947 }
29948 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29949 {
29950 PyThreadState* __tstate = wxPyBeginAllowThreads();
29951 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29952 wxPyEndAllowThreads(__tstate);
29953 if (PyErr_Occurred()) SWIG_fail;
29954 }
29955 {
29956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29957 }
29958 return resultobj;
29959 fail:
29960 return NULL;
29961 }
29962
29963
29964 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29965 PyObject *resultobj = 0;
29966 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29967 wxTimeSpan *arg2 = 0 ;
29968 bool result;
29969 void *argp1 = 0 ;
29970 int res1 = 0 ;
29971 void *argp2 = 0 ;
29972 int res2 = 0 ;
29973 PyObject * obj0 = 0 ;
29974 PyObject * obj1 = 0 ;
29975 char * kwnames[] = {
29976 (char *) "self",(char *) "t", NULL
29977 };
29978
29979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29981 if (!SWIG_IsOK(res1)) {
29982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29983 }
29984 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29985 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29986 if (!SWIG_IsOK(res2)) {
29987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29988 }
29989 if (!argp2) {
29990 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29991 }
29992 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29993 {
29994 PyThreadState* __tstate = wxPyBeginAllowThreads();
29995 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
29996 wxPyEndAllowThreads(__tstate);
29997 if (PyErr_Occurred()) SWIG_fail;
29998 }
29999 {
30000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30001 }
30002 return resultobj;
30003 fail:
30004 return NULL;
30005 }
30006
30007
30008 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30009 PyObject *resultobj = 0;
30010 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30011 int result;
30012 void *argp1 = 0 ;
30013 int res1 = 0 ;
30014 PyObject *swig_obj[1] ;
30015
30016 if (!args) SWIG_fail;
30017 swig_obj[0] = args;
30018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30019 if (!SWIG_IsOK(res1)) {
30020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30021 }
30022 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30023 {
30024 PyThreadState* __tstate = wxPyBeginAllowThreads();
30025 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30026 wxPyEndAllowThreads(__tstate);
30027 if (PyErr_Occurred()) SWIG_fail;
30028 }
30029 resultobj = SWIG_From_int(static_cast< int >(result));
30030 return resultobj;
30031 fail:
30032 return NULL;
30033 }
30034
30035
30036 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30037 PyObject *resultobj = 0;
30038 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30039 int result;
30040 void *argp1 = 0 ;
30041 int res1 = 0 ;
30042 PyObject *swig_obj[1] ;
30043
30044 if (!args) SWIG_fail;
30045 swig_obj[0] = args;
30046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30047 if (!SWIG_IsOK(res1)) {
30048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30049 }
30050 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30051 {
30052 PyThreadState* __tstate = wxPyBeginAllowThreads();
30053 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30054 wxPyEndAllowThreads(__tstate);
30055 if (PyErr_Occurred()) SWIG_fail;
30056 }
30057 resultobj = SWIG_From_int(static_cast< int >(result));
30058 return resultobj;
30059 fail:
30060 return NULL;
30061 }
30062
30063
30064 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30065 PyObject *resultobj = 0;
30066 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30067 int result;
30068 void *argp1 = 0 ;
30069 int res1 = 0 ;
30070 PyObject *swig_obj[1] ;
30071
30072 if (!args) SWIG_fail;
30073 swig_obj[0] = args;
30074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30075 if (!SWIG_IsOK(res1)) {
30076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30077 }
30078 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30079 {
30080 PyThreadState* __tstate = wxPyBeginAllowThreads();
30081 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30082 wxPyEndAllowThreads(__tstate);
30083 if (PyErr_Occurred()) SWIG_fail;
30084 }
30085 resultobj = SWIG_From_int(static_cast< int >(result));
30086 return resultobj;
30087 fail:
30088 return NULL;
30089 }
30090
30091
30092 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30093 PyObject *resultobj = 0;
30094 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30095 int result;
30096 void *argp1 = 0 ;
30097 int res1 = 0 ;
30098 PyObject *swig_obj[1] ;
30099
30100 if (!args) SWIG_fail;
30101 swig_obj[0] = args;
30102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30103 if (!SWIG_IsOK(res1)) {
30104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30105 }
30106 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30107 {
30108 PyThreadState* __tstate = wxPyBeginAllowThreads();
30109 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30110 wxPyEndAllowThreads(__tstate);
30111 if (PyErr_Occurred()) SWIG_fail;
30112 }
30113 resultobj = SWIG_From_int(static_cast< int >(result));
30114 return resultobj;
30115 fail:
30116 return NULL;
30117 }
30118
30119
30120 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30121 PyObject *resultobj = 0;
30122 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30123 wxLongLong result;
30124 void *argp1 = 0 ;
30125 int res1 = 0 ;
30126 PyObject *swig_obj[1] ;
30127
30128 if (!args) SWIG_fail;
30129 swig_obj[0] = args;
30130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30131 if (!SWIG_IsOK(res1)) {
30132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30133 }
30134 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30135 {
30136 PyThreadState* __tstate = wxPyBeginAllowThreads();
30137 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30138 wxPyEndAllowThreads(__tstate);
30139 if (PyErr_Occurred()) SWIG_fail;
30140 }
30141 {
30142 PyObject *hi, *lo, *shifter, *shifted;
30143 hi = PyLong_FromLong( (&result)->GetHi() );
30144 lo = PyLong_FromLong( (&result)->GetLo() );
30145 shifter = PyLong_FromLong(32);
30146 shifted = PyNumber_Lshift(hi, shifter);
30147 resultobj = PyNumber_Or(shifted, lo);
30148 Py_DECREF(hi);
30149 Py_DECREF(lo);
30150 Py_DECREF(shifter);
30151 Py_DECREF(shifted);
30152 }
30153 return resultobj;
30154 fail:
30155 return NULL;
30156 }
30157
30158
30159 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30160 PyObject *resultobj = 0;
30161 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30162 wxLongLong result;
30163 void *argp1 = 0 ;
30164 int res1 = 0 ;
30165 PyObject *swig_obj[1] ;
30166
30167 if (!args) SWIG_fail;
30168 swig_obj[0] = args;
30169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30170 if (!SWIG_IsOK(res1)) {
30171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30172 }
30173 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30174 {
30175 PyThreadState* __tstate = wxPyBeginAllowThreads();
30176 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30177 wxPyEndAllowThreads(__tstate);
30178 if (PyErr_Occurred()) SWIG_fail;
30179 }
30180 {
30181 PyObject *hi, *lo, *shifter, *shifted;
30182 hi = PyLong_FromLong( (&result)->GetHi() );
30183 lo = PyLong_FromLong( (&result)->GetLo() );
30184 shifter = PyLong_FromLong(32);
30185 shifted = PyNumber_Lshift(hi, shifter);
30186 resultobj = PyNumber_Or(shifted, lo);
30187 Py_DECREF(hi);
30188 Py_DECREF(lo);
30189 Py_DECREF(shifter);
30190 Py_DECREF(shifted);
30191 }
30192 return resultobj;
30193 fail:
30194 return NULL;
30195 }
30196
30197
30198 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30199 PyObject *resultobj = 0;
30200 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30201 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30202 wxString *arg2 = (wxString *) &arg2_defvalue ;
30203 wxString result;
30204 void *argp1 = 0 ;
30205 int res1 = 0 ;
30206 bool temp2 = false ;
30207 PyObject * obj0 = 0 ;
30208 PyObject * obj1 = 0 ;
30209 char * kwnames[] = {
30210 (char *) "self",(char *) "format", NULL
30211 };
30212
30213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30215 if (!SWIG_IsOK(res1)) {
30216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30217 }
30218 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30219 if (obj1) {
30220 {
30221 arg2 = wxString_in_helper(obj1);
30222 if (arg2 == NULL) SWIG_fail;
30223 temp2 = true;
30224 }
30225 }
30226 {
30227 PyThreadState* __tstate = wxPyBeginAllowThreads();
30228 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30229 wxPyEndAllowThreads(__tstate);
30230 if (PyErr_Occurred()) SWIG_fail;
30231 }
30232 {
30233 #if wxUSE_UNICODE
30234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30235 #else
30236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30237 #endif
30238 }
30239 {
30240 if (temp2)
30241 delete arg2;
30242 }
30243 return resultobj;
30244 fail:
30245 {
30246 if (temp2)
30247 delete arg2;
30248 }
30249 return NULL;
30250 }
30251
30252
30253 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30254 PyObject *obj;
30255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30256 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30257 return SWIG_Py_Void();
30258 }
30259
30260 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30261 return SWIG_Python_InitShadowInstance(args);
30262 }
30263
30264 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30265 PyObject *resultobj = 0;
30266 int arg1 = (int) 0 ;
30267 int arg2 = (int) 0 ;
30268 int arg3 = (int) 0 ;
30269 int arg4 = (int) 0 ;
30270 wxDateSpan *result = 0 ;
30271 int val1 ;
30272 int ecode1 = 0 ;
30273 int val2 ;
30274 int ecode2 = 0 ;
30275 int val3 ;
30276 int ecode3 = 0 ;
30277 int val4 ;
30278 int ecode4 = 0 ;
30279 PyObject * obj0 = 0 ;
30280 PyObject * obj1 = 0 ;
30281 PyObject * obj2 = 0 ;
30282 PyObject * obj3 = 0 ;
30283 char * kwnames[] = {
30284 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30285 };
30286
30287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30288 if (obj0) {
30289 ecode1 = SWIG_AsVal_int(obj0, &val1);
30290 if (!SWIG_IsOK(ecode1)) {
30291 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30292 }
30293 arg1 = static_cast< int >(val1);
30294 }
30295 if (obj1) {
30296 ecode2 = SWIG_AsVal_int(obj1, &val2);
30297 if (!SWIG_IsOK(ecode2)) {
30298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30299 }
30300 arg2 = static_cast< int >(val2);
30301 }
30302 if (obj2) {
30303 ecode3 = SWIG_AsVal_int(obj2, &val3);
30304 if (!SWIG_IsOK(ecode3)) {
30305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30306 }
30307 arg3 = static_cast< int >(val3);
30308 }
30309 if (obj3) {
30310 ecode4 = SWIG_AsVal_int(obj3, &val4);
30311 if (!SWIG_IsOK(ecode4)) {
30312 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30313 }
30314 arg4 = static_cast< int >(val4);
30315 }
30316 {
30317 PyThreadState* __tstate = wxPyBeginAllowThreads();
30318 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30319 wxPyEndAllowThreads(__tstate);
30320 if (PyErr_Occurred()) SWIG_fail;
30321 }
30322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30323 return resultobj;
30324 fail:
30325 return NULL;
30326 }
30327
30328
30329 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30330 PyObject *resultobj = 0;
30331 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30332 void *argp1 = 0 ;
30333 int res1 = 0 ;
30334 PyObject *swig_obj[1] ;
30335
30336 if (!args) SWIG_fail;
30337 swig_obj[0] = args;
30338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30339 if (!SWIG_IsOK(res1)) {
30340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30341 }
30342 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30343 {
30344 PyThreadState* __tstate = wxPyBeginAllowThreads();
30345 delete arg1;
30346
30347 wxPyEndAllowThreads(__tstate);
30348 if (PyErr_Occurred()) SWIG_fail;
30349 }
30350 resultobj = SWIG_Py_Void();
30351 return resultobj;
30352 fail:
30353 return NULL;
30354 }
30355
30356
30357 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30358 PyObject *resultobj = 0;
30359 int arg1 ;
30360 wxDateSpan result;
30361 int val1 ;
30362 int ecode1 = 0 ;
30363 PyObject * obj0 = 0 ;
30364 char * kwnames[] = {
30365 (char *) "days", NULL
30366 };
30367
30368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30369 ecode1 = SWIG_AsVal_int(obj0, &val1);
30370 if (!SWIG_IsOK(ecode1)) {
30371 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30372 }
30373 arg1 = static_cast< int >(val1);
30374 {
30375 PyThreadState* __tstate = wxPyBeginAllowThreads();
30376 result = wxDateSpan::Days(arg1);
30377 wxPyEndAllowThreads(__tstate);
30378 if (PyErr_Occurred()) SWIG_fail;
30379 }
30380 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30381 return resultobj;
30382 fail:
30383 return NULL;
30384 }
30385
30386
30387 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30388 PyObject *resultobj = 0;
30389 wxDateSpan result;
30390
30391 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30392 {
30393 PyThreadState* __tstate = wxPyBeginAllowThreads();
30394 result = wxDateSpan::Day();
30395 wxPyEndAllowThreads(__tstate);
30396 if (PyErr_Occurred()) SWIG_fail;
30397 }
30398 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30399 return resultobj;
30400 fail:
30401 return NULL;
30402 }
30403
30404
30405 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30406 PyObject *resultobj = 0;
30407 int arg1 ;
30408 wxDateSpan result;
30409 int val1 ;
30410 int ecode1 = 0 ;
30411 PyObject * obj0 = 0 ;
30412 char * kwnames[] = {
30413 (char *) "weeks", NULL
30414 };
30415
30416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30417 ecode1 = SWIG_AsVal_int(obj0, &val1);
30418 if (!SWIG_IsOK(ecode1)) {
30419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30420 }
30421 arg1 = static_cast< int >(val1);
30422 {
30423 PyThreadState* __tstate = wxPyBeginAllowThreads();
30424 result = wxDateSpan::Weeks(arg1);
30425 wxPyEndAllowThreads(__tstate);
30426 if (PyErr_Occurred()) SWIG_fail;
30427 }
30428 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30429 return resultobj;
30430 fail:
30431 return NULL;
30432 }
30433
30434
30435 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30436 PyObject *resultobj = 0;
30437 wxDateSpan result;
30438
30439 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30440 {
30441 PyThreadState* __tstate = wxPyBeginAllowThreads();
30442 result = wxDateSpan::Week();
30443 wxPyEndAllowThreads(__tstate);
30444 if (PyErr_Occurred()) SWIG_fail;
30445 }
30446 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30447 return resultobj;
30448 fail:
30449 return NULL;
30450 }
30451
30452
30453 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30454 PyObject *resultobj = 0;
30455 int arg1 ;
30456 wxDateSpan result;
30457 int val1 ;
30458 int ecode1 = 0 ;
30459 PyObject * obj0 = 0 ;
30460 char * kwnames[] = {
30461 (char *) "mon", NULL
30462 };
30463
30464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30465 ecode1 = SWIG_AsVal_int(obj0, &val1);
30466 if (!SWIG_IsOK(ecode1)) {
30467 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30468 }
30469 arg1 = static_cast< int >(val1);
30470 {
30471 PyThreadState* __tstate = wxPyBeginAllowThreads();
30472 result = wxDateSpan::Months(arg1);
30473 wxPyEndAllowThreads(__tstate);
30474 if (PyErr_Occurred()) SWIG_fail;
30475 }
30476 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30477 return resultobj;
30478 fail:
30479 return NULL;
30480 }
30481
30482
30483 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30484 PyObject *resultobj = 0;
30485 wxDateSpan result;
30486
30487 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30488 {
30489 PyThreadState* __tstate = wxPyBeginAllowThreads();
30490 result = wxDateSpan::Month();
30491 wxPyEndAllowThreads(__tstate);
30492 if (PyErr_Occurred()) SWIG_fail;
30493 }
30494 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30495 return resultobj;
30496 fail:
30497 return NULL;
30498 }
30499
30500
30501 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30502 PyObject *resultobj = 0;
30503 int arg1 ;
30504 wxDateSpan result;
30505 int val1 ;
30506 int ecode1 = 0 ;
30507 PyObject * obj0 = 0 ;
30508 char * kwnames[] = {
30509 (char *) "years", NULL
30510 };
30511
30512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30513 ecode1 = SWIG_AsVal_int(obj0, &val1);
30514 if (!SWIG_IsOK(ecode1)) {
30515 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30516 }
30517 arg1 = static_cast< int >(val1);
30518 {
30519 PyThreadState* __tstate = wxPyBeginAllowThreads();
30520 result = wxDateSpan::Years(arg1);
30521 wxPyEndAllowThreads(__tstate);
30522 if (PyErr_Occurred()) SWIG_fail;
30523 }
30524 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30525 return resultobj;
30526 fail:
30527 return NULL;
30528 }
30529
30530
30531 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30532 PyObject *resultobj = 0;
30533 wxDateSpan result;
30534
30535 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30536 {
30537 PyThreadState* __tstate = wxPyBeginAllowThreads();
30538 result = wxDateSpan::Year();
30539 wxPyEndAllowThreads(__tstate);
30540 if (PyErr_Occurred()) SWIG_fail;
30541 }
30542 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30543 return resultobj;
30544 fail:
30545 return NULL;
30546 }
30547
30548
30549 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30550 PyObject *resultobj = 0;
30551 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30552 int arg2 ;
30553 wxDateSpan *result = 0 ;
30554 void *argp1 = 0 ;
30555 int res1 = 0 ;
30556 int val2 ;
30557 int ecode2 = 0 ;
30558 PyObject * obj0 = 0 ;
30559 PyObject * obj1 = 0 ;
30560 char * kwnames[] = {
30561 (char *) "self",(char *) "n", NULL
30562 };
30563
30564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30566 if (!SWIG_IsOK(res1)) {
30567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30568 }
30569 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30570 ecode2 = SWIG_AsVal_int(obj1, &val2);
30571 if (!SWIG_IsOK(ecode2)) {
30572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30573 }
30574 arg2 = static_cast< int >(val2);
30575 {
30576 PyThreadState* __tstate = wxPyBeginAllowThreads();
30577 {
30578 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30579 result = (wxDateSpan *) &_result_ref;
30580 }
30581 wxPyEndAllowThreads(__tstate);
30582 if (PyErr_Occurred()) SWIG_fail;
30583 }
30584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30585 return resultobj;
30586 fail:
30587 return NULL;
30588 }
30589
30590
30591 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30592 PyObject *resultobj = 0;
30593 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30594 int arg2 ;
30595 wxDateSpan *result = 0 ;
30596 void *argp1 = 0 ;
30597 int res1 = 0 ;
30598 int val2 ;
30599 int ecode2 = 0 ;
30600 PyObject * obj0 = 0 ;
30601 PyObject * obj1 = 0 ;
30602 char * kwnames[] = {
30603 (char *) "self",(char *) "n", NULL
30604 };
30605
30606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30608 if (!SWIG_IsOK(res1)) {
30609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30610 }
30611 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30612 ecode2 = SWIG_AsVal_int(obj1, &val2);
30613 if (!SWIG_IsOK(ecode2)) {
30614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30615 }
30616 arg2 = static_cast< int >(val2);
30617 {
30618 PyThreadState* __tstate = wxPyBeginAllowThreads();
30619 {
30620 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30621 result = (wxDateSpan *) &_result_ref;
30622 }
30623 wxPyEndAllowThreads(__tstate);
30624 if (PyErr_Occurred()) SWIG_fail;
30625 }
30626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30627 return resultobj;
30628 fail:
30629 return NULL;
30630 }
30631
30632
30633 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30634 PyObject *resultobj = 0;
30635 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30636 int arg2 ;
30637 wxDateSpan *result = 0 ;
30638 void *argp1 = 0 ;
30639 int res1 = 0 ;
30640 int val2 ;
30641 int ecode2 = 0 ;
30642 PyObject * obj0 = 0 ;
30643 PyObject * obj1 = 0 ;
30644 char * kwnames[] = {
30645 (char *) "self",(char *) "n", NULL
30646 };
30647
30648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30650 if (!SWIG_IsOK(res1)) {
30651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30652 }
30653 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30654 ecode2 = SWIG_AsVal_int(obj1, &val2);
30655 if (!SWIG_IsOK(ecode2)) {
30656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30657 }
30658 arg2 = static_cast< int >(val2);
30659 {
30660 PyThreadState* __tstate = wxPyBeginAllowThreads();
30661 {
30662 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30663 result = (wxDateSpan *) &_result_ref;
30664 }
30665 wxPyEndAllowThreads(__tstate);
30666 if (PyErr_Occurred()) SWIG_fail;
30667 }
30668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30669 return resultobj;
30670 fail:
30671 return NULL;
30672 }
30673
30674
30675 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30676 PyObject *resultobj = 0;
30677 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30678 int arg2 ;
30679 wxDateSpan *result = 0 ;
30680 void *argp1 = 0 ;
30681 int res1 = 0 ;
30682 int val2 ;
30683 int ecode2 = 0 ;
30684 PyObject * obj0 = 0 ;
30685 PyObject * obj1 = 0 ;
30686 char * kwnames[] = {
30687 (char *) "self",(char *) "n", NULL
30688 };
30689
30690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30692 if (!SWIG_IsOK(res1)) {
30693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30694 }
30695 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30696 ecode2 = SWIG_AsVal_int(obj1, &val2);
30697 if (!SWIG_IsOK(ecode2)) {
30698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30699 }
30700 arg2 = static_cast< int >(val2);
30701 {
30702 PyThreadState* __tstate = wxPyBeginAllowThreads();
30703 {
30704 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30705 result = (wxDateSpan *) &_result_ref;
30706 }
30707 wxPyEndAllowThreads(__tstate);
30708 if (PyErr_Occurred()) SWIG_fail;
30709 }
30710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30711 return resultobj;
30712 fail:
30713 return NULL;
30714 }
30715
30716
30717 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30718 PyObject *resultobj = 0;
30719 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30720 int result;
30721 void *argp1 = 0 ;
30722 int res1 = 0 ;
30723 PyObject *swig_obj[1] ;
30724
30725 if (!args) SWIG_fail;
30726 swig_obj[0] = args;
30727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30728 if (!SWIG_IsOK(res1)) {
30729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30730 }
30731 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30732 {
30733 PyThreadState* __tstate = wxPyBeginAllowThreads();
30734 result = (int)((wxDateSpan const *)arg1)->GetYears();
30735 wxPyEndAllowThreads(__tstate);
30736 if (PyErr_Occurred()) SWIG_fail;
30737 }
30738 resultobj = SWIG_From_int(static_cast< int >(result));
30739 return resultobj;
30740 fail:
30741 return NULL;
30742 }
30743
30744
30745 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30746 PyObject *resultobj = 0;
30747 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30748 int result;
30749 void *argp1 = 0 ;
30750 int res1 = 0 ;
30751 PyObject *swig_obj[1] ;
30752
30753 if (!args) SWIG_fail;
30754 swig_obj[0] = args;
30755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30756 if (!SWIG_IsOK(res1)) {
30757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30758 }
30759 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30760 {
30761 PyThreadState* __tstate = wxPyBeginAllowThreads();
30762 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30763 wxPyEndAllowThreads(__tstate);
30764 if (PyErr_Occurred()) SWIG_fail;
30765 }
30766 resultobj = SWIG_From_int(static_cast< int >(result));
30767 return resultobj;
30768 fail:
30769 return NULL;
30770 }
30771
30772
30773 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30774 PyObject *resultobj = 0;
30775 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30776 int result;
30777 void *argp1 = 0 ;
30778 int res1 = 0 ;
30779 PyObject *swig_obj[1] ;
30780
30781 if (!args) SWIG_fail;
30782 swig_obj[0] = args;
30783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30784 if (!SWIG_IsOK(res1)) {
30785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30786 }
30787 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30788 {
30789 PyThreadState* __tstate = wxPyBeginAllowThreads();
30790 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30791 wxPyEndAllowThreads(__tstate);
30792 if (PyErr_Occurred()) SWIG_fail;
30793 }
30794 resultobj = SWIG_From_int(static_cast< int >(result));
30795 return resultobj;
30796 fail:
30797 return NULL;
30798 }
30799
30800
30801 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30802 PyObject *resultobj = 0;
30803 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30804 int result;
30805 void *argp1 = 0 ;
30806 int res1 = 0 ;
30807 PyObject *swig_obj[1] ;
30808
30809 if (!args) SWIG_fail;
30810 swig_obj[0] = args;
30811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30812 if (!SWIG_IsOK(res1)) {
30813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30814 }
30815 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30816 {
30817 PyThreadState* __tstate = wxPyBeginAllowThreads();
30818 result = (int)((wxDateSpan const *)arg1)->GetDays();
30819 wxPyEndAllowThreads(__tstate);
30820 if (PyErr_Occurred()) SWIG_fail;
30821 }
30822 resultobj = SWIG_From_int(static_cast< int >(result));
30823 return resultobj;
30824 fail:
30825 return NULL;
30826 }
30827
30828
30829 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30830 PyObject *resultobj = 0;
30831 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30832 int result;
30833 void *argp1 = 0 ;
30834 int res1 = 0 ;
30835 PyObject *swig_obj[1] ;
30836
30837 if (!args) SWIG_fail;
30838 swig_obj[0] = args;
30839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30840 if (!SWIG_IsOK(res1)) {
30841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30842 }
30843 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30844 {
30845 PyThreadState* __tstate = wxPyBeginAllowThreads();
30846 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30847 wxPyEndAllowThreads(__tstate);
30848 if (PyErr_Occurred()) SWIG_fail;
30849 }
30850 resultobj = SWIG_From_int(static_cast< int >(result));
30851 return resultobj;
30852 fail:
30853 return NULL;
30854 }
30855
30856
30857 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30858 PyObject *resultobj = 0;
30859 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30860 wxDateSpan *arg2 = 0 ;
30861 wxDateSpan *result = 0 ;
30862 void *argp1 = 0 ;
30863 int res1 = 0 ;
30864 void *argp2 = 0 ;
30865 int res2 = 0 ;
30866 PyObject * obj0 = 0 ;
30867 PyObject * obj1 = 0 ;
30868 char * kwnames[] = {
30869 (char *) "self",(char *) "other", NULL
30870 };
30871
30872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30874 if (!SWIG_IsOK(res1)) {
30875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30876 }
30877 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30878 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30879 if (!SWIG_IsOK(res2)) {
30880 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30881 }
30882 if (!argp2) {
30883 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30884 }
30885 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30886 {
30887 PyThreadState* __tstate = wxPyBeginAllowThreads();
30888 {
30889 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30890 result = (wxDateSpan *) &_result_ref;
30891 }
30892 wxPyEndAllowThreads(__tstate);
30893 if (PyErr_Occurred()) SWIG_fail;
30894 }
30895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30896 return resultobj;
30897 fail:
30898 return NULL;
30899 }
30900
30901
30902 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30903 PyObject *resultobj = 0;
30904 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30905 wxDateSpan *arg2 = 0 ;
30906 wxDateSpan *result = 0 ;
30907 void *argp1 = 0 ;
30908 int res1 = 0 ;
30909 void *argp2 = 0 ;
30910 int res2 = 0 ;
30911 PyObject * obj0 = 0 ;
30912 PyObject * obj1 = 0 ;
30913 char * kwnames[] = {
30914 (char *) "self",(char *) "other", NULL
30915 };
30916
30917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30919 if (!SWIG_IsOK(res1)) {
30920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30921 }
30922 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30923 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30924 if (!SWIG_IsOK(res2)) {
30925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30926 }
30927 if (!argp2) {
30928 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30929 }
30930 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30931 {
30932 PyThreadState* __tstate = wxPyBeginAllowThreads();
30933 {
30934 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30935 result = (wxDateSpan *) &_result_ref;
30936 }
30937 wxPyEndAllowThreads(__tstate);
30938 if (PyErr_Occurred()) SWIG_fail;
30939 }
30940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30941 return resultobj;
30942 fail:
30943 return NULL;
30944 }
30945
30946
30947 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30948 PyObject *resultobj = 0;
30949 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30950 wxDateSpan *result = 0 ;
30951 void *argp1 = 0 ;
30952 int res1 = 0 ;
30953 PyObject *swig_obj[1] ;
30954
30955 if (!args) SWIG_fail;
30956 swig_obj[0] = args;
30957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30958 if (!SWIG_IsOK(res1)) {
30959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30960 }
30961 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30962 {
30963 PyThreadState* __tstate = wxPyBeginAllowThreads();
30964 {
30965 wxDateSpan &_result_ref = (arg1)->Neg();
30966 result = (wxDateSpan *) &_result_ref;
30967 }
30968 wxPyEndAllowThreads(__tstate);
30969 if (PyErr_Occurred()) SWIG_fail;
30970 }
30971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30972 return resultobj;
30973 fail:
30974 return NULL;
30975 }
30976
30977
30978 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30979 PyObject *resultobj = 0;
30980 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30981 int arg2 ;
30982 wxDateSpan *result = 0 ;
30983 void *argp1 = 0 ;
30984 int res1 = 0 ;
30985 int val2 ;
30986 int ecode2 = 0 ;
30987 PyObject * obj0 = 0 ;
30988 PyObject * obj1 = 0 ;
30989 char * kwnames[] = {
30990 (char *) "self",(char *) "factor", NULL
30991 };
30992
30993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
30994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30995 if (!SWIG_IsOK(res1)) {
30996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30997 }
30998 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30999 ecode2 = SWIG_AsVal_int(obj1, &val2);
31000 if (!SWIG_IsOK(ecode2)) {
31001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
31002 }
31003 arg2 = static_cast< int >(val2);
31004 {
31005 PyThreadState* __tstate = wxPyBeginAllowThreads();
31006 {
31007 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
31008 result = (wxDateSpan *) &_result_ref;
31009 }
31010 wxPyEndAllowThreads(__tstate);
31011 if (PyErr_Occurred()) SWIG_fail;
31012 }
31013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31014 return resultobj;
31015 fail:
31016 return NULL;
31017 }
31018
31019
31020 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31021 PyObject *resultobj = 0;
31022 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31023 wxDateSpan *arg2 = 0 ;
31024 wxDateSpan *result = 0 ;
31025 void *argp1 = 0 ;
31026 int res1 = 0 ;
31027 void *argp2 = 0 ;
31028 int res2 = 0 ;
31029 PyObject * obj0 = 0 ;
31030 PyObject * obj1 = 0 ;
31031 char * kwnames[] = {
31032 (char *) "self",(char *) "other", NULL
31033 };
31034
31035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31037 if (!SWIG_IsOK(res1)) {
31038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31039 }
31040 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31041 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31042 if (!SWIG_IsOK(res2)) {
31043 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31044 }
31045 if (!argp2) {
31046 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31047 }
31048 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31049 {
31050 PyThreadState* __tstate = wxPyBeginAllowThreads();
31051 {
31052 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31053 result = (wxDateSpan *) &_result_ref;
31054 }
31055 wxPyEndAllowThreads(__tstate);
31056 if (PyErr_Occurred()) SWIG_fail;
31057 }
31058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31059 return resultobj;
31060 fail:
31061 return NULL;
31062 }
31063
31064
31065 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31066 PyObject *resultobj = 0;
31067 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31068 wxDateSpan *arg2 = 0 ;
31069 wxDateSpan *result = 0 ;
31070 void *argp1 = 0 ;
31071 int res1 = 0 ;
31072 void *argp2 = 0 ;
31073 int res2 = 0 ;
31074 PyObject * obj0 = 0 ;
31075 PyObject * obj1 = 0 ;
31076 char * kwnames[] = {
31077 (char *) "self",(char *) "other", NULL
31078 };
31079
31080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31082 if (!SWIG_IsOK(res1)) {
31083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31084 }
31085 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31086 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31087 if (!SWIG_IsOK(res2)) {
31088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31089 }
31090 if (!argp2) {
31091 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31092 }
31093 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31094 {
31095 PyThreadState* __tstate = wxPyBeginAllowThreads();
31096 {
31097 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31098 result = (wxDateSpan *) &_result_ref;
31099 }
31100 wxPyEndAllowThreads(__tstate);
31101 if (PyErr_Occurred()) SWIG_fail;
31102 }
31103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31104 return resultobj;
31105 fail:
31106 return NULL;
31107 }
31108
31109
31110 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31111 PyObject *resultobj = 0;
31112 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31113 wxDateSpan *result = 0 ;
31114 void *argp1 = 0 ;
31115 int res1 = 0 ;
31116 PyObject *swig_obj[1] ;
31117
31118 if (!args) SWIG_fail;
31119 swig_obj[0] = args;
31120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31121 if (!SWIG_IsOK(res1)) {
31122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31123 }
31124 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31125 {
31126 PyThreadState* __tstate = wxPyBeginAllowThreads();
31127 {
31128 wxDateSpan &_result_ref = (arg1)->operator -();
31129 result = (wxDateSpan *) &_result_ref;
31130 }
31131 wxPyEndAllowThreads(__tstate);
31132 if (PyErr_Occurred()) SWIG_fail;
31133 }
31134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31135 return resultobj;
31136 fail:
31137 return NULL;
31138 }
31139
31140
31141 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31142 PyObject *resultobj = 0;
31143 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31144 int arg2 ;
31145 wxDateSpan *result = 0 ;
31146 void *argp1 = 0 ;
31147 int res1 = 0 ;
31148 int val2 ;
31149 int ecode2 = 0 ;
31150 PyObject * obj0 = 0 ;
31151 PyObject * obj1 = 0 ;
31152 char * kwnames[] = {
31153 (char *) "self",(char *) "factor", NULL
31154 };
31155
31156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31158 if (!SWIG_IsOK(res1)) {
31159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31160 }
31161 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31162 ecode2 = SWIG_AsVal_int(obj1, &val2);
31163 if (!SWIG_IsOK(ecode2)) {
31164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31165 }
31166 arg2 = static_cast< int >(val2);
31167 {
31168 PyThreadState* __tstate = wxPyBeginAllowThreads();
31169 {
31170 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31171 result = (wxDateSpan *) &_result_ref;
31172 }
31173 wxPyEndAllowThreads(__tstate);
31174 if (PyErr_Occurred()) SWIG_fail;
31175 }
31176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31177 return resultobj;
31178 fail:
31179 return NULL;
31180 }
31181
31182
31183 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31184 PyObject *resultobj = 0;
31185 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31186 wxDateSpan *arg2 = 0 ;
31187 wxDateSpan result;
31188 void *argp1 = 0 ;
31189 int res1 = 0 ;
31190 void *argp2 = 0 ;
31191 int res2 = 0 ;
31192 PyObject * obj0 = 0 ;
31193 PyObject * obj1 = 0 ;
31194 char * kwnames[] = {
31195 (char *) "self",(char *) "other", NULL
31196 };
31197
31198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31200 if (!SWIG_IsOK(res1)) {
31201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31202 }
31203 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31204 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31205 if (!SWIG_IsOK(res2)) {
31206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31207 }
31208 if (!argp2) {
31209 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31210 }
31211 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31212 {
31213 PyThreadState* __tstate = wxPyBeginAllowThreads();
31214 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31215 wxPyEndAllowThreads(__tstate);
31216 if (PyErr_Occurred()) SWIG_fail;
31217 }
31218 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31219 return resultobj;
31220 fail:
31221 return NULL;
31222 }
31223
31224
31225 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31226 PyObject *resultobj = 0;
31227 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31228 wxDateSpan *arg2 = 0 ;
31229 wxDateSpan result;
31230 void *argp1 = 0 ;
31231 int res1 = 0 ;
31232 void *argp2 = 0 ;
31233 int res2 = 0 ;
31234 PyObject * obj0 = 0 ;
31235 PyObject * obj1 = 0 ;
31236 char * kwnames[] = {
31237 (char *) "self",(char *) "other", NULL
31238 };
31239
31240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31242 if (!SWIG_IsOK(res1)) {
31243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31244 }
31245 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31246 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31247 if (!SWIG_IsOK(res2)) {
31248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31249 }
31250 if (!argp2) {
31251 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31252 }
31253 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31254 {
31255 PyThreadState* __tstate = wxPyBeginAllowThreads();
31256 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31257 wxPyEndAllowThreads(__tstate);
31258 if (PyErr_Occurred()) SWIG_fail;
31259 }
31260 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31261 return resultobj;
31262 fail:
31263 return NULL;
31264 }
31265
31266
31267 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31268 PyObject *resultobj = 0;
31269 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31270 int arg2 ;
31271 wxDateSpan result;
31272 void *argp1 = 0 ;
31273 int res1 = 0 ;
31274 int val2 ;
31275 int ecode2 = 0 ;
31276 PyObject * obj0 = 0 ;
31277 PyObject * obj1 = 0 ;
31278 char * kwnames[] = {
31279 (char *) "self",(char *) "n", NULL
31280 };
31281
31282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31284 if (!SWIG_IsOK(res1)) {
31285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31286 }
31287 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31288 ecode2 = SWIG_AsVal_int(obj1, &val2);
31289 if (!SWIG_IsOK(ecode2)) {
31290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31291 }
31292 arg2 = static_cast< int >(val2);
31293 {
31294 PyThreadState* __tstate = wxPyBeginAllowThreads();
31295 result = wxDateSpan___mul__(arg1,arg2);
31296 wxPyEndAllowThreads(__tstate);
31297 if (PyErr_Occurred()) SWIG_fail;
31298 }
31299 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31300 return resultobj;
31301 fail:
31302 return NULL;
31303 }
31304
31305
31306 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31307 PyObject *resultobj = 0;
31308 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31309 int arg2 ;
31310 wxDateSpan result;
31311 void *argp1 = 0 ;
31312 int res1 = 0 ;
31313 int val2 ;
31314 int ecode2 = 0 ;
31315 PyObject * obj0 = 0 ;
31316 PyObject * obj1 = 0 ;
31317 char * kwnames[] = {
31318 (char *) "self",(char *) "n", NULL
31319 };
31320
31321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31323 if (!SWIG_IsOK(res1)) {
31324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31325 }
31326 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31327 ecode2 = SWIG_AsVal_int(obj1, &val2);
31328 if (!SWIG_IsOK(ecode2)) {
31329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31330 }
31331 arg2 = static_cast< int >(val2);
31332 {
31333 PyThreadState* __tstate = wxPyBeginAllowThreads();
31334 result = wxDateSpan___rmul__(arg1,arg2);
31335 wxPyEndAllowThreads(__tstate);
31336 if (PyErr_Occurred()) SWIG_fail;
31337 }
31338 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31339 return resultobj;
31340 fail:
31341 return NULL;
31342 }
31343
31344
31345 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31346 PyObject *resultobj = 0;
31347 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31348 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31349 bool result;
31350 void *argp1 = 0 ;
31351 int res1 = 0 ;
31352 void *argp2 = 0 ;
31353 int res2 = 0 ;
31354 PyObject * obj0 = 0 ;
31355 PyObject * obj1 = 0 ;
31356 char * kwnames[] = {
31357 (char *) "self",(char *) "other", NULL
31358 };
31359
31360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31362 if (!SWIG_IsOK(res1)) {
31363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31364 }
31365 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31366 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31367 if (!SWIG_IsOK(res2)) {
31368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31369 }
31370 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31371 {
31372 PyThreadState* __tstate = wxPyBeginAllowThreads();
31373 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31374 wxPyEndAllowThreads(__tstate);
31375 if (PyErr_Occurred()) SWIG_fail;
31376 }
31377 {
31378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31379 }
31380 return resultobj;
31381 fail:
31382 return NULL;
31383 }
31384
31385
31386 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31387 PyObject *resultobj = 0;
31388 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31389 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31390 bool result;
31391 void *argp1 = 0 ;
31392 int res1 = 0 ;
31393 void *argp2 = 0 ;
31394 int res2 = 0 ;
31395 PyObject * obj0 = 0 ;
31396 PyObject * obj1 = 0 ;
31397 char * kwnames[] = {
31398 (char *) "self",(char *) "other", NULL
31399 };
31400
31401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31403 if (!SWIG_IsOK(res1)) {
31404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31405 }
31406 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31407 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31408 if (!SWIG_IsOK(res2)) {
31409 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31410 }
31411 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31412 {
31413 PyThreadState* __tstate = wxPyBeginAllowThreads();
31414 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31415 wxPyEndAllowThreads(__tstate);
31416 if (PyErr_Occurred()) SWIG_fail;
31417 }
31418 {
31419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31420 }
31421 return resultobj;
31422 fail:
31423 return NULL;
31424 }
31425
31426
31427 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31428 PyObject *obj;
31429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31430 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31431 return SWIG_Py_Void();
31432 }
31433
31434 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31435 return SWIG_Python_InitShadowInstance(args);
31436 }
31437
31438 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31439 PyObject *resultobj = 0;
31440 long result;
31441
31442 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31443 {
31444 PyThreadState* __tstate = wxPyBeginAllowThreads();
31445 result = (long)wxGetLocalTime();
31446 wxPyEndAllowThreads(__tstate);
31447 if (PyErr_Occurred()) SWIG_fail;
31448 }
31449 resultobj = SWIG_From_long(static_cast< long >(result));
31450 return resultobj;
31451 fail:
31452 return NULL;
31453 }
31454
31455
31456 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31457 PyObject *resultobj = 0;
31458 long result;
31459
31460 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31461 {
31462 PyThreadState* __tstate = wxPyBeginAllowThreads();
31463 result = (long)wxGetUTCTime();
31464 wxPyEndAllowThreads(__tstate);
31465 if (PyErr_Occurred()) SWIG_fail;
31466 }
31467 resultobj = SWIG_From_long(static_cast< long >(result));
31468 return resultobj;
31469 fail:
31470 return NULL;
31471 }
31472
31473
31474 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31475 PyObject *resultobj = 0;
31476 long result;
31477
31478 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31479 {
31480 PyThreadState* __tstate = wxPyBeginAllowThreads();
31481 result = (long)wxGetCurrentTime();
31482 wxPyEndAllowThreads(__tstate);
31483 if (PyErr_Occurred()) SWIG_fail;
31484 }
31485 resultobj = SWIG_From_long(static_cast< long >(result));
31486 return resultobj;
31487 fail:
31488 return NULL;
31489 }
31490
31491
31492 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31493 PyObject *resultobj = 0;
31494 wxLongLong result;
31495
31496 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31497 {
31498 PyThreadState* __tstate = wxPyBeginAllowThreads();
31499 result = wxGetLocalTimeMillis();
31500 wxPyEndAllowThreads(__tstate);
31501 if (PyErr_Occurred()) SWIG_fail;
31502 }
31503 {
31504 PyObject *hi, *lo, *shifter, *shifted;
31505 hi = PyLong_FromLong( (&result)->GetHi() );
31506 lo = PyLong_FromLong( (&result)->GetLo() );
31507 shifter = PyLong_FromLong(32);
31508 shifted = PyNumber_Lshift(hi, shifter);
31509 resultobj = PyNumber_Or(shifted, lo);
31510 Py_DECREF(hi);
31511 Py_DECREF(lo);
31512 Py_DECREF(shifter);
31513 Py_DECREF(shifted);
31514 }
31515 return resultobj;
31516 fail:
31517 return NULL;
31518 }
31519
31520
31521 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31522 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31523 return 1;
31524 }
31525
31526
31527 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31528 PyObject *pyobj = 0;
31529
31530 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31531 return pyobj;
31532 }
31533
31534
31535 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31536 PyObject *resultobj = 0;
31537 wxDataFormatId arg1 ;
31538 wxDataFormat *result = 0 ;
31539 int val1 ;
31540 int ecode1 = 0 ;
31541 PyObject * obj0 = 0 ;
31542 char * kwnames[] = {
31543 (char *) "type", NULL
31544 };
31545
31546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31547 ecode1 = SWIG_AsVal_int(obj0, &val1);
31548 if (!SWIG_IsOK(ecode1)) {
31549 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31550 }
31551 arg1 = static_cast< wxDataFormatId >(val1);
31552 {
31553 PyThreadState* __tstate = wxPyBeginAllowThreads();
31554 result = (wxDataFormat *)new wxDataFormat(arg1);
31555 wxPyEndAllowThreads(__tstate);
31556 if (PyErr_Occurred()) SWIG_fail;
31557 }
31558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31559 return resultobj;
31560 fail:
31561 return NULL;
31562 }
31563
31564
31565 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31566 PyObject *resultobj = 0;
31567 wxString *arg1 = 0 ;
31568 wxDataFormat *result = 0 ;
31569 bool temp1 = false ;
31570 PyObject * obj0 = 0 ;
31571 char * kwnames[] = {
31572 (char *) "format", NULL
31573 };
31574
31575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31576 {
31577 arg1 = wxString_in_helper(obj0);
31578 if (arg1 == NULL) SWIG_fail;
31579 temp1 = true;
31580 }
31581 {
31582 PyThreadState* __tstate = wxPyBeginAllowThreads();
31583 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31584 wxPyEndAllowThreads(__tstate);
31585 if (PyErr_Occurred()) SWIG_fail;
31586 }
31587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31588 {
31589 if (temp1)
31590 delete arg1;
31591 }
31592 return resultobj;
31593 fail:
31594 {
31595 if (temp1)
31596 delete arg1;
31597 }
31598 return NULL;
31599 }
31600
31601
31602 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31603 PyObject *resultobj = 0;
31604 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31605 void *argp1 = 0 ;
31606 int res1 = 0 ;
31607 PyObject *swig_obj[1] ;
31608
31609 if (!args) SWIG_fail;
31610 swig_obj[0] = args;
31611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31612 if (!SWIG_IsOK(res1)) {
31613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31614 }
31615 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31616 {
31617 PyThreadState* __tstate = wxPyBeginAllowThreads();
31618 delete arg1;
31619
31620 wxPyEndAllowThreads(__tstate);
31621 if (PyErr_Occurred()) SWIG_fail;
31622 }
31623 resultobj = SWIG_Py_Void();
31624 return resultobj;
31625 fail:
31626 return NULL;
31627 }
31628
31629
31630 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31631 PyObject *resultobj = 0;
31632 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31633 wxDataFormatId arg2 ;
31634 bool result;
31635 void *argp1 = 0 ;
31636 int res1 = 0 ;
31637 int val2 ;
31638 int ecode2 = 0 ;
31639
31640 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31642 if (!SWIG_IsOK(res1)) {
31643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31644 }
31645 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31646 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31647 if (!SWIG_IsOK(ecode2)) {
31648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31649 }
31650 arg2 = static_cast< wxDataFormatId >(val2);
31651 {
31652 PyThreadState* __tstate = wxPyBeginAllowThreads();
31653 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31654 wxPyEndAllowThreads(__tstate);
31655 if (PyErr_Occurred()) SWIG_fail;
31656 }
31657 {
31658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31659 }
31660 return resultobj;
31661 fail:
31662 return NULL;
31663 }
31664
31665
31666 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31667 PyObject *resultobj = 0;
31668 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31669 wxDataFormatId arg2 ;
31670 bool result;
31671 void *argp1 = 0 ;
31672 int res1 = 0 ;
31673 int val2 ;
31674 int ecode2 = 0 ;
31675
31676 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31678 if (!SWIG_IsOK(res1)) {
31679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31680 }
31681 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31682 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31683 if (!SWIG_IsOK(ecode2)) {
31684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31685 }
31686 arg2 = static_cast< wxDataFormatId >(val2);
31687 {
31688 PyThreadState* __tstate = wxPyBeginAllowThreads();
31689 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31690 wxPyEndAllowThreads(__tstate);
31691 if (PyErr_Occurred()) SWIG_fail;
31692 }
31693 {
31694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31695 }
31696 return resultobj;
31697 fail:
31698 return NULL;
31699 }
31700
31701
31702 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31703 PyObject *resultobj = 0;
31704 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31705 wxDataFormat *arg2 = 0 ;
31706 bool result;
31707 void *argp1 = 0 ;
31708 int res1 = 0 ;
31709 void *argp2 = 0 ;
31710 int res2 = 0 ;
31711
31712 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31714 if (!SWIG_IsOK(res1)) {
31715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31716 }
31717 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31718 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31719 if (!SWIG_IsOK(res2)) {
31720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31721 }
31722 if (!argp2) {
31723 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31724 }
31725 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31726 {
31727 PyThreadState* __tstate = wxPyBeginAllowThreads();
31728 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31729 wxPyEndAllowThreads(__tstate);
31730 if (PyErr_Occurred()) SWIG_fail;
31731 }
31732 {
31733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31734 }
31735 return resultobj;
31736 fail:
31737 return NULL;
31738 }
31739
31740
31741 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31742 int argc;
31743 PyObject *argv[3];
31744
31745 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31746 --argc;
31747 if (argc == 2) {
31748 int _v = 0;
31749 {
31750 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31751 _v = SWIG_CheckState(res);
31752 }
31753 if (!_v) goto check_1;
31754 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31755 }
31756 check_1:
31757
31758 if (argc == 2) {
31759 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31760 }
31761
31762 fail:
31763 Py_INCREF(Py_NotImplemented);
31764 return Py_NotImplemented;
31765 }
31766
31767
31768 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31769 PyObject *resultobj = 0;
31770 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31771 wxDataFormat *arg2 = 0 ;
31772 bool result;
31773 void *argp1 = 0 ;
31774 int res1 = 0 ;
31775 void *argp2 = 0 ;
31776 int res2 = 0 ;
31777
31778 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31780 if (!SWIG_IsOK(res1)) {
31781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31782 }
31783 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31784 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31785 if (!SWIG_IsOK(res2)) {
31786 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31787 }
31788 if (!argp2) {
31789 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31790 }
31791 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31792 {
31793 PyThreadState* __tstate = wxPyBeginAllowThreads();
31794 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31795 wxPyEndAllowThreads(__tstate);
31796 if (PyErr_Occurred()) SWIG_fail;
31797 }
31798 {
31799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31800 }
31801 return resultobj;
31802 fail:
31803 return NULL;
31804 }
31805
31806
31807 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31808 int argc;
31809 PyObject *argv[3];
31810
31811 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31812 --argc;
31813 if (argc == 2) {
31814 int _v = 0;
31815 {
31816 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31817 _v = SWIG_CheckState(res);
31818 }
31819 if (!_v) goto check_1;
31820 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31821 }
31822 check_1:
31823
31824 if (argc == 2) {
31825 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31826 }
31827
31828 fail:
31829 Py_INCREF(Py_NotImplemented);
31830 return Py_NotImplemented;
31831 }
31832
31833
31834 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31835 PyObject *resultobj = 0;
31836 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31837 wxDataFormatId arg2 ;
31838 void *argp1 = 0 ;
31839 int res1 = 0 ;
31840 int val2 ;
31841 int ecode2 = 0 ;
31842 PyObject * obj0 = 0 ;
31843 PyObject * obj1 = 0 ;
31844 char * kwnames[] = {
31845 (char *) "self",(char *) "format", NULL
31846 };
31847
31848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31850 if (!SWIG_IsOK(res1)) {
31851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31852 }
31853 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31854 ecode2 = SWIG_AsVal_int(obj1, &val2);
31855 if (!SWIG_IsOK(ecode2)) {
31856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31857 }
31858 arg2 = static_cast< wxDataFormatId >(val2);
31859 {
31860 PyThreadState* __tstate = wxPyBeginAllowThreads();
31861 (arg1)->SetType(arg2);
31862 wxPyEndAllowThreads(__tstate);
31863 if (PyErr_Occurred()) SWIG_fail;
31864 }
31865 resultobj = SWIG_Py_Void();
31866 return resultobj;
31867 fail:
31868 return NULL;
31869 }
31870
31871
31872 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31873 PyObject *resultobj = 0;
31874 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31875 wxDataFormatId result;
31876 void *argp1 = 0 ;
31877 int res1 = 0 ;
31878 PyObject *swig_obj[1] ;
31879
31880 if (!args) SWIG_fail;
31881 swig_obj[0] = args;
31882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31883 if (!SWIG_IsOK(res1)) {
31884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31885 }
31886 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31887 {
31888 PyThreadState* __tstate = wxPyBeginAllowThreads();
31889 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31890 wxPyEndAllowThreads(__tstate);
31891 if (PyErr_Occurred()) SWIG_fail;
31892 }
31893 resultobj = SWIG_From_int(static_cast< int >(result));
31894 return resultobj;
31895 fail:
31896 return NULL;
31897 }
31898
31899
31900 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31901 PyObject *resultobj = 0;
31902 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31903 wxString result;
31904 void *argp1 = 0 ;
31905 int res1 = 0 ;
31906 PyObject *swig_obj[1] ;
31907
31908 if (!args) SWIG_fail;
31909 swig_obj[0] = args;
31910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31911 if (!SWIG_IsOK(res1)) {
31912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31913 }
31914 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31915 {
31916 PyThreadState* __tstate = wxPyBeginAllowThreads();
31917 result = ((wxDataFormat const *)arg1)->GetId();
31918 wxPyEndAllowThreads(__tstate);
31919 if (PyErr_Occurred()) SWIG_fail;
31920 }
31921 {
31922 #if wxUSE_UNICODE
31923 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31924 #else
31925 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31926 #endif
31927 }
31928 return resultobj;
31929 fail:
31930 return NULL;
31931 }
31932
31933
31934 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31935 PyObject *resultobj = 0;
31936 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31937 wxString *arg2 = 0 ;
31938 void *argp1 = 0 ;
31939 int res1 = 0 ;
31940 bool temp2 = false ;
31941 PyObject * obj0 = 0 ;
31942 PyObject * obj1 = 0 ;
31943 char * kwnames[] = {
31944 (char *) "self",(char *) "format", NULL
31945 };
31946
31947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31949 if (!SWIG_IsOK(res1)) {
31950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31951 }
31952 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31953 {
31954 arg2 = wxString_in_helper(obj1);
31955 if (arg2 == NULL) SWIG_fail;
31956 temp2 = true;
31957 }
31958 {
31959 PyThreadState* __tstate = wxPyBeginAllowThreads();
31960 (arg1)->SetId((wxString const &)*arg2);
31961 wxPyEndAllowThreads(__tstate);
31962 if (PyErr_Occurred()) SWIG_fail;
31963 }
31964 resultobj = SWIG_Py_Void();
31965 {
31966 if (temp2)
31967 delete arg2;
31968 }
31969 return resultobj;
31970 fail:
31971 {
31972 if (temp2)
31973 delete arg2;
31974 }
31975 return NULL;
31976 }
31977
31978
31979 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31980 PyObject *obj;
31981 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31982 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31983 return SWIG_Py_Void();
31984 }
31985
31986 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31987 return SWIG_Python_InitShadowInstance(args);
31988 }
31989
31990 SWIGINTERN int FormatInvalid_set(PyObject *) {
31991 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31992 return 1;
31993 }
31994
31995
31996 SWIGINTERN PyObject *FormatInvalid_get(void) {
31997 PyObject *pyobj = 0;
31998
31999 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
32000 return pyobj;
32001 }
32002
32003
32004 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32005 PyObject *resultobj = 0;
32006 wxDataObject *arg1 = (wxDataObject *) 0 ;
32007 void *argp1 = 0 ;
32008 int res1 = 0 ;
32009 PyObject *swig_obj[1] ;
32010
32011 if (!args) SWIG_fail;
32012 swig_obj[0] = args;
32013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32014 if (!SWIG_IsOK(res1)) {
32015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
32016 }
32017 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32018 {
32019 PyThreadState* __tstate = wxPyBeginAllowThreads();
32020 delete arg1;
32021
32022 wxPyEndAllowThreads(__tstate);
32023 if (PyErr_Occurred()) SWIG_fail;
32024 }
32025 resultobj = SWIG_Py_Void();
32026 return resultobj;
32027 fail:
32028 return NULL;
32029 }
32030
32031
32032 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32033 PyObject *resultobj = 0;
32034 wxDataObject *arg1 = (wxDataObject *) 0 ;
32035 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32036 SwigValueWrapper<wxDataFormat > result;
32037 void *argp1 = 0 ;
32038 int res1 = 0 ;
32039 int val2 ;
32040 int ecode2 = 0 ;
32041 PyObject * obj0 = 0 ;
32042 PyObject * obj1 = 0 ;
32043 char * kwnames[] = {
32044 (char *) "self",(char *) "dir", NULL
32045 };
32046
32047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32049 if (!SWIG_IsOK(res1)) {
32050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32051 }
32052 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32053 if (obj1) {
32054 ecode2 = SWIG_AsVal_int(obj1, &val2);
32055 if (!SWIG_IsOK(ecode2)) {
32056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32057 }
32058 arg2 = static_cast< wxDataObject::Direction >(val2);
32059 }
32060 {
32061 PyThreadState* __tstate = wxPyBeginAllowThreads();
32062 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32063 wxPyEndAllowThreads(__tstate);
32064 if (PyErr_Occurred()) SWIG_fail;
32065 }
32066 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32067 return resultobj;
32068 fail:
32069 return NULL;
32070 }
32071
32072
32073 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32074 PyObject *resultobj = 0;
32075 wxDataObject *arg1 = (wxDataObject *) 0 ;
32076 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32077 size_t result;
32078 void *argp1 = 0 ;
32079 int res1 = 0 ;
32080 int val2 ;
32081 int ecode2 = 0 ;
32082 PyObject * obj0 = 0 ;
32083 PyObject * obj1 = 0 ;
32084 char * kwnames[] = {
32085 (char *) "self",(char *) "dir", NULL
32086 };
32087
32088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32090 if (!SWIG_IsOK(res1)) {
32091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32092 }
32093 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32094 if (obj1) {
32095 ecode2 = SWIG_AsVal_int(obj1, &val2);
32096 if (!SWIG_IsOK(ecode2)) {
32097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32098 }
32099 arg2 = static_cast< wxDataObject::Direction >(val2);
32100 }
32101 {
32102 PyThreadState* __tstate = wxPyBeginAllowThreads();
32103 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32104 wxPyEndAllowThreads(__tstate);
32105 if (PyErr_Occurred()) SWIG_fail;
32106 }
32107 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32108 return resultobj;
32109 fail:
32110 return NULL;
32111 }
32112
32113
32114 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32115 PyObject *resultobj = 0;
32116 wxDataObject *arg1 = (wxDataObject *) 0 ;
32117 wxDataFormat *arg2 = 0 ;
32118 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32119 bool result;
32120 void *argp1 = 0 ;
32121 int res1 = 0 ;
32122 void *argp2 = 0 ;
32123 int res2 = 0 ;
32124 int val3 ;
32125 int ecode3 = 0 ;
32126 PyObject * obj0 = 0 ;
32127 PyObject * obj1 = 0 ;
32128 PyObject * obj2 = 0 ;
32129 char * kwnames[] = {
32130 (char *) "self",(char *) "format",(char *) "dir", NULL
32131 };
32132
32133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32135 if (!SWIG_IsOK(res1)) {
32136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32137 }
32138 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32139 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32140 if (!SWIG_IsOK(res2)) {
32141 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32142 }
32143 if (!argp2) {
32144 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32145 }
32146 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32147 if (obj2) {
32148 ecode3 = SWIG_AsVal_int(obj2, &val3);
32149 if (!SWIG_IsOK(ecode3)) {
32150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32151 }
32152 arg3 = static_cast< wxDataObject::Direction >(val3);
32153 }
32154 {
32155 PyThreadState* __tstate = wxPyBeginAllowThreads();
32156 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32157 wxPyEndAllowThreads(__tstate);
32158 if (PyErr_Occurred()) SWIG_fail;
32159 }
32160 {
32161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32162 }
32163 return resultobj;
32164 fail:
32165 return NULL;
32166 }
32167
32168
32169 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32170 PyObject *resultobj = 0;
32171 wxDataObject *arg1 = (wxDataObject *) 0 ;
32172 wxDataFormat *arg2 = 0 ;
32173 size_t result;
32174 void *argp1 = 0 ;
32175 int res1 = 0 ;
32176 void *argp2 = 0 ;
32177 int res2 = 0 ;
32178 PyObject * obj0 = 0 ;
32179 PyObject * obj1 = 0 ;
32180 char * kwnames[] = {
32181 (char *) "self",(char *) "format", NULL
32182 };
32183
32184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32186 if (!SWIG_IsOK(res1)) {
32187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32188 }
32189 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32190 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32191 if (!SWIG_IsOK(res2)) {
32192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32193 }
32194 if (!argp2) {
32195 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32196 }
32197 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32198 {
32199 PyThreadState* __tstate = wxPyBeginAllowThreads();
32200 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32201 wxPyEndAllowThreads(__tstate);
32202 if (PyErr_Occurred()) SWIG_fail;
32203 }
32204 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32205 return resultobj;
32206 fail:
32207 return NULL;
32208 }
32209
32210
32211 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32212 PyObject *resultobj = 0;
32213 wxDataObject *arg1 = (wxDataObject *) 0 ;
32214 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32215 PyObject *result = 0 ;
32216 void *argp1 = 0 ;
32217 int res1 = 0 ;
32218 int val2 ;
32219 int ecode2 = 0 ;
32220 PyObject * obj0 = 0 ;
32221 PyObject * obj1 = 0 ;
32222 char * kwnames[] = {
32223 (char *) "self",(char *) "dir", NULL
32224 };
32225
32226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32228 if (!SWIG_IsOK(res1)) {
32229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32230 }
32231 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32232 if (obj1) {
32233 ecode2 = SWIG_AsVal_int(obj1, &val2);
32234 if (!SWIG_IsOK(ecode2)) {
32235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32236 }
32237 arg2 = static_cast< wxDataObject::Direction >(val2);
32238 }
32239 {
32240 PyThreadState* __tstate = wxPyBeginAllowThreads();
32241 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32242 wxPyEndAllowThreads(__tstate);
32243 if (PyErr_Occurred()) SWIG_fail;
32244 }
32245 resultobj = result;
32246 return resultobj;
32247 fail:
32248 return NULL;
32249 }
32250
32251
32252 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32253 PyObject *resultobj = 0;
32254 wxDataObject *arg1 = (wxDataObject *) 0 ;
32255 wxDataFormat *arg2 = 0 ;
32256 PyObject *result = 0 ;
32257 void *argp1 = 0 ;
32258 int res1 = 0 ;
32259 void *argp2 = 0 ;
32260 int res2 = 0 ;
32261 PyObject * obj0 = 0 ;
32262 PyObject * obj1 = 0 ;
32263 char * kwnames[] = {
32264 (char *) "self",(char *) "format", NULL
32265 };
32266
32267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32269 if (!SWIG_IsOK(res1)) {
32270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32271 }
32272 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32273 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32274 if (!SWIG_IsOK(res2)) {
32275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32276 }
32277 if (!argp2) {
32278 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32279 }
32280 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32281 {
32282 PyThreadState* __tstate = wxPyBeginAllowThreads();
32283 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
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_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32295 PyObject *resultobj = 0;
32296 wxDataObject *arg1 = (wxDataObject *) 0 ;
32297 wxDataFormat *arg2 = 0 ;
32298 PyObject *arg3 = (PyObject *) 0 ;
32299 bool result;
32300 void *argp1 = 0 ;
32301 int res1 = 0 ;
32302 void *argp2 = 0 ;
32303 int res2 = 0 ;
32304 PyObject * obj0 = 0 ;
32305 PyObject * obj1 = 0 ;
32306 PyObject * obj2 = 0 ;
32307 char * kwnames[] = {
32308 (char *) "self",(char *) "format",(char *) "data", NULL
32309 };
32310
32311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32313 if (!SWIG_IsOK(res1)) {
32314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32315 }
32316 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32317 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32318 if (!SWIG_IsOK(res2)) {
32319 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32320 }
32321 if (!argp2) {
32322 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32323 }
32324 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32325 arg3 = obj2;
32326 {
32327 PyThreadState* __tstate = wxPyBeginAllowThreads();
32328 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32329 wxPyEndAllowThreads(__tstate);
32330 if (PyErr_Occurred()) SWIG_fail;
32331 }
32332 {
32333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32334 }
32335 return resultobj;
32336 fail:
32337 return NULL;
32338 }
32339
32340
32341 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32342 PyObject *obj;
32343 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32344 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32345 return SWIG_Py_Void();
32346 }
32347
32348 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32349 PyObject *resultobj = 0;
32350 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32351 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32352 wxDataObjectSimple *result = 0 ;
32353 void *argp1 = 0 ;
32354 int res1 = 0 ;
32355 PyObject * obj0 = 0 ;
32356 char * kwnames[] = {
32357 (char *) "format", NULL
32358 };
32359
32360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32361 if (obj0) {
32362 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32363 if (!SWIG_IsOK(res1)) {
32364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32365 }
32366 if (!argp1) {
32367 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32368 }
32369 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32370 }
32371 {
32372 PyThreadState* __tstate = wxPyBeginAllowThreads();
32373 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32374 wxPyEndAllowThreads(__tstate);
32375 if (PyErr_Occurred()) SWIG_fail;
32376 }
32377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32378 return resultobj;
32379 fail:
32380 return NULL;
32381 }
32382
32383
32384 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32385 PyObject *resultobj = 0;
32386 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32387 wxDataFormat *result = 0 ;
32388 void *argp1 = 0 ;
32389 int res1 = 0 ;
32390 PyObject *swig_obj[1] ;
32391
32392 if (!args) SWIG_fail;
32393 swig_obj[0] = args;
32394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32395 if (!SWIG_IsOK(res1)) {
32396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32397 }
32398 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32399 {
32400 PyThreadState* __tstate = wxPyBeginAllowThreads();
32401 {
32402 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32403 result = (wxDataFormat *) &_result_ref;
32404 }
32405 wxPyEndAllowThreads(__tstate);
32406 if (PyErr_Occurred()) SWIG_fail;
32407 }
32408 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32409 return resultobj;
32410 fail:
32411 return NULL;
32412 }
32413
32414
32415 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32416 PyObject *resultobj = 0;
32417 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32418 wxDataFormat *arg2 = 0 ;
32419 void *argp1 = 0 ;
32420 int res1 = 0 ;
32421 void *argp2 = 0 ;
32422 int res2 = 0 ;
32423 PyObject * obj0 = 0 ;
32424 PyObject * obj1 = 0 ;
32425 char * kwnames[] = {
32426 (char *) "self",(char *) "format", NULL
32427 };
32428
32429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32431 if (!SWIG_IsOK(res1)) {
32432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32433 }
32434 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32435 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32436 if (!SWIG_IsOK(res2)) {
32437 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32438 }
32439 if (!argp2) {
32440 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32441 }
32442 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32443 {
32444 PyThreadState* __tstate = wxPyBeginAllowThreads();
32445 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32446 wxPyEndAllowThreads(__tstate);
32447 if (PyErr_Occurred()) SWIG_fail;
32448 }
32449 resultobj = SWIG_Py_Void();
32450 return resultobj;
32451 fail:
32452 return NULL;
32453 }
32454
32455
32456 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32457 PyObject *resultobj = 0;
32458 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32459 size_t result;
32460 void *argp1 = 0 ;
32461 int res1 = 0 ;
32462 PyObject *swig_obj[1] ;
32463
32464 if (!args) SWIG_fail;
32465 swig_obj[0] = args;
32466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32467 if (!SWIG_IsOK(res1)) {
32468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32469 }
32470 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32471 {
32472 PyThreadState* __tstate = wxPyBeginAllowThreads();
32473 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32474 wxPyEndAllowThreads(__tstate);
32475 if (PyErr_Occurred()) SWIG_fail;
32476 }
32477 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32478 return resultobj;
32479 fail:
32480 return NULL;
32481 }
32482
32483
32484 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32485 PyObject *resultobj = 0;
32486 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32487 PyObject *result = 0 ;
32488 void *argp1 = 0 ;
32489 int res1 = 0 ;
32490 PyObject *swig_obj[1] ;
32491
32492 if (!args) SWIG_fail;
32493 swig_obj[0] = args;
32494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32495 if (!SWIG_IsOK(res1)) {
32496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32497 }
32498 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32499 {
32500 PyThreadState* __tstate = wxPyBeginAllowThreads();
32501 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32502 wxPyEndAllowThreads(__tstate);
32503 if (PyErr_Occurred()) SWIG_fail;
32504 }
32505 resultobj = result;
32506 return resultobj;
32507 fail:
32508 return NULL;
32509 }
32510
32511
32512 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32513 PyObject *resultobj = 0;
32514 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32515 PyObject *arg2 = (PyObject *) 0 ;
32516 bool result;
32517 void *argp1 = 0 ;
32518 int res1 = 0 ;
32519 PyObject * obj0 = 0 ;
32520 PyObject * obj1 = 0 ;
32521 char * kwnames[] = {
32522 (char *) "self",(char *) "data", NULL
32523 };
32524
32525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32527 if (!SWIG_IsOK(res1)) {
32528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32529 }
32530 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32531 arg2 = obj1;
32532 {
32533 PyThreadState* __tstate = wxPyBeginAllowThreads();
32534 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32535 wxPyEndAllowThreads(__tstate);
32536 if (PyErr_Occurred()) SWIG_fail;
32537 }
32538 {
32539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32540 }
32541 return resultobj;
32542 fail:
32543 return NULL;
32544 }
32545
32546
32547 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32548 PyObject *obj;
32549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32550 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32551 return SWIG_Py_Void();
32552 }
32553
32554 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32555 return SWIG_Python_InitShadowInstance(args);
32556 }
32557
32558 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32559 PyObject *resultobj = 0;
32560 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32561 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32562 wxPyDataObjectSimple *result = 0 ;
32563 void *argp1 = 0 ;
32564 int res1 = 0 ;
32565 PyObject * obj0 = 0 ;
32566 char * kwnames[] = {
32567 (char *) "format", NULL
32568 };
32569
32570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32571 if (obj0) {
32572 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32573 if (!SWIG_IsOK(res1)) {
32574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32575 }
32576 if (!argp1) {
32577 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32578 }
32579 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32580 }
32581 {
32582 PyThreadState* __tstate = wxPyBeginAllowThreads();
32583 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32584 wxPyEndAllowThreads(__tstate);
32585 if (PyErr_Occurred()) SWIG_fail;
32586 }
32587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32588 return resultobj;
32589 fail:
32590 return NULL;
32591 }
32592
32593
32594 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32595 PyObject *resultobj = 0;
32596 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32597 PyObject *arg2 = (PyObject *) 0 ;
32598 PyObject *arg3 = (PyObject *) 0 ;
32599 void *argp1 = 0 ;
32600 int res1 = 0 ;
32601 PyObject * obj0 = 0 ;
32602 PyObject * obj1 = 0 ;
32603 PyObject * obj2 = 0 ;
32604 char * kwnames[] = {
32605 (char *) "self",(char *) "self",(char *) "_class", NULL
32606 };
32607
32608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32610 if (!SWIG_IsOK(res1)) {
32611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32612 }
32613 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32614 arg2 = obj1;
32615 arg3 = obj2;
32616 {
32617 PyThreadState* __tstate = wxPyBeginAllowThreads();
32618 (arg1)->_setCallbackInfo(arg2,arg3);
32619 wxPyEndAllowThreads(__tstate);
32620 if (PyErr_Occurred()) SWIG_fail;
32621 }
32622 resultobj = SWIG_Py_Void();
32623 return resultobj;
32624 fail:
32625 return NULL;
32626 }
32627
32628
32629 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32630 PyObject *obj;
32631 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32632 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32633 return SWIG_Py_Void();
32634 }
32635
32636 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32637 return SWIG_Python_InitShadowInstance(args);
32638 }
32639
32640 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32641 PyObject *resultobj = 0;
32642 wxDataObjectComposite *result = 0 ;
32643
32644 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32645 {
32646 PyThreadState* __tstate = wxPyBeginAllowThreads();
32647 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32648 wxPyEndAllowThreads(__tstate);
32649 if (PyErr_Occurred()) SWIG_fail;
32650 }
32651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32652 return resultobj;
32653 fail:
32654 return NULL;
32655 }
32656
32657
32658 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32659 PyObject *resultobj = 0;
32660 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32661 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32662 bool arg3 = (bool) false ;
32663 void *argp1 = 0 ;
32664 int res1 = 0 ;
32665 int res2 = 0 ;
32666 bool val3 ;
32667 int ecode3 = 0 ;
32668 PyObject * obj0 = 0 ;
32669 PyObject * obj1 = 0 ;
32670 PyObject * obj2 = 0 ;
32671 char * kwnames[] = {
32672 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32673 };
32674
32675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32677 if (!SWIG_IsOK(res1)) {
32678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32679 }
32680 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32681 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32682 if (!SWIG_IsOK(res2)) {
32683 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32684 }
32685 if (obj2) {
32686 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32687 if (!SWIG_IsOK(ecode3)) {
32688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32689 }
32690 arg3 = static_cast< bool >(val3);
32691 }
32692 {
32693 PyThreadState* __tstate = wxPyBeginAllowThreads();
32694 (arg1)->Add(arg2,arg3);
32695 wxPyEndAllowThreads(__tstate);
32696 if (PyErr_Occurred()) SWIG_fail;
32697 }
32698 resultobj = SWIG_Py_Void();
32699 return resultobj;
32700 fail:
32701 return NULL;
32702 }
32703
32704
32705 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32706 PyObject *resultobj = 0;
32707 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32708 SwigValueWrapper<wxDataFormat > result;
32709 void *argp1 = 0 ;
32710 int res1 = 0 ;
32711 PyObject *swig_obj[1] ;
32712
32713 if (!args) SWIG_fail;
32714 swig_obj[0] = args;
32715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32716 if (!SWIG_IsOK(res1)) {
32717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32718 }
32719 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32720 {
32721 PyThreadState* __tstate = wxPyBeginAllowThreads();
32722 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32723 wxPyEndAllowThreads(__tstate);
32724 if (PyErr_Occurred()) SWIG_fail;
32725 }
32726 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32727 return resultobj;
32728 fail:
32729 return NULL;
32730 }
32731
32732
32733 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32734 PyObject *obj;
32735 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32736 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32737 return SWIG_Py_Void();
32738 }
32739
32740 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32741 return SWIG_Python_InitShadowInstance(args);
32742 }
32743
32744 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32745 PyObject *resultobj = 0;
32746 wxString const &arg1_defvalue = wxPyEmptyString ;
32747 wxString *arg1 = (wxString *) &arg1_defvalue ;
32748 wxTextDataObject *result = 0 ;
32749 bool temp1 = false ;
32750 PyObject * obj0 = 0 ;
32751 char * kwnames[] = {
32752 (char *) "text", NULL
32753 };
32754
32755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32756 if (obj0) {
32757 {
32758 arg1 = wxString_in_helper(obj0);
32759 if (arg1 == NULL) SWIG_fail;
32760 temp1 = true;
32761 }
32762 }
32763 {
32764 PyThreadState* __tstate = wxPyBeginAllowThreads();
32765 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32766 wxPyEndAllowThreads(__tstate);
32767 if (PyErr_Occurred()) SWIG_fail;
32768 }
32769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32770 {
32771 if (temp1)
32772 delete arg1;
32773 }
32774 return resultobj;
32775 fail:
32776 {
32777 if (temp1)
32778 delete arg1;
32779 }
32780 return NULL;
32781 }
32782
32783
32784 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32785 PyObject *resultobj = 0;
32786 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32787 size_t result;
32788 void *argp1 = 0 ;
32789 int res1 = 0 ;
32790 PyObject *swig_obj[1] ;
32791
32792 if (!args) SWIG_fail;
32793 swig_obj[0] = args;
32794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32795 if (!SWIG_IsOK(res1)) {
32796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32797 }
32798 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32799 {
32800 PyThreadState* __tstate = wxPyBeginAllowThreads();
32801 result = (size_t)(arg1)->GetTextLength();
32802 wxPyEndAllowThreads(__tstate);
32803 if (PyErr_Occurred()) SWIG_fail;
32804 }
32805 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32806 return resultobj;
32807 fail:
32808 return NULL;
32809 }
32810
32811
32812 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32813 PyObject *resultobj = 0;
32814 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32815 wxString result;
32816 void *argp1 = 0 ;
32817 int res1 = 0 ;
32818 PyObject *swig_obj[1] ;
32819
32820 if (!args) SWIG_fail;
32821 swig_obj[0] = args;
32822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32823 if (!SWIG_IsOK(res1)) {
32824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32825 }
32826 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32827 {
32828 PyThreadState* __tstate = wxPyBeginAllowThreads();
32829 result = (arg1)->GetText();
32830 wxPyEndAllowThreads(__tstate);
32831 if (PyErr_Occurred()) SWIG_fail;
32832 }
32833 {
32834 #if wxUSE_UNICODE
32835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32836 #else
32837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32838 #endif
32839 }
32840 return resultobj;
32841 fail:
32842 return NULL;
32843 }
32844
32845
32846 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32847 PyObject *resultobj = 0;
32848 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32849 wxString *arg2 = 0 ;
32850 void *argp1 = 0 ;
32851 int res1 = 0 ;
32852 bool temp2 = false ;
32853 PyObject * obj0 = 0 ;
32854 PyObject * obj1 = 0 ;
32855 char * kwnames[] = {
32856 (char *) "self",(char *) "text", NULL
32857 };
32858
32859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32861 if (!SWIG_IsOK(res1)) {
32862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32863 }
32864 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32865 {
32866 arg2 = wxString_in_helper(obj1);
32867 if (arg2 == NULL) SWIG_fail;
32868 temp2 = true;
32869 }
32870 {
32871 PyThreadState* __tstate = wxPyBeginAllowThreads();
32872 (arg1)->SetText((wxString const &)*arg2);
32873 wxPyEndAllowThreads(__tstate);
32874 if (PyErr_Occurred()) SWIG_fail;
32875 }
32876 resultobj = SWIG_Py_Void();
32877 {
32878 if (temp2)
32879 delete arg2;
32880 }
32881 return resultobj;
32882 fail:
32883 {
32884 if (temp2)
32885 delete arg2;
32886 }
32887 return NULL;
32888 }
32889
32890
32891 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32892 PyObject *obj;
32893 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32894 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32895 return SWIG_Py_Void();
32896 }
32897
32898 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32899 return SWIG_Python_InitShadowInstance(args);
32900 }
32901
32902 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32903 PyObject *resultobj = 0;
32904 wxString const &arg1_defvalue = wxPyEmptyString ;
32905 wxString *arg1 = (wxString *) &arg1_defvalue ;
32906 wxPyTextDataObject *result = 0 ;
32907 bool temp1 = false ;
32908 PyObject * obj0 = 0 ;
32909 char * kwnames[] = {
32910 (char *) "text", NULL
32911 };
32912
32913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32914 if (obj0) {
32915 {
32916 arg1 = wxString_in_helper(obj0);
32917 if (arg1 == NULL) SWIG_fail;
32918 temp1 = true;
32919 }
32920 }
32921 {
32922 PyThreadState* __tstate = wxPyBeginAllowThreads();
32923 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32924 wxPyEndAllowThreads(__tstate);
32925 if (PyErr_Occurred()) SWIG_fail;
32926 }
32927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32928 {
32929 if (temp1)
32930 delete arg1;
32931 }
32932 return resultobj;
32933 fail:
32934 {
32935 if (temp1)
32936 delete arg1;
32937 }
32938 return NULL;
32939 }
32940
32941
32942 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32943 PyObject *resultobj = 0;
32944 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32945 PyObject *arg2 = (PyObject *) 0 ;
32946 PyObject *arg3 = (PyObject *) 0 ;
32947 void *argp1 = 0 ;
32948 int res1 = 0 ;
32949 PyObject * obj0 = 0 ;
32950 PyObject * obj1 = 0 ;
32951 PyObject * obj2 = 0 ;
32952 char * kwnames[] = {
32953 (char *) "self",(char *) "self",(char *) "_class", NULL
32954 };
32955
32956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32958 if (!SWIG_IsOK(res1)) {
32959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32960 }
32961 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32962 arg2 = obj1;
32963 arg3 = obj2;
32964 {
32965 PyThreadState* __tstate = wxPyBeginAllowThreads();
32966 (arg1)->_setCallbackInfo(arg2,arg3);
32967 wxPyEndAllowThreads(__tstate);
32968 if (PyErr_Occurred()) SWIG_fail;
32969 }
32970 resultobj = SWIG_Py_Void();
32971 return resultobj;
32972 fail:
32973 return NULL;
32974 }
32975
32976
32977 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32978 PyObject *obj;
32979 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32980 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32981 return SWIG_Py_Void();
32982 }
32983
32984 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32985 return SWIG_Python_InitShadowInstance(args);
32986 }
32987
32988 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32989 PyObject *resultobj = 0;
32990 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32991 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32992 wxBitmapDataObject *result = 0 ;
32993 void *argp1 = 0 ;
32994 int res1 = 0 ;
32995 PyObject * obj0 = 0 ;
32996 char * kwnames[] = {
32997 (char *) "bitmap", NULL
32998 };
32999
33000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
33001 if (obj0) {
33002 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33003 if (!SWIG_IsOK(res1)) {
33004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33005 }
33006 if (!argp1) {
33007 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33008 }
33009 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33010 }
33011 {
33012 PyThreadState* __tstate = wxPyBeginAllowThreads();
33013 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
33014 wxPyEndAllowThreads(__tstate);
33015 if (PyErr_Occurred()) SWIG_fail;
33016 }
33017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
33018 return resultobj;
33019 fail:
33020 return NULL;
33021 }
33022
33023
33024 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33025 PyObject *resultobj = 0;
33026 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33027 wxBitmap result;
33028 void *argp1 = 0 ;
33029 int res1 = 0 ;
33030 PyObject *swig_obj[1] ;
33031
33032 if (!args) SWIG_fail;
33033 swig_obj[0] = args;
33034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33035 if (!SWIG_IsOK(res1)) {
33036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33037 }
33038 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33039 {
33040 PyThreadState* __tstate = wxPyBeginAllowThreads();
33041 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33042 wxPyEndAllowThreads(__tstate);
33043 if (PyErr_Occurred()) SWIG_fail;
33044 }
33045 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33046 return resultobj;
33047 fail:
33048 return NULL;
33049 }
33050
33051
33052 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33053 PyObject *resultobj = 0;
33054 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33055 wxBitmap *arg2 = 0 ;
33056 void *argp1 = 0 ;
33057 int res1 = 0 ;
33058 void *argp2 = 0 ;
33059 int res2 = 0 ;
33060 PyObject * obj0 = 0 ;
33061 PyObject * obj1 = 0 ;
33062 char * kwnames[] = {
33063 (char *) "self",(char *) "bitmap", NULL
33064 };
33065
33066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33068 if (!SWIG_IsOK(res1)) {
33069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33070 }
33071 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33072 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33073 if (!SWIG_IsOK(res2)) {
33074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33075 }
33076 if (!argp2) {
33077 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33078 }
33079 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33080 {
33081 PyThreadState* __tstate = wxPyBeginAllowThreads();
33082 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33083 wxPyEndAllowThreads(__tstate);
33084 if (PyErr_Occurred()) SWIG_fail;
33085 }
33086 resultobj = SWIG_Py_Void();
33087 return resultobj;
33088 fail:
33089 return NULL;
33090 }
33091
33092
33093 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33094 PyObject *obj;
33095 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33096 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33097 return SWIG_Py_Void();
33098 }
33099
33100 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33101 return SWIG_Python_InitShadowInstance(args);
33102 }
33103
33104 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33105 PyObject *resultobj = 0;
33106 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33107 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33108 wxPyBitmapDataObject *result = 0 ;
33109 void *argp1 = 0 ;
33110 int res1 = 0 ;
33111 PyObject * obj0 = 0 ;
33112 char * kwnames[] = {
33113 (char *) "bitmap", NULL
33114 };
33115
33116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33117 if (obj0) {
33118 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33119 if (!SWIG_IsOK(res1)) {
33120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33121 }
33122 if (!argp1) {
33123 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33124 }
33125 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33126 }
33127 {
33128 PyThreadState* __tstate = wxPyBeginAllowThreads();
33129 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33130 wxPyEndAllowThreads(__tstate);
33131 if (PyErr_Occurred()) SWIG_fail;
33132 }
33133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33134 return resultobj;
33135 fail:
33136 return NULL;
33137 }
33138
33139
33140 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33141 PyObject *resultobj = 0;
33142 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33143 PyObject *arg2 = (PyObject *) 0 ;
33144 PyObject *arg3 = (PyObject *) 0 ;
33145 void *argp1 = 0 ;
33146 int res1 = 0 ;
33147 PyObject * obj0 = 0 ;
33148 PyObject * obj1 = 0 ;
33149 PyObject * obj2 = 0 ;
33150 char * kwnames[] = {
33151 (char *) "self",(char *) "self",(char *) "_class", NULL
33152 };
33153
33154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33156 if (!SWIG_IsOK(res1)) {
33157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33158 }
33159 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33160 arg2 = obj1;
33161 arg3 = obj2;
33162 {
33163 PyThreadState* __tstate = wxPyBeginAllowThreads();
33164 (arg1)->_setCallbackInfo(arg2,arg3);
33165 wxPyEndAllowThreads(__tstate);
33166 if (PyErr_Occurred()) SWIG_fail;
33167 }
33168 resultobj = SWIG_Py_Void();
33169 return resultobj;
33170 fail:
33171 return NULL;
33172 }
33173
33174
33175 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33176 PyObject *obj;
33177 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33178 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33179 return SWIG_Py_Void();
33180 }
33181
33182 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33183 return SWIG_Python_InitShadowInstance(args);
33184 }
33185
33186 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33187 PyObject *resultobj = 0;
33188 wxFileDataObject *result = 0 ;
33189
33190 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33191 {
33192 PyThreadState* __tstate = wxPyBeginAllowThreads();
33193 result = (wxFileDataObject *)new wxFileDataObject();
33194 wxPyEndAllowThreads(__tstate);
33195 if (PyErr_Occurred()) SWIG_fail;
33196 }
33197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33198 return resultobj;
33199 fail:
33200 return NULL;
33201 }
33202
33203
33204 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33205 PyObject *resultobj = 0;
33206 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33207 wxArrayString *result = 0 ;
33208 void *argp1 = 0 ;
33209 int res1 = 0 ;
33210 PyObject *swig_obj[1] ;
33211
33212 if (!args) SWIG_fail;
33213 swig_obj[0] = args;
33214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33215 if (!SWIG_IsOK(res1)) {
33216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33217 }
33218 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33219 {
33220 PyThreadState* __tstate = wxPyBeginAllowThreads();
33221 {
33222 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33223 result = (wxArrayString *) &_result_ref;
33224 }
33225 wxPyEndAllowThreads(__tstate);
33226 if (PyErr_Occurred()) SWIG_fail;
33227 }
33228 {
33229 resultobj = wxArrayString2PyList_helper(*result);
33230 }
33231 return resultobj;
33232 fail:
33233 return NULL;
33234 }
33235
33236
33237 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33238 PyObject *resultobj = 0;
33239 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33240 wxString *arg2 = 0 ;
33241 void *argp1 = 0 ;
33242 int res1 = 0 ;
33243 bool temp2 = false ;
33244 PyObject * obj0 = 0 ;
33245 PyObject * obj1 = 0 ;
33246 char * kwnames[] = {
33247 (char *) "self",(char *) "filename", NULL
33248 };
33249
33250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33252 if (!SWIG_IsOK(res1)) {
33253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33254 }
33255 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33256 {
33257 arg2 = wxString_in_helper(obj1);
33258 if (arg2 == NULL) SWIG_fail;
33259 temp2 = true;
33260 }
33261 {
33262 PyThreadState* __tstate = wxPyBeginAllowThreads();
33263 (arg1)->AddFile((wxString const &)*arg2);
33264 wxPyEndAllowThreads(__tstate);
33265 if (PyErr_Occurred()) SWIG_fail;
33266 }
33267 resultobj = SWIG_Py_Void();
33268 {
33269 if (temp2)
33270 delete arg2;
33271 }
33272 return resultobj;
33273 fail:
33274 {
33275 if (temp2)
33276 delete arg2;
33277 }
33278 return NULL;
33279 }
33280
33281
33282 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33283 PyObject *obj;
33284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33285 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33286 return SWIG_Py_Void();
33287 }
33288
33289 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33290 return SWIG_Python_InitShadowInstance(args);
33291 }
33292
33293 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33294 PyObject *resultobj = 0;
33295 wxDataFormat *arg1 = 0 ;
33296 wxCustomDataObject *result = 0 ;
33297 void *argp1 = 0 ;
33298 int res1 = 0 ;
33299
33300 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33302 if (!SWIG_IsOK(res1)) {
33303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33304 }
33305 if (!argp1) {
33306 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33307 }
33308 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33309 {
33310 PyThreadState* __tstate = wxPyBeginAllowThreads();
33311 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33312 wxPyEndAllowThreads(__tstate);
33313 if (PyErr_Occurred()) SWIG_fail;
33314 }
33315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33316 return resultobj;
33317 fail:
33318 return NULL;
33319 }
33320
33321
33322 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33323 PyObject *resultobj = 0;
33324 wxString *arg1 = 0 ;
33325 wxCustomDataObject *result = 0 ;
33326 bool temp1 = false ;
33327
33328 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33329 {
33330 arg1 = wxString_in_helper(swig_obj[0]);
33331 if (arg1 == NULL) SWIG_fail;
33332 temp1 = true;
33333 }
33334 {
33335 PyThreadState* __tstate = wxPyBeginAllowThreads();
33336 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33337 wxPyEndAllowThreads(__tstate);
33338 if (PyErr_Occurred()) SWIG_fail;
33339 }
33340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33341 {
33342 if (temp1)
33343 delete arg1;
33344 }
33345 return resultobj;
33346 fail:
33347 {
33348 if (temp1)
33349 delete arg1;
33350 }
33351 return NULL;
33352 }
33353
33354
33355 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33356 PyObject *resultobj = 0;
33357 wxCustomDataObject *result = 0 ;
33358
33359 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33360 {
33361 PyThreadState* __tstate = wxPyBeginAllowThreads();
33362 result = (wxCustomDataObject *)new wxCustomDataObject();
33363 wxPyEndAllowThreads(__tstate);
33364 if (PyErr_Occurred()) SWIG_fail;
33365 }
33366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33367 return resultobj;
33368 fail:
33369 return NULL;
33370 }
33371
33372
33373 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33374 int argc;
33375 PyObject *argv[2];
33376
33377 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33378 --argc;
33379 if (argc == 0) {
33380 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33381 }
33382 if (argc == 1) {
33383 int _v = 0;
33384 {
33385 {
33386 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33387 }
33388 }
33389 if (!_v) goto check_2;
33390 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33391 }
33392 check_2:
33393
33394 if (argc == 1) {
33395 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33396 }
33397
33398 fail:
33399 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33400 return NULL;
33401 }
33402
33403
33404 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33405 PyObject *resultobj = 0;
33406 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33407 PyObject *arg2 = (PyObject *) 0 ;
33408 bool result;
33409 void *argp1 = 0 ;
33410 int res1 = 0 ;
33411 PyObject * obj0 = 0 ;
33412 PyObject * obj1 = 0 ;
33413 char * kwnames[] = {
33414 (char *) "self",(char *) "data", NULL
33415 };
33416
33417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33419 if (!SWIG_IsOK(res1)) {
33420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33421 }
33422 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33423 arg2 = obj1;
33424 {
33425 PyThreadState* __tstate = wxPyBeginAllowThreads();
33426 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33427 wxPyEndAllowThreads(__tstate);
33428 if (PyErr_Occurred()) SWIG_fail;
33429 }
33430 {
33431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33432 }
33433 return resultobj;
33434 fail:
33435 return NULL;
33436 }
33437
33438
33439 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33440 PyObject *resultobj = 0;
33441 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33442 size_t result;
33443 void *argp1 = 0 ;
33444 int res1 = 0 ;
33445 PyObject *swig_obj[1] ;
33446
33447 if (!args) SWIG_fail;
33448 swig_obj[0] = args;
33449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33450 if (!SWIG_IsOK(res1)) {
33451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33452 }
33453 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33454 {
33455 PyThreadState* __tstate = wxPyBeginAllowThreads();
33456 result = (size_t)(arg1)->GetSize();
33457 wxPyEndAllowThreads(__tstate);
33458 if (PyErr_Occurred()) SWIG_fail;
33459 }
33460 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33461 return resultobj;
33462 fail:
33463 return NULL;
33464 }
33465
33466
33467 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33468 PyObject *resultobj = 0;
33469 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33470 PyObject *result = 0 ;
33471 void *argp1 = 0 ;
33472 int res1 = 0 ;
33473 PyObject *swig_obj[1] ;
33474
33475 if (!args) SWIG_fail;
33476 swig_obj[0] = args;
33477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33478 if (!SWIG_IsOK(res1)) {
33479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33480 }
33481 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33482 {
33483 PyThreadState* __tstate = wxPyBeginAllowThreads();
33484 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33485 wxPyEndAllowThreads(__tstate);
33486 if (PyErr_Occurred()) SWIG_fail;
33487 }
33488 resultobj = result;
33489 return resultobj;
33490 fail:
33491 return NULL;
33492 }
33493
33494
33495 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33496 PyObject *obj;
33497 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33498 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33499 return SWIG_Py_Void();
33500 }
33501
33502 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33503 return SWIG_Python_InitShadowInstance(args);
33504 }
33505
33506 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33507 PyObject *resultobj = 0;
33508 wxString const &arg1_defvalue = wxPyEmptyString ;
33509 wxString *arg1 = (wxString *) &arg1_defvalue ;
33510 wxURLDataObject *result = 0 ;
33511 bool temp1 = false ;
33512 PyObject * obj0 = 0 ;
33513 char * kwnames[] = {
33514 (char *) "url", NULL
33515 };
33516
33517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33518 if (obj0) {
33519 {
33520 arg1 = wxString_in_helper(obj0);
33521 if (arg1 == NULL) SWIG_fail;
33522 temp1 = true;
33523 }
33524 }
33525 {
33526 PyThreadState* __tstate = wxPyBeginAllowThreads();
33527 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33528 wxPyEndAllowThreads(__tstate);
33529 if (PyErr_Occurred()) SWIG_fail;
33530 }
33531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33532 {
33533 if (temp1)
33534 delete arg1;
33535 }
33536 return resultobj;
33537 fail:
33538 {
33539 if (temp1)
33540 delete arg1;
33541 }
33542 return NULL;
33543 }
33544
33545
33546 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33547 PyObject *resultobj = 0;
33548 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33549 wxString result;
33550 void *argp1 = 0 ;
33551 int res1 = 0 ;
33552 PyObject *swig_obj[1] ;
33553
33554 if (!args) SWIG_fail;
33555 swig_obj[0] = args;
33556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33557 if (!SWIG_IsOK(res1)) {
33558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33559 }
33560 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33561 {
33562 PyThreadState* __tstate = wxPyBeginAllowThreads();
33563 result = (arg1)->GetURL();
33564 wxPyEndAllowThreads(__tstate);
33565 if (PyErr_Occurred()) SWIG_fail;
33566 }
33567 {
33568 #if wxUSE_UNICODE
33569 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33570 #else
33571 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33572 #endif
33573 }
33574 return resultobj;
33575 fail:
33576 return NULL;
33577 }
33578
33579
33580 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33581 PyObject *resultobj = 0;
33582 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33583 wxString *arg2 = 0 ;
33584 void *argp1 = 0 ;
33585 int res1 = 0 ;
33586 bool temp2 = false ;
33587 PyObject * obj0 = 0 ;
33588 PyObject * obj1 = 0 ;
33589 char * kwnames[] = {
33590 (char *) "self",(char *) "url", NULL
33591 };
33592
33593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33595 if (!SWIG_IsOK(res1)) {
33596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33597 }
33598 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33599 {
33600 arg2 = wxString_in_helper(obj1);
33601 if (arg2 == NULL) SWIG_fail;
33602 temp2 = true;
33603 }
33604 {
33605 PyThreadState* __tstate = wxPyBeginAllowThreads();
33606 (arg1)->SetURL((wxString const &)*arg2);
33607 wxPyEndAllowThreads(__tstate);
33608 if (PyErr_Occurred()) SWIG_fail;
33609 }
33610 resultobj = SWIG_Py_Void();
33611 {
33612 if (temp2)
33613 delete arg2;
33614 }
33615 return resultobj;
33616 fail:
33617 {
33618 if (temp2)
33619 delete arg2;
33620 }
33621 return NULL;
33622 }
33623
33624
33625 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33626 PyObject *obj;
33627 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33628 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33629 return SWIG_Py_Void();
33630 }
33631
33632 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33633 return SWIG_Python_InitShadowInstance(args);
33634 }
33635
33636 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33637 PyObject *resultobj = 0;
33638 wxMetafileDataObject *result = 0 ;
33639
33640 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33641 {
33642 PyThreadState* __tstate = wxPyBeginAllowThreads();
33643 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33644 wxPyEndAllowThreads(__tstate);
33645 if (PyErr_Occurred()) SWIG_fail;
33646 }
33647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33648 return resultobj;
33649 fail:
33650 return NULL;
33651 }
33652
33653
33654 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33655 PyObject *resultobj = 0;
33656 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33657 wxMetafile *arg2 = 0 ;
33658 void *argp1 = 0 ;
33659 int res1 = 0 ;
33660 void *argp2 = 0 ;
33661 int res2 = 0 ;
33662 PyObject * obj0 = 0 ;
33663 PyObject * obj1 = 0 ;
33664 char * kwnames[] = {
33665 (char *) "self",(char *) "metafile", NULL
33666 };
33667
33668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
33669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33670 if (!SWIG_IsOK(res1)) {
33671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
33672 }
33673 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33674 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
33675 if (!SWIG_IsOK(res2)) {
33676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33677 }
33678 if (!argp2) {
33679 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33680 }
33681 arg2 = reinterpret_cast< wxMetafile * >(argp2);
33682 {
33683 PyThreadState* __tstate = wxPyBeginAllowThreads();
33684 (arg1)->SetMetafile((wxMetafile const &)*arg2);
33685 wxPyEndAllowThreads(__tstate);
33686 if (PyErr_Occurred()) SWIG_fail;
33687 }
33688 resultobj = SWIG_Py_Void();
33689 return resultobj;
33690 fail:
33691 return NULL;
33692 }
33693
33694
33695 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33696 PyObject *resultobj = 0;
33697 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33698 wxMetafile result;
33699 void *argp1 = 0 ;
33700 int res1 = 0 ;
33701 PyObject *swig_obj[1] ;
33702
33703 if (!args) SWIG_fail;
33704 swig_obj[0] = args;
33705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33706 if (!SWIG_IsOK(res1)) {
33707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
33708 }
33709 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33710 {
33711 PyThreadState* __tstate = wxPyBeginAllowThreads();
33712 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
33713 wxPyEndAllowThreads(__tstate);
33714 if (PyErr_Occurred()) SWIG_fail;
33715 }
33716 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
33717 return resultobj;
33718 fail:
33719 return NULL;
33720 }
33721
33722
33723 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33724 PyObject *obj;
33725 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33726 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33727 return SWIG_Py_Void();
33728 }
33729
33730 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33731 return SWIG_Python_InitShadowInstance(args);
33732 }
33733
33734 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33735 PyObject *resultobj = 0;
33736 wxDragResult arg1 ;
33737 bool result;
33738 int val1 ;
33739 int ecode1 = 0 ;
33740 PyObject * obj0 = 0 ;
33741 char * kwnames[] = {
33742 (char *) "res", NULL
33743 };
33744
33745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33746 ecode1 = SWIG_AsVal_int(obj0, &val1);
33747 if (!SWIG_IsOK(ecode1)) {
33748 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33749 }
33750 arg1 = static_cast< wxDragResult >(val1);
33751 {
33752 PyThreadState* __tstate = wxPyBeginAllowThreads();
33753 result = (bool)wxIsDragResultOk(arg1);
33754 wxPyEndAllowThreads(__tstate);
33755 if (PyErr_Occurred()) SWIG_fail;
33756 }
33757 {
33758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33759 }
33760 return resultobj;
33761 fail:
33762 return NULL;
33763 }
33764
33765
33766 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33767 PyObject *resultobj = 0;
33768 wxWindow *arg1 = (wxWindow *) 0 ;
33769 wxCursor const &arg2_defvalue = wxNullCursor ;
33770 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
33771 wxCursor const &arg3_defvalue = wxNullCursor ;
33772 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
33773 wxCursor const &arg4_defvalue = wxNullCursor ;
33774 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
33775 wxPyDropSource *result = 0 ;
33776 void *argp1 = 0 ;
33777 int res1 = 0 ;
33778 void *argp2 = 0 ;
33779 int res2 = 0 ;
33780 void *argp3 = 0 ;
33781 int res3 = 0 ;
33782 void *argp4 = 0 ;
33783 int res4 = 0 ;
33784 PyObject * obj0 = 0 ;
33785 PyObject * obj1 = 0 ;
33786 PyObject * obj2 = 0 ;
33787 PyObject * obj3 = 0 ;
33788 char * kwnames[] = {
33789 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33790 };
33791
33792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33794 if (!SWIG_IsOK(res1)) {
33795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33796 }
33797 arg1 = reinterpret_cast< wxWindow * >(argp1);
33798 if (obj1) {
33799 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
33800 if (!SWIG_IsOK(res2)) {
33801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33802 }
33803 if (!argp2) {
33804 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33805 }
33806 arg2 = reinterpret_cast< wxCursor * >(argp2);
33807 }
33808 if (obj2) {
33809 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33810 if (!SWIG_IsOK(res3)) {
33811 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33812 }
33813 if (!argp3) {
33814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33815 }
33816 arg3 = reinterpret_cast< wxCursor * >(argp3);
33817 }
33818 if (obj3) {
33819 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
33820 if (!SWIG_IsOK(res4)) {
33821 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33822 }
33823 if (!argp4) {
33824 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33825 }
33826 arg4 = reinterpret_cast< wxCursor * >(argp4);
33827 }
33828 {
33829 PyThreadState* __tstate = wxPyBeginAllowThreads();
33830 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
33831 wxPyEndAllowThreads(__tstate);
33832 if (PyErr_Occurred()) SWIG_fail;
33833 }
33834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33835 return resultobj;
33836 fail:
33837 return NULL;
33838 }
33839
33840
33841 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33842 PyObject *resultobj = 0;
33843 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33844 PyObject *arg2 = (PyObject *) 0 ;
33845 PyObject *arg3 = (PyObject *) 0 ;
33846 int arg4 ;
33847 void *argp1 = 0 ;
33848 int res1 = 0 ;
33849 int val4 ;
33850 int ecode4 = 0 ;
33851 PyObject * obj0 = 0 ;
33852 PyObject * obj1 = 0 ;
33853 PyObject * obj2 = 0 ;
33854 PyObject * obj3 = 0 ;
33855 char * kwnames[] = {
33856 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33857 };
33858
33859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33861 if (!SWIG_IsOK(res1)) {
33862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33863 }
33864 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33865 arg2 = obj1;
33866 arg3 = obj2;
33867 ecode4 = SWIG_AsVal_int(obj3, &val4);
33868 if (!SWIG_IsOK(ecode4)) {
33869 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33870 }
33871 arg4 = static_cast< int >(val4);
33872 {
33873 PyThreadState* __tstate = wxPyBeginAllowThreads();
33874 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33875 wxPyEndAllowThreads(__tstate);
33876 if (PyErr_Occurred()) SWIG_fail;
33877 }
33878 resultobj = SWIG_Py_Void();
33879 return resultobj;
33880 fail:
33881 return NULL;
33882 }
33883
33884
33885 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33886 PyObject *resultobj = 0;
33887 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33888 void *argp1 = 0 ;
33889 int res1 = 0 ;
33890 PyObject *swig_obj[1] ;
33891
33892 if (!args) SWIG_fail;
33893 swig_obj[0] = args;
33894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33895 if (!SWIG_IsOK(res1)) {
33896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33897 }
33898 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33899 {
33900 PyThreadState* __tstate = wxPyBeginAllowThreads();
33901 delete arg1;
33902
33903 wxPyEndAllowThreads(__tstate);
33904 if (PyErr_Occurred()) SWIG_fail;
33905 }
33906 resultobj = SWIG_Py_Void();
33907 return resultobj;
33908 fail:
33909 return NULL;
33910 }
33911
33912
33913 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33914 PyObject *resultobj = 0;
33915 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33916 wxDataObject *arg2 = 0 ;
33917 void *argp1 = 0 ;
33918 int res1 = 0 ;
33919 void *argp2 = 0 ;
33920 int res2 = 0 ;
33921 PyObject * obj0 = 0 ;
33922 PyObject * obj1 = 0 ;
33923 char * kwnames[] = {
33924 (char *) "self",(char *) "data", NULL
33925 };
33926
33927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33929 if (!SWIG_IsOK(res1)) {
33930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33931 }
33932 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33933 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33934 if (!SWIG_IsOK(res2)) {
33935 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33936 }
33937 if (!argp2) {
33938 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33939 }
33940 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33941 {
33942 PyThreadState* __tstate = wxPyBeginAllowThreads();
33943 (arg1)->SetData(*arg2);
33944 wxPyEndAllowThreads(__tstate);
33945 if (PyErr_Occurred()) SWIG_fail;
33946 }
33947 resultobj = SWIG_Py_Void();
33948 return resultobj;
33949 fail:
33950 return NULL;
33951 }
33952
33953
33954 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33955 PyObject *resultobj = 0;
33956 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33957 wxDataObject *result = 0 ;
33958 void *argp1 = 0 ;
33959 int res1 = 0 ;
33960 PyObject *swig_obj[1] ;
33961
33962 if (!args) SWIG_fail;
33963 swig_obj[0] = args;
33964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33965 if (!SWIG_IsOK(res1)) {
33966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33967 }
33968 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33969 {
33970 PyThreadState* __tstate = wxPyBeginAllowThreads();
33971 result = (wxDataObject *)(arg1)->GetDataObject();
33972 wxPyEndAllowThreads(__tstate);
33973 if (PyErr_Occurred()) SWIG_fail;
33974 }
33975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33976 return resultobj;
33977 fail:
33978 return NULL;
33979 }
33980
33981
33982 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33983 PyObject *resultobj = 0;
33984 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33985 wxDragResult arg2 ;
33986 wxCursor *arg3 = 0 ;
33987 void *argp1 = 0 ;
33988 int res1 = 0 ;
33989 int val2 ;
33990 int ecode2 = 0 ;
33991 void *argp3 = 0 ;
33992 int res3 = 0 ;
33993 PyObject * obj0 = 0 ;
33994 PyObject * obj1 = 0 ;
33995 PyObject * obj2 = 0 ;
33996 char * kwnames[] = {
33997 (char *) "self",(char *) "res",(char *) "cursor", NULL
33998 };
33999
34000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34002 if (!SWIG_IsOK(res1)) {
34003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34004 }
34005 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34006 ecode2 = SWIG_AsVal_int(obj1, &val2);
34007 if (!SWIG_IsOK(ecode2)) {
34008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
34009 }
34010 arg2 = static_cast< wxDragResult >(val2);
34011 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
34012 if (!SWIG_IsOK(res3)) {
34013 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34014 }
34015 if (!argp3) {
34016 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34017 }
34018 arg3 = reinterpret_cast< wxCursor * >(argp3);
34019 {
34020 PyThreadState* __tstate = wxPyBeginAllowThreads();
34021 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
34022 wxPyEndAllowThreads(__tstate);
34023 if (PyErr_Occurred()) SWIG_fail;
34024 }
34025 resultobj = SWIG_Py_Void();
34026 return resultobj;
34027 fail:
34028 return NULL;
34029 }
34030
34031
34032 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34033 PyObject *resultobj = 0;
34034 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34035 int arg2 = (int) wxDrag_CopyOnly ;
34036 wxDragResult result;
34037 void *argp1 = 0 ;
34038 int res1 = 0 ;
34039 int val2 ;
34040 int ecode2 = 0 ;
34041 PyObject * obj0 = 0 ;
34042 PyObject * obj1 = 0 ;
34043 char * kwnames[] = {
34044 (char *) "self",(char *) "flags", NULL
34045 };
34046
34047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
34048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34049 if (!SWIG_IsOK(res1)) {
34050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34051 }
34052 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34053 if (obj1) {
34054 ecode2 = SWIG_AsVal_int(obj1, &val2);
34055 if (!SWIG_IsOK(ecode2)) {
34056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
34057 }
34058 arg2 = static_cast< int >(val2);
34059 }
34060 {
34061 PyThreadState* __tstate = wxPyBeginAllowThreads();
34062 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34063 wxPyEndAllowThreads(__tstate);
34064 if (PyErr_Occurred()) SWIG_fail;
34065 }
34066 resultobj = SWIG_From_int(static_cast< int >(result));
34067 return resultobj;
34068 fail:
34069 return NULL;
34070 }
34071
34072
34073 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34074 PyObject *resultobj = 0;
34075 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34076 wxDragResult arg2 ;
34077 bool result;
34078 void *argp1 = 0 ;
34079 int res1 = 0 ;
34080 int val2 ;
34081 int ecode2 = 0 ;
34082 PyObject * obj0 = 0 ;
34083 PyObject * obj1 = 0 ;
34084 char * kwnames[] = {
34085 (char *) "self",(char *) "effect", NULL
34086 };
34087
34088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34090 if (!SWIG_IsOK(res1)) {
34091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34092 }
34093 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34094 ecode2 = SWIG_AsVal_int(obj1, &val2);
34095 if (!SWIG_IsOK(ecode2)) {
34096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34097 }
34098 arg2 = static_cast< wxDragResult >(val2);
34099 {
34100 PyThreadState* __tstate = wxPyBeginAllowThreads();
34101 result = (bool)(arg1)->GiveFeedback(arg2);
34102 wxPyEndAllowThreads(__tstate);
34103 if (PyErr_Occurred()) SWIG_fail;
34104 }
34105 {
34106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34107 }
34108 return resultobj;
34109 fail:
34110 return NULL;
34111 }
34112
34113
34114 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34115 PyObject *obj;
34116 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34117 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34118 return SWIG_Py_Void();
34119 }
34120
34121 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34122 return SWIG_Python_InitShadowInstance(args);
34123 }
34124
34125 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34126 PyObject *resultobj = 0;
34127 wxDataObject *arg1 = (wxDataObject *) NULL ;
34128 wxPyDropTarget *result = 0 ;
34129 int res1 = 0 ;
34130 PyObject * obj0 = 0 ;
34131 char * kwnames[] = {
34132 (char *) "dataObject", NULL
34133 };
34134
34135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34136 if (obj0) {
34137 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34138 if (!SWIG_IsOK(res1)) {
34139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34140 }
34141 }
34142 {
34143 PyThreadState* __tstate = wxPyBeginAllowThreads();
34144 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34145 wxPyEndAllowThreads(__tstate);
34146 if (PyErr_Occurred()) SWIG_fail;
34147 }
34148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34149 return resultobj;
34150 fail:
34151 return NULL;
34152 }
34153
34154
34155 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34156 PyObject *resultobj = 0;
34157 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34158 PyObject *arg2 = (PyObject *) 0 ;
34159 PyObject *arg3 = (PyObject *) 0 ;
34160 void *argp1 = 0 ;
34161 int res1 = 0 ;
34162 PyObject * obj0 = 0 ;
34163 PyObject * obj1 = 0 ;
34164 PyObject * obj2 = 0 ;
34165 char * kwnames[] = {
34166 (char *) "self",(char *) "self",(char *) "_class", NULL
34167 };
34168
34169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34171 if (!SWIG_IsOK(res1)) {
34172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34173 }
34174 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34175 arg2 = obj1;
34176 arg3 = obj2;
34177 {
34178 PyThreadState* __tstate = wxPyBeginAllowThreads();
34179 (arg1)->_setCallbackInfo(arg2,arg3);
34180 wxPyEndAllowThreads(__tstate);
34181 if (PyErr_Occurred()) SWIG_fail;
34182 }
34183 resultobj = SWIG_Py_Void();
34184 return resultobj;
34185 fail:
34186 return NULL;
34187 }
34188
34189
34190 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34191 PyObject *resultobj = 0;
34192 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34193 void *argp1 = 0 ;
34194 int res1 = 0 ;
34195 PyObject *swig_obj[1] ;
34196
34197 if (!args) SWIG_fail;
34198 swig_obj[0] = args;
34199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34200 if (!SWIG_IsOK(res1)) {
34201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34202 }
34203 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34204 {
34205 PyThreadState* __tstate = wxPyBeginAllowThreads();
34206 delete arg1;
34207
34208 wxPyEndAllowThreads(__tstate);
34209 if (PyErr_Occurred()) SWIG_fail;
34210 }
34211 resultobj = SWIG_Py_Void();
34212 return resultobj;
34213 fail:
34214 return NULL;
34215 }
34216
34217
34218 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34219 PyObject *resultobj = 0;
34220 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34221 wxDataObject *result = 0 ;
34222 void *argp1 = 0 ;
34223 int res1 = 0 ;
34224 PyObject *swig_obj[1] ;
34225
34226 if (!args) SWIG_fail;
34227 swig_obj[0] = args;
34228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34229 if (!SWIG_IsOK(res1)) {
34230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34231 }
34232 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34233 {
34234 PyThreadState* __tstate = wxPyBeginAllowThreads();
34235 result = (wxDataObject *)(arg1)->GetDataObject();
34236 wxPyEndAllowThreads(__tstate);
34237 if (PyErr_Occurred()) SWIG_fail;
34238 }
34239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34240 return resultobj;
34241 fail:
34242 return NULL;
34243 }
34244
34245
34246 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34247 PyObject *resultobj = 0;
34248 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34249 wxDataObject *arg2 = (wxDataObject *) 0 ;
34250 void *argp1 = 0 ;
34251 int res1 = 0 ;
34252 int res2 = 0 ;
34253 PyObject * obj0 = 0 ;
34254 PyObject * obj1 = 0 ;
34255 char * kwnames[] = {
34256 (char *) "self",(char *) "dataObject", NULL
34257 };
34258
34259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34261 if (!SWIG_IsOK(res1)) {
34262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34263 }
34264 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34265 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34266 if (!SWIG_IsOK(res2)) {
34267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34268 }
34269 {
34270 PyThreadState* __tstate = wxPyBeginAllowThreads();
34271 (arg1)->SetDataObject(arg2);
34272 wxPyEndAllowThreads(__tstate);
34273 if (PyErr_Occurred()) SWIG_fail;
34274 }
34275 resultobj = SWIG_Py_Void();
34276 return resultobj;
34277 fail:
34278 return NULL;
34279 }
34280
34281
34282 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34283 PyObject *resultobj = 0;
34284 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34285 int arg2 ;
34286 int arg3 ;
34287 wxDragResult arg4 ;
34288 wxDragResult result;
34289 void *argp1 = 0 ;
34290 int res1 = 0 ;
34291 int val2 ;
34292 int ecode2 = 0 ;
34293 int val3 ;
34294 int ecode3 = 0 ;
34295 int val4 ;
34296 int ecode4 = 0 ;
34297 PyObject * obj0 = 0 ;
34298 PyObject * obj1 = 0 ;
34299 PyObject * obj2 = 0 ;
34300 PyObject * obj3 = 0 ;
34301 char * kwnames[] = {
34302 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34303 };
34304
34305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34307 if (!SWIG_IsOK(res1)) {
34308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34309 }
34310 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34311 ecode2 = SWIG_AsVal_int(obj1, &val2);
34312 if (!SWIG_IsOK(ecode2)) {
34313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34314 }
34315 arg2 = static_cast< int >(val2);
34316 ecode3 = SWIG_AsVal_int(obj2, &val3);
34317 if (!SWIG_IsOK(ecode3)) {
34318 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34319 }
34320 arg3 = static_cast< int >(val3);
34321 ecode4 = SWIG_AsVal_int(obj3, &val4);
34322 if (!SWIG_IsOK(ecode4)) {
34323 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34324 }
34325 arg4 = static_cast< wxDragResult >(val4);
34326 {
34327 PyThreadState* __tstate = wxPyBeginAllowThreads();
34328 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34329 wxPyEndAllowThreads(__tstate);
34330 if (PyErr_Occurred()) SWIG_fail;
34331 }
34332 resultobj = SWIG_From_int(static_cast< int >(result));
34333 return resultobj;
34334 fail:
34335 return NULL;
34336 }
34337
34338
34339 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34340 PyObject *resultobj = 0;
34341 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34342 int arg2 ;
34343 int arg3 ;
34344 wxDragResult arg4 ;
34345 wxDragResult result;
34346 void *argp1 = 0 ;
34347 int res1 = 0 ;
34348 int val2 ;
34349 int ecode2 = 0 ;
34350 int val3 ;
34351 int ecode3 = 0 ;
34352 int val4 ;
34353 int ecode4 = 0 ;
34354 PyObject * obj0 = 0 ;
34355 PyObject * obj1 = 0 ;
34356 PyObject * obj2 = 0 ;
34357 PyObject * obj3 = 0 ;
34358 char * kwnames[] = {
34359 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34360 };
34361
34362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34364 if (!SWIG_IsOK(res1)) {
34365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34366 }
34367 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34368 ecode2 = SWIG_AsVal_int(obj1, &val2);
34369 if (!SWIG_IsOK(ecode2)) {
34370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34371 }
34372 arg2 = static_cast< int >(val2);
34373 ecode3 = SWIG_AsVal_int(obj2, &val3);
34374 if (!SWIG_IsOK(ecode3)) {
34375 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34376 }
34377 arg3 = static_cast< int >(val3);
34378 ecode4 = SWIG_AsVal_int(obj3, &val4);
34379 if (!SWIG_IsOK(ecode4)) {
34380 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34381 }
34382 arg4 = static_cast< wxDragResult >(val4);
34383 {
34384 PyThreadState* __tstate = wxPyBeginAllowThreads();
34385 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34386 wxPyEndAllowThreads(__tstate);
34387 if (PyErr_Occurred()) SWIG_fail;
34388 }
34389 resultobj = SWIG_From_int(static_cast< int >(result));
34390 return resultobj;
34391 fail:
34392 return NULL;
34393 }
34394
34395
34396 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34397 PyObject *resultobj = 0;
34398 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34399 void *argp1 = 0 ;
34400 int res1 = 0 ;
34401 PyObject *swig_obj[1] ;
34402
34403 if (!args) SWIG_fail;
34404 swig_obj[0] = args;
34405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34406 if (!SWIG_IsOK(res1)) {
34407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34408 }
34409 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34410 {
34411 PyThreadState* __tstate = wxPyBeginAllowThreads();
34412 (arg1)->OnLeave();
34413 wxPyEndAllowThreads(__tstate);
34414 if (PyErr_Occurred()) SWIG_fail;
34415 }
34416 resultobj = SWIG_Py_Void();
34417 return resultobj;
34418 fail:
34419 return NULL;
34420 }
34421
34422
34423 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34424 PyObject *resultobj = 0;
34425 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34426 int arg2 ;
34427 int arg3 ;
34428 bool result;
34429 void *argp1 = 0 ;
34430 int res1 = 0 ;
34431 int val2 ;
34432 int ecode2 = 0 ;
34433 int val3 ;
34434 int ecode3 = 0 ;
34435 PyObject * obj0 = 0 ;
34436 PyObject * obj1 = 0 ;
34437 PyObject * obj2 = 0 ;
34438 char * kwnames[] = {
34439 (char *) "self",(char *) "x",(char *) "y", NULL
34440 };
34441
34442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34444 if (!SWIG_IsOK(res1)) {
34445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34446 }
34447 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34448 ecode2 = SWIG_AsVal_int(obj1, &val2);
34449 if (!SWIG_IsOK(ecode2)) {
34450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34451 }
34452 arg2 = static_cast< int >(val2);
34453 ecode3 = SWIG_AsVal_int(obj2, &val3);
34454 if (!SWIG_IsOK(ecode3)) {
34455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34456 }
34457 arg3 = static_cast< int >(val3);
34458 {
34459 PyThreadState* __tstate = wxPyBeginAllowThreads();
34460 result = (bool)(arg1)->OnDrop(arg2,arg3);
34461 wxPyEndAllowThreads(__tstate);
34462 if (PyErr_Occurred()) SWIG_fail;
34463 }
34464 {
34465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34466 }
34467 return resultobj;
34468 fail:
34469 return NULL;
34470 }
34471
34472
34473 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34474 PyObject *resultobj = 0;
34475 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34476 bool result;
34477 void *argp1 = 0 ;
34478 int res1 = 0 ;
34479 PyObject *swig_obj[1] ;
34480
34481 if (!args) SWIG_fail;
34482 swig_obj[0] = args;
34483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34484 if (!SWIG_IsOK(res1)) {
34485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34486 }
34487 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34488 {
34489 PyThreadState* __tstate = wxPyBeginAllowThreads();
34490 result = (bool)(arg1)->GetData();
34491 wxPyEndAllowThreads(__tstate);
34492 if (PyErr_Occurred()) SWIG_fail;
34493 }
34494 {
34495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34496 }
34497 return resultobj;
34498 fail:
34499 return NULL;
34500 }
34501
34502
34503 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34504 PyObject *resultobj = 0;
34505 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34506 wxDragResult arg2 ;
34507 void *argp1 = 0 ;
34508 int res1 = 0 ;
34509 int val2 ;
34510 int ecode2 = 0 ;
34511 PyObject * obj0 = 0 ;
34512 PyObject * obj1 = 0 ;
34513 char * kwnames[] = {
34514 (char *) "self",(char *) "action", NULL
34515 };
34516
34517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34519 if (!SWIG_IsOK(res1)) {
34520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34521 }
34522 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34523 ecode2 = SWIG_AsVal_int(obj1, &val2);
34524 if (!SWIG_IsOK(ecode2)) {
34525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34526 }
34527 arg2 = static_cast< wxDragResult >(val2);
34528 {
34529 PyThreadState* __tstate = wxPyBeginAllowThreads();
34530 (arg1)->SetDefaultAction(arg2);
34531 wxPyEndAllowThreads(__tstate);
34532 if (PyErr_Occurred()) SWIG_fail;
34533 }
34534 resultobj = SWIG_Py_Void();
34535 return resultobj;
34536 fail:
34537 return NULL;
34538 }
34539
34540
34541 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34542 PyObject *resultobj = 0;
34543 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34544 wxDragResult result;
34545 void *argp1 = 0 ;
34546 int res1 = 0 ;
34547 PyObject *swig_obj[1] ;
34548
34549 if (!args) SWIG_fail;
34550 swig_obj[0] = args;
34551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34552 if (!SWIG_IsOK(res1)) {
34553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34554 }
34555 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34556 {
34557 PyThreadState* __tstate = wxPyBeginAllowThreads();
34558 result = (wxDragResult)(arg1)->GetDefaultAction();
34559 wxPyEndAllowThreads(__tstate);
34560 if (PyErr_Occurred()) SWIG_fail;
34561 }
34562 resultobj = SWIG_From_int(static_cast< int >(result));
34563 return resultobj;
34564 fail:
34565 return NULL;
34566 }
34567
34568
34569 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34570 PyObject *obj;
34571 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34572 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34573 return SWIG_Py_Void();
34574 }
34575
34576 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34577 return SWIG_Python_InitShadowInstance(args);
34578 }
34579
34580 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34581 PyObject *resultobj = 0;
34582 wxPyTextDropTarget *result = 0 ;
34583
34584 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34585 {
34586 PyThreadState* __tstate = wxPyBeginAllowThreads();
34587 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34588 wxPyEndAllowThreads(__tstate);
34589 if (PyErr_Occurred()) SWIG_fail;
34590 }
34591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34592 return resultobj;
34593 fail:
34594 return NULL;
34595 }
34596
34597
34598 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34599 PyObject *resultobj = 0;
34600 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34601 PyObject *arg2 = (PyObject *) 0 ;
34602 PyObject *arg3 = (PyObject *) 0 ;
34603 void *argp1 = 0 ;
34604 int res1 = 0 ;
34605 PyObject * obj0 = 0 ;
34606 PyObject * obj1 = 0 ;
34607 PyObject * obj2 = 0 ;
34608 char * kwnames[] = {
34609 (char *) "self",(char *) "self",(char *) "_class", NULL
34610 };
34611
34612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34614 if (!SWIG_IsOK(res1)) {
34615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34616 }
34617 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34618 arg2 = obj1;
34619 arg3 = obj2;
34620 {
34621 PyThreadState* __tstate = wxPyBeginAllowThreads();
34622 (arg1)->_setCallbackInfo(arg2,arg3);
34623 wxPyEndAllowThreads(__tstate);
34624 if (PyErr_Occurred()) SWIG_fail;
34625 }
34626 resultobj = SWIG_Py_Void();
34627 return resultobj;
34628 fail:
34629 return NULL;
34630 }
34631
34632
34633 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34634 PyObject *resultobj = 0;
34635 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34636 int arg2 ;
34637 int arg3 ;
34638 wxString *arg4 = 0 ;
34639 bool result;
34640 void *argp1 = 0 ;
34641 int res1 = 0 ;
34642 int val2 ;
34643 int ecode2 = 0 ;
34644 int val3 ;
34645 int ecode3 = 0 ;
34646 bool temp4 = false ;
34647 PyObject * obj0 = 0 ;
34648 PyObject * obj1 = 0 ;
34649 PyObject * obj2 = 0 ;
34650 PyObject * obj3 = 0 ;
34651 char * kwnames[] = {
34652 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34653 };
34654
34655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34657 if (!SWIG_IsOK(res1)) {
34658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34659 }
34660 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34661 ecode2 = SWIG_AsVal_int(obj1, &val2);
34662 if (!SWIG_IsOK(ecode2)) {
34663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34664 }
34665 arg2 = static_cast< int >(val2);
34666 ecode3 = SWIG_AsVal_int(obj2, &val3);
34667 if (!SWIG_IsOK(ecode3)) {
34668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34669 }
34670 arg3 = static_cast< int >(val3);
34671 {
34672 arg4 = wxString_in_helper(obj3);
34673 if (arg4 == NULL) SWIG_fail;
34674 temp4 = true;
34675 }
34676 {
34677 PyThreadState* __tstate = wxPyBeginAllowThreads();
34678 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34679 wxPyEndAllowThreads(__tstate);
34680 if (PyErr_Occurred()) SWIG_fail;
34681 }
34682 {
34683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34684 }
34685 {
34686 if (temp4)
34687 delete arg4;
34688 }
34689 return resultobj;
34690 fail:
34691 {
34692 if (temp4)
34693 delete arg4;
34694 }
34695 return NULL;
34696 }
34697
34698
34699 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34700 PyObject *resultobj = 0;
34701 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34702 int arg2 ;
34703 int arg3 ;
34704 wxDragResult arg4 ;
34705 wxDragResult result;
34706 void *argp1 = 0 ;
34707 int res1 = 0 ;
34708 int val2 ;
34709 int ecode2 = 0 ;
34710 int val3 ;
34711 int ecode3 = 0 ;
34712 int val4 ;
34713 int ecode4 = 0 ;
34714 PyObject * obj0 = 0 ;
34715 PyObject * obj1 = 0 ;
34716 PyObject * obj2 = 0 ;
34717 PyObject * obj3 = 0 ;
34718 char * kwnames[] = {
34719 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34720 };
34721
34722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34724 if (!SWIG_IsOK(res1)) {
34725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34726 }
34727 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34728 ecode2 = SWIG_AsVal_int(obj1, &val2);
34729 if (!SWIG_IsOK(ecode2)) {
34730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34731 }
34732 arg2 = static_cast< int >(val2);
34733 ecode3 = SWIG_AsVal_int(obj2, &val3);
34734 if (!SWIG_IsOK(ecode3)) {
34735 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34736 }
34737 arg3 = static_cast< int >(val3);
34738 ecode4 = SWIG_AsVal_int(obj3, &val4);
34739 if (!SWIG_IsOK(ecode4)) {
34740 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34741 }
34742 arg4 = static_cast< wxDragResult >(val4);
34743 {
34744 PyThreadState* __tstate = wxPyBeginAllowThreads();
34745 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34746 wxPyEndAllowThreads(__tstate);
34747 if (PyErr_Occurred()) SWIG_fail;
34748 }
34749 resultobj = SWIG_From_int(static_cast< int >(result));
34750 return resultobj;
34751 fail:
34752 return NULL;
34753 }
34754
34755
34756 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34757 PyObject *resultobj = 0;
34758 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34759 int arg2 ;
34760 int arg3 ;
34761 wxDragResult arg4 ;
34762 wxDragResult result;
34763 void *argp1 = 0 ;
34764 int res1 = 0 ;
34765 int val2 ;
34766 int ecode2 = 0 ;
34767 int val3 ;
34768 int ecode3 = 0 ;
34769 int val4 ;
34770 int ecode4 = 0 ;
34771 PyObject * obj0 = 0 ;
34772 PyObject * obj1 = 0 ;
34773 PyObject * obj2 = 0 ;
34774 PyObject * obj3 = 0 ;
34775 char * kwnames[] = {
34776 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34777 };
34778
34779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34781 if (!SWIG_IsOK(res1)) {
34782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34783 }
34784 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34785 ecode2 = SWIG_AsVal_int(obj1, &val2);
34786 if (!SWIG_IsOK(ecode2)) {
34787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34788 }
34789 arg2 = static_cast< int >(val2);
34790 ecode3 = SWIG_AsVal_int(obj2, &val3);
34791 if (!SWIG_IsOK(ecode3)) {
34792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34793 }
34794 arg3 = static_cast< int >(val3);
34795 ecode4 = SWIG_AsVal_int(obj3, &val4);
34796 if (!SWIG_IsOK(ecode4)) {
34797 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34798 }
34799 arg4 = static_cast< wxDragResult >(val4);
34800 {
34801 PyThreadState* __tstate = wxPyBeginAllowThreads();
34802 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34803 wxPyEndAllowThreads(__tstate);
34804 if (PyErr_Occurred()) SWIG_fail;
34805 }
34806 resultobj = SWIG_From_int(static_cast< int >(result));
34807 return resultobj;
34808 fail:
34809 return NULL;
34810 }
34811
34812
34813 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34814 PyObject *resultobj = 0;
34815 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34816 void *argp1 = 0 ;
34817 int res1 = 0 ;
34818 PyObject *swig_obj[1] ;
34819
34820 if (!args) SWIG_fail;
34821 swig_obj[0] = args;
34822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34823 if (!SWIG_IsOK(res1)) {
34824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34825 }
34826 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34827 {
34828 PyThreadState* __tstate = wxPyBeginAllowThreads();
34829 (arg1)->OnLeave();
34830 wxPyEndAllowThreads(__tstate);
34831 if (PyErr_Occurred()) SWIG_fail;
34832 }
34833 resultobj = SWIG_Py_Void();
34834 return resultobj;
34835 fail:
34836 return NULL;
34837 }
34838
34839
34840 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34841 PyObject *resultobj = 0;
34842 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34843 int arg2 ;
34844 int arg3 ;
34845 bool result;
34846 void *argp1 = 0 ;
34847 int res1 = 0 ;
34848 int val2 ;
34849 int ecode2 = 0 ;
34850 int val3 ;
34851 int ecode3 = 0 ;
34852 PyObject * obj0 = 0 ;
34853 PyObject * obj1 = 0 ;
34854 PyObject * obj2 = 0 ;
34855 char * kwnames[] = {
34856 (char *) "self",(char *) "x",(char *) "y", NULL
34857 };
34858
34859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34861 if (!SWIG_IsOK(res1)) {
34862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34863 }
34864 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34865 ecode2 = SWIG_AsVal_int(obj1, &val2);
34866 if (!SWIG_IsOK(ecode2)) {
34867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34868 }
34869 arg2 = static_cast< int >(val2);
34870 ecode3 = SWIG_AsVal_int(obj2, &val3);
34871 if (!SWIG_IsOK(ecode3)) {
34872 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34873 }
34874 arg3 = static_cast< int >(val3);
34875 {
34876 PyThreadState* __tstate = wxPyBeginAllowThreads();
34877 result = (bool)(arg1)->OnDrop(arg2,arg3);
34878 wxPyEndAllowThreads(__tstate);
34879 if (PyErr_Occurred()) SWIG_fail;
34880 }
34881 {
34882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34883 }
34884 return resultobj;
34885 fail:
34886 return NULL;
34887 }
34888
34889
34890 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34891 PyObject *resultobj = 0;
34892 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34893 int arg2 ;
34894 int arg3 ;
34895 wxDragResult arg4 ;
34896 wxDragResult result;
34897 void *argp1 = 0 ;
34898 int res1 = 0 ;
34899 int val2 ;
34900 int ecode2 = 0 ;
34901 int val3 ;
34902 int ecode3 = 0 ;
34903 int val4 ;
34904 int ecode4 = 0 ;
34905 PyObject * obj0 = 0 ;
34906 PyObject * obj1 = 0 ;
34907 PyObject * obj2 = 0 ;
34908 PyObject * obj3 = 0 ;
34909 char * kwnames[] = {
34910 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34911 };
34912
34913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34915 if (!SWIG_IsOK(res1)) {
34916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34917 }
34918 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34919 ecode2 = SWIG_AsVal_int(obj1, &val2);
34920 if (!SWIG_IsOK(ecode2)) {
34921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34922 }
34923 arg2 = static_cast< int >(val2);
34924 ecode3 = SWIG_AsVal_int(obj2, &val3);
34925 if (!SWIG_IsOK(ecode3)) {
34926 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34927 }
34928 arg3 = static_cast< int >(val3);
34929 ecode4 = SWIG_AsVal_int(obj3, &val4);
34930 if (!SWIG_IsOK(ecode4)) {
34931 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34932 }
34933 arg4 = static_cast< wxDragResult >(val4);
34934 {
34935 PyThreadState* __tstate = wxPyBeginAllowThreads();
34936 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34937 wxPyEndAllowThreads(__tstate);
34938 if (PyErr_Occurred()) SWIG_fail;
34939 }
34940 resultobj = SWIG_From_int(static_cast< int >(result));
34941 return resultobj;
34942 fail:
34943 return NULL;
34944 }
34945
34946
34947 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34948 PyObject *obj;
34949 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34950 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34951 return SWIG_Py_Void();
34952 }
34953
34954 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34955 return SWIG_Python_InitShadowInstance(args);
34956 }
34957
34958 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34959 PyObject *resultobj = 0;
34960 wxPyFileDropTarget *result = 0 ;
34961
34962 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34963 {
34964 PyThreadState* __tstate = wxPyBeginAllowThreads();
34965 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34966 wxPyEndAllowThreads(__tstate);
34967 if (PyErr_Occurred()) SWIG_fail;
34968 }
34969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34970 return resultobj;
34971 fail:
34972 return NULL;
34973 }
34974
34975
34976 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34977 PyObject *resultobj = 0;
34978 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34979 PyObject *arg2 = (PyObject *) 0 ;
34980 PyObject *arg3 = (PyObject *) 0 ;
34981 void *argp1 = 0 ;
34982 int res1 = 0 ;
34983 PyObject * obj0 = 0 ;
34984 PyObject * obj1 = 0 ;
34985 PyObject * obj2 = 0 ;
34986 char * kwnames[] = {
34987 (char *) "self",(char *) "self",(char *) "_class", NULL
34988 };
34989
34990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34992 if (!SWIG_IsOK(res1)) {
34993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34994 }
34995 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34996 arg2 = obj1;
34997 arg3 = obj2;
34998 {
34999 PyThreadState* __tstate = wxPyBeginAllowThreads();
35000 (arg1)->_setCallbackInfo(arg2,arg3);
35001 wxPyEndAllowThreads(__tstate);
35002 if (PyErr_Occurred()) SWIG_fail;
35003 }
35004 resultobj = SWIG_Py_Void();
35005 return resultobj;
35006 fail:
35007 return NULL;
35008 }
35009
35010
35011 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35012 PyObject *resultobj = 0;
35013 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35014 int arg2 ;
35015 int arg3 ;
35016 wxArrayString *arg4 = 0 ;
35017 bool result;
35018 void *argp1 = 0 ;
35019 int res1 = 0 ;
35020 int val2 ;
35021 int ecode2 = 0 ;
35022 int val3 ;
35023 int ecode3 = 0 ;
35024 bool temp4 = false ;
35025 PyObject * obj0 = 0 ;
35026 PyObject * obj1 = 0 ;
35027 PyObject * obj2 = 0 ;
35028 PyObject * obj3 = 0 ;
35029 char * kwnames[] = {
35030 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
35031 };
35032
35033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35035 if (!SWIG_IsOK(res1)) {
35036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35037 }
35038 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35039 ecode2 = SWIG_AsVal_int(obj1, &val2);
35040 if (!SWIG_IsOK(ecode2)) {
35041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
35042 }
35043 arg2 = static_cast< int >(val2);
35044 ecode3 = SWIG_AsVal_int(obj2, &val3);
35045 if (!SWIG_IsOK(ecode3)) {
35046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
35047 }
35048 arg3 = static_cast< int >(val3);
35049 {
35050 if (! PySequence_Check(obj3)) {
35051 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
35052 SWIG_fail;
35053 }
35054 arg4 = new wxArrayString;
35055 temp4 = true;
35056 int i, len=PySequence_Length(obj3);
35057 for (i=0; i<len; i++) {
35058 PyObject* item = PySequence_GetItem(obj3, i);
35059 wxString* s = wxString_in_helper(item);
35060 if (PyErr_Occurred()) SWIG_fail;
35061 arg4->Add(*s);
35062 delete s;
35063 Py_DECREF(item);
35064 }
35065 }
35066 {
35067 PyThreadState* __tstate = wxPyBeginAllowThreads();
35068 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35069 wxPyEndAllowThreads(__tstate);
35070 if (PyErr_Occurred()) SWIG_fail;
35071 }
35072 {
35073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35074 }
35075 {
35076 if (temp4) delete arg4;
35077 }
35078 return resultobj;
35079 fail:
35080 {
35081 if (temp4) delete arg4;
35082 }
35083 return NULL;
35084 }
35085
35086
35087 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35088 PyObject *resultobj = 0;
35089 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35090 int arg2 ;
35091 int arg3 ;
35092 wxDragResult arg4 ;
35093 wxDragResult result;
35094 void *argp1 = 0 ;
35095 int res1 = 0 ;
35096 int val2 ;
35097 int ecode2 = 0 ;
35098 int val3 ;
35099 int ecode3 = 0 ;
35100 int val4 ;
35101 int ecode4 = 0 ;
35102 PyObject * obj0 = 0 ;
35103 PyObject * obj1 = 0 ;
35104 PyObject * obj2 = 0 ;
35105 PyObject * obj3 = 0 ;
35106 char * kwnames[] = {
35107 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35108 };
35109
35110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35112 if (!SWIG_IsOK(res1)) {
35113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35114 }
35115 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35116 ecode2 = SWIG_AsVal_int(obj1, &val2);
35117 if (!SWIG_IsOK(ecode2)) {
35118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35119 }
35120 arg2 = static_cast< int >(val2);
35121 ecode3 = SWIG_AsVal_int(obj2, &val3);
35122 if (!SWIG_IsOK(ecode3)) {
35123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35124 }
35125 arg3 = static_cast< int >(val3);
35126 ecode4 = SWIG_AsVal_int(obj3, &val4);
35127 if (!SWIG_IsOK(ecode4)) {
35128 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35129 }
35130 arg4 = static_cast< wxDragResult >(val4);
35131 {
35132 PyThreadState* __tstate = wxPyBeginAllowThreads();
35133 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35134 wxPyEndAllowThreads(__tstate);
35135 if (PyErr_Occurred()) SWIG_fail;
35136 }
35137 resultobj = SWIG_From_int(static_cast< int >(result));
35138 return resultobj;
35139 fail:
35140 return NULL;
35141 }
35142
35143
35144 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35145 PyObject *resultobj = 0;
35146 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35147 int arg2 ;
35148 int arg3 ;
35149 wxDragResult arg4 ;
35150 wxDragResult result;
35151 void *argp1 = 0 ;
35152 int res1 = 0 ;
35153 int val2 ;
35154 int ecode2 = 0 ;
35155 int val3 ;
35156 int ecode3 = 0 ;
35157 int val4 ;
35158 int ecode4 = 0 ;
35159 PyObject * obj0 = 0 ;
35160 PyObject * obj1 = 0 ;
35161 PyObject * obj2 = 0 ;
35162 PyObject * obj3 = 0 ;
35163 char * kwnames[] = {
35164 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35165 };
35166
35167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35169 if (!SWIG_IsOK(res1)) {
35170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35171 }
35172 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35173 ecode2 = SWIG_AsVal_int(obj1, &val2);
35174 if (!SWIG_IsOK(ecode2)) {
35175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35176 }
35177 arg2 = static_cast< int >(val2);
35178 ecode3 = SWIG_AsVal_int(obj2, &val3);
35179 if (!SWIG_IsOK(ecode3)) {
35180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35181 }
35182 arg3 = static_cast< int >(val3);
35183 ecode4 = SWIG_AsVal_int(obj3, &val4);
35184 if (!SWIG_IsOK(ecode4)) {
35185 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35186 }
35187 arg4 = static_cast< wxDragResult >(val4);
35188 {
35189 PyThreadState* __tstate = wxPyBeginAllowThreads();
35190 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35191 wxPyEndAllowThreads(__tstate);
35192 if (PyErr_Occurred()) SWIG_fail;
35193 }
35194 resultobj = SWIG_From_int(static_cast< int >(result));
35195 return resultobj;
35196 fail:
35197 return NULL;
35198 }
35199
35200
35201 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35202 PyObject *resultobj = 0;
35203 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35204 void *argp1 = 0 ;
35205 int res1 = 0 ;
35206 PyObject *swig_obj[1] ;
35207
35208 if (!args) SWIG_fail;
35209 swig_obj[0] = args;
35210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35211 if (!SWIG_IsOK(res1)) {
35212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35213 }
35214 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35215 {
35216 PyThreadState* __tstate = wxPyBeginAllowThreads();
35217 (arg1)->OnLeave();
35218 wxPyEndAllowThreads(__tstate);
35219 if (PyErr_Occurred()) SWIG_fail;
35220 }
35221 resultobj = SWIG_Py_Void();
35222 return resultobj;
35223 fail:
35224 return NULL;
35225 }
35226
35227
35228 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35229 PyObject *resultobj = 0;
35230 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35231 int arg2 ;
35232 int arg3 ;
35233 bool result;
35234 void *argp1 = 0 ;
35235 int res1 = 0 ;
35236 int val2 ;
35237 int ecode2 = 0 ;
35238 int val3 ;
35239 int ecode3 = 0 ;
35240 PyObject * obj0 = 0 ;
35241 PyObject * obj1 = 0 ;
35242 PyObject * obj2 = 0 ;
35243 char * kwnames[] = {
35244 (char *) "self",(char *) "x",(char *) "y", NULL
35245 };
35246
35247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35249 if (!SWIG_IsOK(res1)) {
35250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35251 }
35252 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35253 ecode2 = SWIG_AsVal_int(obj1, &val2);
35254 if (!SWIG_IsOK(ecode2)) {
35255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35256 }
35257 arg2 = static_cast< int >(val2);
35258 ecode3 = SWIG_AsVal_int(obj2, &val3);
35259 if (!SWIG_IsOK(ecode3)) {
35260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35261 }
35262 arg3 = static_cast< int >(val3);
35263 {
35264 PyThreadState* __tstate = wxPyBeginAllowThreads();
35265 result = (bool)(arg1)->OnDrop(arg2,arg3);
35266 wxPyEndAllowThreads(__tstate);
35267 if (PyErr_Occurred()) SWIG_fail;
35268 }
35269 {
35270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35271 }
35272 return resultobj;
35273 fail:
35274 return NULL;
35275 }
35276
35277
35278 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35279 PyObject *resultobj = 0;
35280 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35281 int arg2 ;
35282 int arg3 ;
35283 wxDragResult arg4 ;
35284 wxDragResult result;
35285 void *argp1 = 0 ;
35286 int res1 = 0 ;
35287 int val2 ;
35288 int ecode2 = 0 ;
35289 int val3 ;
35290 int ecode3 = 0 ;
35291 int val4 ;
35292 int ecode4 = 0 ;
35293 PyObject * obj0 = 0 ;
35294 PyObject * obj1 = 0 ;
35295 PyObject * obj2 = 0 ;
35296 PyObject * obj3 = 0 ;
35297 char * kwnames[] = {
35298 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35299 };
35300
35301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35303 if (!SWIG_IsOK(res1)) {
35304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35305 }
35306 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35307 ecode2 = SWIG_AsVal_int(obj1, &val2);
35308 if (!SWIG_IsOK(ecode2)) {
35309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35310 }
35311 arg2 = static_cast< int >(val2);
35312 ecode3 = SWIG_AsVal_int(obj2, &val3);
35313 if (!SWIG_IsOK(ecode3)) {
35314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35315 }
35316 arg3 = static_cast< int >(val3);
35317 ecode4 = SWIG_AsVal_int(obj3, &val4);
35318 if (!SWIG_IsOK(ecode4)) {
35319 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35320 }
35321 arg4 = static_cast< wxDragResult >(val4);
35322 {
35323 PyThreadState* __tstate = wxPyBeginAllowThreads();
35324 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35325 wxPyEndAllowThreads(__tstate);
35326 if (PyErr_Occurred()) SWIG_fail;
35327 }
35328 resultobj = SWIG_From_int(static_cast< int >(result));
35329 return resultobj;
35330 fail:
35331 return NULL;
35332 }
35333
35334
35335 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35336 PyObject *obj;
35337 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35338 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35339 return SWIG_Py_Void();
35340 }
35341
35342 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35343 return SWIG_Python_InitShadowInstance(args);
35344 }
35345
35346 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35347 PyObject *resultobj = 0;
35348 wxClipboard *result = 0 ;
35349
35350 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35351 {
35352 PyThreadState* __tstate = wxPyBeginAllowThreads();
35353 result = (wxClipboard *)new wxClipboard();
35354 wxPyEndAllowThreads(__tstate);
35355 if (PyErr_Occurred()) SWIG_fail;
35356 }
35357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35358 return resultobj;
35359 fail:
35360 return NULL;
35361 }
35362
35363
35364 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35365 PyObject *resultobj = 0;
35366 wxClipboard *arg1 = (wxClipboard *) 0 ;
35367 void *argp1 = 0 ;
35368 int res1 = 0 ;
35369 PyObject *swig_obj[1] ;
35370
35371 if (!args) SWIG_fail;
35372 swig_obj[0] = args;
35373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35374 if (!SWIG_IsOK(res1)) {
35375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35376 }
35377 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35378 {
35379 PyThreadState* __tstate = wxPyBeginAllowThreads();
35380 delete arg1;
35381
35382 wxPyEndAllowThreads(__tstate);
35383 if (PyErr_Occurred()) SWIG_fail;
35384 }
35385 resultobj = SWIG_Py_Void();
35386 return resultobj;
35387 fail:
35388 return NULL;
35389 }
35390
35391
35392 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35393 PyObject *resultobj = 0;
35394 wxClipboard *arg1 = (wxClipboard *) 0 ;
35395 bool result;
35396 void *argp1 = 0 ;
35397 int res1 = 0 ;
35398 PyObject *swig_obj[1] ;
35399
35400 if (!args) SWIG_fail;
35401 swig_obj[0] = args;
35402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35403 if (!SWIG_IsOK(res1)) {
35404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35405 }
35406 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35407 {
35408 PyThreadState* __tstate = wxPyBeginAllowThreads();
35409 result = (bool)(arg1)->Open();
35410 wxPyEndAllowThreads(__tstate);
35411 if (PyErr_Occurred()) SWIG_fail;
35412 }
35413 {
35414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35415 }
35416 return resultobj;
35417 fail:
35418 return NULL;
35419 }
35420
35421
35422 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35423 PyObject *resultobj = 0;
35424 wxClipboard *arg1 = (wxClipboard *) 0 ;
35425 void *argp1 = 0 ;
35426 int res1 = 0 ;
35427 PyObject *swig_obj[1] ;
35428
35429 if (!args) SWIG_fail;
35430 swig_obj[0] = args;
35431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35432 if (!SWIG_IsOK(res1)) {
35433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35434 }
35435 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35436 {
35437 PyThreadState* __tstate = wxPyBeginAllowThreads();
35438 (arg1)->Close();
35439 wxPyEndAllowThreads(__tstate);
35440 if (PyErr_Occurred()) SWIG_fail;
35441 }
35442 resultobj = SWIG_Py_Void();
35443 return resultobj;
35444 fail:
35445 return NULL;
35446 }
35447
35448
35449 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35450 PyObject *resultobj = 0;
35451 wxClipboard *arg1 = (wxClipboard *) 0 ;
35452 bool result;
35453 void *argp1 = 0 ;
35454 int res1 = 0 ;
35455 PyObject *swig_obj[1] ;
35456
35457 if (!args) SWIG_fail;
35458 swig_obj[0] = args;
35459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35460 if (!SWIG_IsOK(res1)) {
35461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35462 }
35463 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35464 {
35465 PyThreadState* __tstate = wxPyBeginAllowThreads();
35466 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35467 wxPyEndAllowThreads(__tstate);
35468 if (PyErr_Occurred()) SWIG_fail;
35469 }
35470 {
35471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35472 }
35473 return resultobj;
35474 fail:
35475 return NULL;
35476 }
35477
35478
35479 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35480 PyObject *resultobj = 0;
35481 wxClipboard *arg1 = (wxClipboard *) 0 ;
35482 wxDataObject *arg2 = (wxDataObject *) 0 ;
35483 bool result;
35484 void *argp1 = 0 ;
35485 int res1 = 0 ;
35486 int res2 = 0 ;
35487 PyObject * obj0 = 0 ;
35488 PyObject * obj1 = 0 ;
35489 char * kwnames[] = {
35490 (char *) "self",(char *) "data", NULL
35491 };
35492
35493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35495 if (!SWIG_IsOK(res1)) {
35496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35497 }
35498 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35499 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35500 if (!SWIG_IsOK(res2)) {
35501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35502 }
35503 {
35504 PyThreadState* __tstate = wxPyBeginAllowThreads();
35505 result = (bool)(arg1)->AddData(arg2);
35506 wxPyEndAllowThreads(__tstate);
35507 if (PyErr_Occurred()) SWIG_fail;
35508 }
35509 {
35510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35511 }
35512 return resultobj;
35513 fail:
35514 return NULL;
35515 }
35516
35517
35518 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35519 PyObject *resultobj = 0;
35520 wxClipboard *arg1 = (wxClipboard *) 0 ;
35521 wxDataObject *arg2 = (wxDataObject *) 0 ;
35522 bool result;
35523 void *argp1 = 0 ;
35524 int res1 = 0 ;
35525 int res2 = 0 ;
35526 PyObject * obj0 = 0 ;
35527 PyObject * obj1 = 0 ;
35528 char * kwnames[] = {
35529 (char *) "self",(char *) "data", NULL
35530 };
35531
35532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35534 if (!SWIG_IsOK(res1)) {
35535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35536 }
35537 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35538 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35539 if (!SWIG_IsOK(res2)) {
35540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35541 }
35542 {
35543 PyThreadState* __tstate = wxPyBeginAllowThreads();
35544 result = (bool)(arg1)->SetData(arg2);
35545 wxPyEndAllowThreads(__tstate);
35546 if (PyErr_Occurred()) SWIG_fail;
35547 }
35548 {
35549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35550 }
35551 return resultobj;
35552 fail:
35553 return NULL;
35554 }
35555
35556
35557 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35558 PyObject *resultobj = 0;
35559 wxClipboard *arg1 = (wxClipboard *) 0 ;
35560 wxDataFormat *arg2 = 0 ;
35561 bool result;
35562 void *argp1 = 0 ;
35563 int res1 = 0 ;
35564 void *argp2 = 0 ;
35565 int res2 = 0 ;
35566 PyObject * obj0 = 0 ;
35567 PyObject * obj1 = 0 ;
35568 char * kwnames[] = {
35569 (char *) "self",(char *) "format", NULL
35570 };
35571
35572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35574 if (!SWIG_IsOK(res1)) {
35575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35576 }
35577 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35578 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35579 if (!SWIG_IsOK(res2)) {
35580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35581 }
35582 if (!argp2) {
35583 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35584 }
35585 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35586 {
35587 PyThreadState* __tstate = wxPyBeginAllowThreads();
35588 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35589 wxPyEndAllowThreads(__tstate);
35590 if (PyErr_Occurred()) SWIG_fail;
35591 }
35592 {
35593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35594 }
35595 return resultobj;
35596 fail:
35597 return NULL;
35598 }
35599
35600
35601 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35602 PyObject *resultobj = 0;
35603 wxClipboard *arg1 = (wxClipboard *) 0 ;
35604 wxDataObject *arg2 = 0 ;
35605 bool result;
35606 void *argp1 = 0 ;
35607 int res1 = 0 ;
35608 void *argp2 = 0 ;
35609 int res2 = 0 ;
35610 PyObject * obj0 = 0 ;
35611 PyObject * obj1 = 0 ;
35612 char * kwnames[] = {
35613 (char *) "self",(char *) "data", NULL
35614 };
35615
35616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35618 if (!SWIG_IsOK(res1)) {
35619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35620 }
35621 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35622 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35623 if (!SWIG_IsOK(res2)) {
35624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35625 }
35626 if (!argp2) {
35627 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35628 }
35629 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35630 {
35631 PyThreadState* __tstate = wxPyBeginAllowThreads();
35632 result = (bool)(arg1)->GetData(*arg2);
35633 wxPyEndAllowThreads(__tstate);
35634 if (PyErr_Occurred()) SWIG_fail;
35635 }
35636 {
35637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35638 }
35639 return resultobj;
35640 fail:
35641 return NULL;
35642 }
35643
35644
35645 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35646 PyObject *resultobj = 0;
35647 wxClipboard *arg1 = (wxClipboard *) 0 ;
35648 void *argp1 = 0 ;
35649 int res1 = 0 ;
35650 PyObject *swig_obj[1] ;
35651
35652 if (!args) SWIG_fail;
35653 swig_obj[0] = args;
35654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35655 if (!SWIG_IsOK(res1)) {
35656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35657 }
35658 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35659 {
35660 PyThreadState* __tstate = wxPyBeginAllowThreads();
35661 (arg1)->Clear();
35662 wxPyEndAllowThreads(__tstate);
35663 if (PyErr_Occurred()) SWIG_fail;
35664 }
35665 resultobj = SWIG_Py_Void();
35666 return resultobj;
35667 fail:
35668 return NULL;
35669 }
35670
35671
35672 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35673 PyObject *resultobj = 0;
35674 wxClipboard *arg1 = (wxClipboard *) 0 ;
35675 bool result;
35676 void *argp1 = 0 ;
35677 int res1 = 0 ;
35678 PyObject *swig_obj[1] ;
35679
35680 if (!args) SWIG_fail;
35681 swig_obj[0] = args;
35682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35683 if (!SWIG_IsOK(res1)) {
35684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35685 }
35686 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35687 {
35688 PyThreadState* __tstate = wxPyBeginAllowThreads();
35689 result = (bool)(arg1)->Flush();
35690 wxPyEndAllowThreads(__tstate);
35691 if (PyErr_Occurred()) SWIG_fail;
35692 }
35693 {
35694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35695 }
35696 return resultobj;
35697 fail:
35698 return NULL;
35699 }
35700
35701
35702 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35703 PyObject *resultobj = 0;
35704 wxClipboard *arg1 = (wxClipboard *) 0 ;
35705 bool arg2 = (bool) true ;
35706 void *argp1 = 0 ;
35707 int res1 = 0 ;
35708 bool val2 ;
35709 int ecode2 = 0 ;
35710 PyObject * obj0 = 0 ;
35711 PyObject * obj1 = 0 ;
35712 char * kwnames[] = {
35713 (char *) "self",(char *) "primary", NULL
35714 };
35715
35716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35718 if (!SWIG_IsOK(res1)) {
35719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35720 }
35721 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35722 if (obj1) {
35723 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35724 if (!SWIG_IsOK(ecode2)) {
35725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35726 }
35727 arg2 = static_cast< bool >(val2);
35728 }
35729 {
35730 PyThreadState* __tstate = wxPyBeginAllowThreads();
35731 (arg1)->UsePrimarySelection(arg2);
35732 wxPyEndAllowThreads(__tstate);
35733 if (PyErr_Occurred()) SWIG_fail;
35734 }
35735 resultobj = SWIG_Py_Void();
35736 return resultobj;
35737 fail:
35738 return NULL;
35739 }
35740
35741
35742 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35743 PyObject *resultobj = 0;
35744 wxClipboard *result = 0 ;
35745
35746 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35747 {
35748 PyThreadState* __tstate = wxPyBeginAllowThreads();
35749 result = (wxClipboard *)wxClipboard::Get();
35750 wxPyEndAllowThreads(__tstate);
35751 if (PyErr_Occurred()) SWIG_fail;
35752 }
35753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35754 return resultobj;
35755 fail:
35756 return NULL;
35757 }
35758
35759
35760 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35761 PyObject *obj;
35762 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35763 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35764 return SWIG_Py_Void();
35765 }
35766
35767 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35768 return SWIG_Python_InitShadowInstance(args);
35769 }
35770
35771 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35772 PyObject *resultobj = 0;
35773 wxClipboard *arg1 = (wxClipboard *) NULL ;
35774 wxClipboardLocker *result = 0 ;
35775 void *argp1 = 0 ;
35776 int res1 = 0 ;
35777 PyObject * obj0 = 0 ;
35778 char * kwnames[] = {
35779 (char *) "clipboard", NULL
35780 };
35781
35782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35783 if (obj0) {
35784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35785 if (!SWIG_IsOK(res1)) {
35786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35787 }
35788 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35789 }
35790 {
35791 PyThreadState* __tstate = wxPyBeginAllowThreads();
35792 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35793 wxPyEndAllowThreads(__tstate);
35794 if (PyErr_Occurred()) SWIG_fail;
35795 }
35796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35797 return resultobj;
35798 fail:
35799 return NULL;
35800 }
35801
35802
35803 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35804 PyObject *resultobj = 0;
35805 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35806 void *argp1 = 0 ;
35807 int res1 = 0 ;
35808 PyObject *swig_obj[1] ;
35809
35810 if (!args) SWIG_fail;
35811 swig_obj[0] = args;
35812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35813 if (!SWIG_IsOK(res1)) {
35814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35815 }
35816 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35817 {
35818 PyThreadState* __tstate = wxPyBeginAllowThreads();
35819 delete arg1;
35820
35821 wxPyEndAllowThreads(__tstate);
35822 if (PyErr_Occurred()) SWIG_fail;
35823 }
35824 resultobj = SWIG_Py_Void();
35825 return resultobj;
35826 fail:
35827 return NULL;
35828 }
35829
35830
35831 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35832 PyObject *resultobj = 0;
35833 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35834 bool result;
35835 void *argp1 = 0 ;
35836 int res1 = 0 ;
35837 PyObject *swig_obj[1] ;
35838
35839 if (!args) SWIG_fail;
35840 swig_obj[0] = args;
35841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35842 if (!SWIG_IsOK(res1)) {
35843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35844 }
35845 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35846 {
35847 PyThreadState* __tstate = wxPyBeginAllowThreads();
35848 result = (bool)wxClipboardLocker___nonzero__(arg1);
35849 wxPyEndAllowThreads(__tstate);
35850 if (PyErr_Occurred()) SWIG_fail;
35851 }
35852 {
35853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35854 }
35855 return resultobj;
35856 fail:
35857 return NULL;
35858 }
35859
35860
35861 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35862 PyObject *obj;
35863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35864 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35865 return SWIG_Py_Void();
35866 }
35867
35868 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35869 return SWIG_Python_InitShadowInstance(args);
35870 }
35871
35872 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35873 PyObject *resultobj = 0;
35874 int arg1 = (int) 0 ;
35875 int arg2 = (int) 0 ;
35876 int arg3 = (int) 0 ;
35877 int arg4 = (int) 0 ;
35878 wxVideoMode *result = 0 ;
35879 int val1 ;
35880 int ecode1 = 0 ;
35881 int val2 ;
35882 int ecode2 = 0 ;
35883 int val3 ;
35884 int ecode3 = 0 ;
35885 int val4 ;
35886 int ecode4 = 0 ;
35887 PyObject * obj0 = 0 ;
35888 PyObject * obj1 = 0 ;
35889 PyObject * obj2 = 0 ;
35890 PyObject * obj3 = 0 ;
35891 char * kwnames[] = {
35892 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35893 };
35894
35895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35896 if (obj0) {
35897 ecode1 = SWIG_AsVal_int(obj0, &val1);
35898 if (!SWIG_IsOK(ecode1)) {
35899 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35900 }
35901 arg1 = static_cast< int >(val1);
35902 }
35903 if (obj1) {
35904 ecode2 = SWIG_AsVal_int(obj1, &val2);
35905 if (!SWIG_IsOK(ecode2)) {
35906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35907 }
35908 arg2 = static_cast< int >(val2);
35909 }
35910 if (obj2) {
35911 ecode3 = SWIG_AsVal_int(obj2, &val3);
35912 if (!SWIG_IsOK(ecode3)) {
35913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35914 }
35915 arg3 = static_cast< int >(val3);
35916 }
35917 if (obj3) {
35918 ecode4 = SWIG_AsVal_int(obj3, &val4);
35919 if (!SWIG_IsOK(ecode4)) {
35920 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35921 }
35922 arg4 = static_cast< int >(val4);
35923 }
35924 {
35925 PyThreadState* __tstate = wxPyBeginAllowThreads();
35926 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35927 wxPyEndAllowThreads(__tstate);
35928 if (PyErr_Occurred()) SWIG_fail;
35929 }
35930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35931 return resultobj;
35932 fail:
35933 return NULL;
35934 }
35935
35936
35937 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35938 PyObject *resultobj = 0;
35939 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35940 void *argp1 = 0 ;
35941 int res1 = 0 ;
35942 PyObject *swig_obj[1] ;
35943
35944 if (!args) SWIG_fail;
35945 swig_obj[0] = args;
35946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35947 if (!SWIG_IsOK(res1)) {
35948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35949 }
35950 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35951 {
35952 PyThreadState* __tstate = wxPyBeginAllowThreads();
35953 delete arg1;
35954
35955 wxPyEndAllowThreads(__tstate);
35956 if (PyErr_Occurred()) SWIG_fail;
35957 }
35958 resultobj = SWIG_Py_Void();
35959 return resultobj;
35960 fail:
35961 return NULL;
35962 }
35963
35964
35965 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35966 PyObject *resultobj = 0;
35967 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35968 wxVideoMode *arg2 = 0 ;
35969 bool result;
35970 void *argp1 = 0 ;
35971 int res1 = 0 ;
35972 void *argp2 = 0 ;
35973 int res2 = 0 ;
35974 PyObject * obj0 = 0 ;
35975 PyObject * obj1 = 0 ;
35976 char * kwnames[] = {
35977 (char *) "self",(char *) "other", NULL
35978 };
35979
35980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35982 if (!SWIG_IsOK(res1)) {
35983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35984 }
35985 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35986 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35987 if (!SWIG_IsOK(res2)) {
35988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35989 }
35990 if (!argp2) {
35991 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35992 }
35993 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35994 {
35995 PyThreadState* __tstate = wxPyBeginAllowThreads();
35996 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35997 wxPyEndAllowThreads(__tstate);
35998 if (PyErr_Occurred()) SWIG_fail;
35999 }
36000 {
36001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36002 }
36003 return resultobj;
36004 fail:
36005 return NULL;
36006 }
36007
36008
36009 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36010 PyObject *resultobj = 0;
36011 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36012 int result;
36013 void *argp1 = 0 ;
36014 int res1 = 0 ;
36015 PyObject *swig_obj[1] ;
36016
36017 if (!args) SWIG_fail;
36018 swig_obj[0] = args;
36019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36020 if (!SWIG_IsOK(res1)) {
36021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36022 }
36023 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36024 {
36025 PyThreadState* __tstate = wxPyBeginAllowThreads();
36026 result = (int)((wxVideoMode const *)arg1)->GetWidth();
36027 wxPyEndAllowThreads(__tstate);
36028 if (PyErr_Occurred()) SWIG_fail;
36029 }
36030 resultobj = SWIG_From_int(static_cast< int >(result));
36031 return resultobj;
36032 fail:
36033 return NULL;
36034 }
36035
36036
36037 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36038 PyObject *resultobj = 0;
36039 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36040 int result;
36041 void *argp1 = 0 ;
36042 int res1 = 0 ;
36043 PyObject *swig_obj[1] ;
36044
36045 if (!args) SWIG_fail;
36046 swig_obj[0] = args;
36047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36048 if (!SWIG_IsOK(res1)) {
36049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36050 }
36051 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36052 {
36053 PyThreadState* __tstate = wxPyBeginAllowThreads();
36054 result = (int)((wxVideoMode const *)arg1)->GetHeight();
36055 wxPyEndAllowThreads(__tstate);
36056 if (PyErr_Occurred()) SWIG_fail;
36057 }
36058 resultobj = SWIG_From_int(static_cast< int >(result));
36059 return resultobj;
36060 fail:
36061 return NULL;
36062 }
36063
36064
36065 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36066 PyObject *resultobj = 0;
36067 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36068 int result;
36069 void *argp1 = 0 ;
36070 int res1 = 0 ;
36071 PyObject *swig_obj[1] ;
36072
36073 if (!args) SWIG_fail;
36074 swig_obj[0] = args;
36075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36076 if (!SWIG_IsOK(res1)) {
36077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36078 }
36079 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36080 {
36081 PyThreadState* __tstate = wxPyBeginAllowThreads();
36082 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36083 wxPyEndAllowThreads(__tstate);
36084 if (PyErr_Occurred()) SWIG_fail;
36085 }
36086 resultobj = SWIG_From_int(static_cast< int >(result));
36087 return resultobj;
36088 fail:
36089 return NULL;
36090 }
36091
36092
36093 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36094 PyObject *resultobj = 0;
36095 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36096 bool result;
36097 void *argp1 = 0 ;
36098 int res1 = 0 ;
36099 PyObject *swig_obj[1] ;
36100
36101 if (!args) SWIG_fail;
36102 swig_obj[0] = args;
36103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36104 if (!SWIG_IsOK(res1)) {
36105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36106 }
36107 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36108 {
36109 PyThreadState* __tstate = wxPyBeginAllowThreads();
36110 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36111 wxPyEndAllowThreads(__tstate);
36112 if (PyErr_Occurred()) SWIG_fail;
36113 }
36114 {
36115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36116 }
36117 return resultobj;
36118 fail:
36119 return NULL;
36120 }
36121
36122
36123 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36124 PyObject *resultobj = 0;
36125 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36126 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36127 bool result;
36128 void *argp1 = 0 ;
36129 int res1 = 0 ;
36130 void *argp2 = 0 ;
36131 int res2 = 0 ;
36132 PyObject * obj0 = 0 ;
36133 PyObject * obj1 = 0 ;
36134 char * kwnames[] = {
36135 (char *) "self",(char *) "other", NULL
36136 };
36137
36138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36140 if (!SWIG_IsOK(res1)) {
36141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36142 }
36143 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36145 if (!SWIG_IsOK(res2)) {
36146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36147 }
36148 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36149 {
36150 PyThreadState* __tstate = wxPyBeginAllowThreads();
36151 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36152 wxPyEndAllowThreads(__tstate);
36153 if (PyErr_Occurred()) SWIG_fail;
36154 }
36155 {
36156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36157 }
36158 return resultobj;
36159 fail:
36160 return NULL;
36161 }
36162
36163
36164 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36165 PyObject *resultobj = 0;
36166 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36167 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36168 bool result;
36169 void *argp1 = 0 ;
36170 int res1 = 0 ;
36171 void *argp2 = 0 ;
36172 int res2 = 0 ;
36173 PyObject * obj0 = 0 ;
36174 PyObject * obj1 = 0 ;
36175 char * kwnames[] = {
36176 (char *) "self",(char *) "other", NULL
36177 };
36178
36179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36181 if (!SWIG_IsOK(res1)) {
36182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36183 }
36184 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36185 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36186 if (!SWIG_IsOK(res2)) {
36187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36188 }
36189 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36190 {
36191 PyThreadState* __tstate = wxPyBeginAllowThreads();
36192 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36193 wxPyEndAllowThreads(__tstate);
36194 if (PyErr_Occurred()) SWIG_fail;
36195 }
36196 {
36197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36198 }
36199 return resultobj;
36200 fail:
36201 return NULL;
36202 }
36203
36204
36205 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36206 PyObject *resultobj = 0;
36207 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36208 int arg2 ;
36209 void *argp1 = 0 ;
36210 int res1 = 0 ;
36211 int val2 ;
36212 int ecode2 = 0 ;
36213 PyObject *swig_obj[2] ;
36214
36215 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36217 if (!SWIG_IsOK(res1)) {
36218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36219 }
36220 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36221 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36222 if (!SWIG_IsOK(ecode2)) {
36223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36224 }
36225 arg2 = static_cast< int >(val2);
36226 if (arg1) (arg1)->w = arg2;
36227
36228 resultobj = SWIG_Py_Void();
36229 return resultobj;
36230 fail:
36231 return NULL;
36232 }
36233
36234
36235 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36236 PyObject *resultobj = 0;
36237 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36238 int result;
36239 void *argp1 = 0 ;
36240 int res1 = 0 ;
36241 PyObject *swig_obj[1] ;
36242
36243 if (!args) SWIG_fail;
36244 swig_obj[0] = args;
36245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36246 if (!SWIG_IsOK(res1)) {
36247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36248 }
36249 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36250 result = (int) ((arg1)->w);
36251 resultobj = SWIG_From_int(static_cast< int >(result));
36252 return resultobj;
36253 fail:
36254 return NULL;
36255 }
36256
36257
36258 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36259 PyObject *resultobj = 0;
36260 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36261 int arg2 ;
36262 void *argp1 = 0 ;
36263 int res1 = 0 ;
36264 int val2 ;
36265 int ecode2 = 0 ;
36266 PyObject *swig_obj[2] ;
36267
36268 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36270 if (!SWIG_IsOK(res1)) {
36271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36272 }
36273 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36274 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36275 if (!SWIG_IsOK(ecode2)) {
36276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36277 }
36278 arg2 = static_cast< int >(val2);
36279 if (arg1) (arg1)->h = arg2;
36280
36281 resultobj = SWIG_Py_Void();
36282 return resultobj;
36283 fail:
36284 return NULL;
36285 }
36286
36287
36288 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36289 PyObject *resultobj = 0;
36290 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36291 int result;
36292 void *argp1 = 0 ;
36293 int res1 = 0 ;
36294 PyObject *swig_obj[1] ;
36295
36296 if (!args) SWIG_fail;
36297 swig_obj[0] = args;
36298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36299 if (!SWIG_IsOK(res1)) {
36300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36301 }
36302 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36303 result = (int) ((arg1)->h);
36304 resultobj = SWIG_From_int(static_cast< int >(result));
36305 return resultobj;
36306 fail:
36307 return NULL;
36308 }
36309
36310
36311 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36312 PyObject *resultobj = 0;
36313 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36314 int arg2 ;
36315 void *argp1 = 0 ;
36316 int res1 = 0 ;
36317 int val2 ;
36318 int ecode2 = 0 ;
36319 PyObject *swig_obj[2] ;
36320
36321 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36323 if (!SWIG_IsOK(res1)) {
36324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36325 }
36326 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36327 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36328 if (!SWIG_IsOK(ecode2)) {
36329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36330 }
36331 arg2 = static_cast< int >(val2);
36332 if (arg1) (arg1)->bpp = arg2;
36333
36334 resultobj = SWIG_Py_Void();
36335 return resultobj;
36336 fail:
36337 return NULL;
36338 }
36339
36340
36341 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36342 PyObject *resultobj = 0;
36343 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36344 int result;
36345 void *argp1 = 0 ;
36346 int res1 = 0 ;
36347 PyObject *swig_obj[1] ;
36348
36349 if (!args) SWIG_fail;
36350 swig_obj[0] = args;
36351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36352 if (!SWIG_IsOK(res1)) {
36353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36354 }
36355 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36356 result = (int) ((arg1)->bpp);
36357 resultobj = SWIG_From_int(static_cast< int >(result));
36358 return resultobj;
36359 fail:
36360 return NULL;
36361 }
36362
36363
36364 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36365 PyObject *resultobj = 0;
36366 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36367 int arg2 ;
36368 void *argp1 = 0 ;
36369 int res1 = 0 ;
36370 int val2 ;
36371 int ecode2 = 0 ;
36372 PyObject *swig_obj[2] ;
36373
36374 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36376 if (!SWIG_IsOK(res1)) {
36377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36378 }
36379 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36380 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36381 if (!SWIG_IsOK(ecode2)) {
36382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36383 }
36384 arg2 = static_cast< int >(val2);
36385 if (arg1) (arg1)->refresh = arg2;
36386
36387 resultobj = SWIG_Py_Void();
36388 return resultobj;
36389 fail:
36390 return NULL;
36391 }
36392
36393
36394 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36395 PyObject *resultobj = 0;
36396 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36397 int result;
36398 void *argp1 = 0 ;
36399 int res1 = 0 ;
36400 PyObject *swig_obj[1] ;
36401
36402 if (!args) SWIG_fail;
36403 swig_obj[0] = args;
36404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36405 if (!SWIG_IsOK(res1)) {
36406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36407 }
36408 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36409 result = (int) ((arg1)->refresh);
36410 resultobj = SWIG_From_int(static_cast< int >(result));
36411 return resultobj;
36412 fail:
36413 return NULL;
36414 }
36415
36416
36417 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36418 PyObject *obj;
36419 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36420 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36421 return SWIG_Py_Void();
36422 }
36423
36424 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36425 return SWIG_Python_InitShadowInstance(args);
36426 }
36427
36428 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36429 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36430 return 1;
36431 }
36432
36433
36434 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36435 PyObject *pyobj = 0;
36436
36437 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36438 return pyobj;
36439 }
36440
36441
36442 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36443 PyObject *resultobj = 0;
36444 unsigned int arg1 = (unsigned int) 0 ;
36445 wxDisplay *result = 0 ;
36446 unsigned int val1 ;
36447 int ecode1 = 0 ;
36448 PyObject * obj0 = 0 ;
36449 char * kwnames[] = {
36450 (char *) "index", NULL
36451 };
36452
36453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36454 if (obj0) {
36455 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36456 if (!SWIG_IsOK(ecode1)) {
36457 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36458 }
36459 arg1 = static_cast< unsigned int >(val1);
36460 }
36461 {
36462 PyThreadState* __tstate = wxPyBeginAllowThreads();
36463 result = (wxDisplay *)new wxDisplay(arg1);
36464 wxPyEndAllowThreads(__tstate);
36465 if (PyErr_Occurred()) SWIG_fail;
36466 }
36467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36468 return resultobj;
36469 fail:
36470 return NULL;
36471 }
36472
36473
36474 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36475 PyObject *resultobj = 0;
36476 wxDisplay *arg1 = (wxDisplay *) 0 ;
36477 void *argp1 = 0 ;
36478 int res1 = 0 ;
36479 PyObject *swig_obj[1] ;
36480
36481 if (!args) SWIG_fail;
36482 swig_obj[0] = args;
36483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36484 if (!SWIG_IsOK(res1)) {
36485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36486 }
36487 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36488 {
36489 PyThreadState* __tstate = wxPyBeginAllowThreads();
36490 delete arg1;
36491
36492 wxPyEndAllowThreads(__tstate);
36493 if (PyErr_Occurred()) SWIG_fail;
36494 }
36495 resultobj = SWIG_Py_Void();
36496 return resultobj;
36497 fail:
36498 return NULL;
36499 }
36500
36501
36502 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36503 PyObject *resultobj = 0;
36504 unsigned int result;
36505
36506 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36507 {
36508 PyThreadState* __tstate = wxPyBeginAllowThreads();
36509 result = (unsigned int)wxDisplay::GetCount();
36510 wxPyEndAllowThreads(__tstate);
36511 if (PyErr_Occurred()) SWIG_fail;
36512 }
36513 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36514 return resultobj;
36515 fail:
36516 return NULL;
36517 }
36518
36519
36520 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36521 PyObject *resultobj = 0;
36522 wxPoint *arg1 = 0 ;
36523 int result;
36524 wxPoint temp1 ;
36525 PyObject * obj0 = 0 ;
36526 char * kwnames[] = {
36527 (char *) "pt", NULL
36528 };
36529
36530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36531 {
36532 arg1 = &temp1;
36533 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36534 }
36535 {
36536 PyThreadState* __tstate = wxPyBeginAllowThreads();
36537 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36538 wxPyEndAllowThreads(__tstate);
36539 if (PyErr_Occurred()) SWIG_fail;
36540 }
36541 resultobj = SWIG_From_int(static_cast< int >(result));
36542 return resultobj;
36543 fail:
36544 return NULL;
36545 }
36546
36547
36548 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36549 PyObject *resultobj = 0;
36550 wxWindow *arg1 = (wxWindow *) 0 ;
36551 int result;
36552 void *argp1 = 0 ;
36553 int res1 = 0 ;
36554 PyObject * obj0 = 0 ;
36555 char * kwnames[] = {
36556 (char *) "window", NULL
36557 };
36558
36559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36561 if (!SWIG_IsOK(res1)) {
36562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36563 }
36564 arg1 = reinterpret_cast< wxWindow * >(argp1);
36565 {
36566 PyThreadState* __tstate = wxPyBeginAllowThreads();
36567 result = (int)wxDisplay::GetFromWindow(arg1);
36568 wxPyEndAllowThreads(__tstate);
36569 if (PyErr_Occurred()) SWIG_fail;
36570 }
36571 resultobj = SWIG_From_int(static_cast< int >(result));
36572 return resultobj;
36573 fail:
36574 return NULL;
36575 }
36576
36577
36578 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36579 PyObject *resultobj = 0;
36580 wxDisplay *arg1 = (wxDisplay *) 0 ;
36581 bool result;
36582 void *argp1 = 0 ;
36583 int res1 = 0 ;
36584 PyObject *swig_obj[1] ;
36585
36586 if (!args) SWIG_fail;
36587 swig_obj[0] = args;
36588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36589 if (!SWIG_IsOK(res1)) {
36590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36591 }
36592 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36593 {
36594 PyThreadState* __tstate = wxPyBeginAllowThreads();
36595 result = (bool)((wxDisplay const *)arg1)->IsOk();
36596 wxPyEndAllowThreads(__tstate);
36597 if (PyErr_Occurred()) SWIG_fail;
36598 }
36599 {
36600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36601 }
36602 return resultobj;
36603 fail:
36604 return NULL;
36605 }
36606
36607
36608 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36609 PyObject *resultobj = 0;
36610 wxDisplay *arg1 = (wxDisplay *) 0 ;
36611 wxRect result;
36612 void *argp1 = 0 ;
36613 int res1 = 0 ;
36614 PyObject *swig_obj[1] ;
36615
36616 if (!args) SWIG_fail;
36617 swig_obj[0] = args;
36618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36619 if (!SWIG_IsOK(res1)) {
36620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36621 }
36622 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36623 {
36624 PyThreadState* __tstate = wxPyBeginAllowThreads();
36625 result = ((wxDisplay const *)arg1)->GetGeometry();
36626 wxPyEndAllowThreads(__tstate);
36627 if (PyErr_Occurred()) SWIG_fail;
36628 }
36629 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36630 return resultobj;
36631 fail:
36632 return NULL;
36633 }
36634
36635
36636 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36637 PyObject *resultobj = 0;
36638 wxDisplay *arg1 = (wxDisplay *) 0 ;
36639 wxRect result;
36640 void *argp1 = 0 ;
36641 int res1 = 0 ;
36642 PyObject *swig_obj[1] ;
36643
36644 if (!args) SWIG_fail;
36645 swig_obj[0] = args;
36646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36647 if (!SWIG_IsOK(res1)) {
36648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36649 }
36650 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36651 {
36652 PyThreadState* __tstate = wxPyBeginAllowThreads();
36653 result = ((wxDisplay const *)arg1)->GetClientArea();
36654 wxPyEndAllowThreads(__tstate);
36655 if (PyErr_Occurred()) SWIG_fail;
36656 }
36657 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36658 return resultobj;
36659 fail:
36660 return NULL;
36661 }
36662
36663
36664 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36665 PyObject *resultobj = 0;
36666 wxDisplay *arg1 = (wxDisplay *) 0 ;
36667 wxString result;
36668 void *argp1 = 0 ;
36669 int res1 = 0 ;
36670 PyObject *swig_obj[1] ;
36671
36672 if (!args) SWIG_fail;
36673 swig_obj[0] = args;
36674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36675 if (!SWIG_IsOK(res1)) {
36676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36677 }
36678 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36679 {
36680 PyThreadState* __tstate = wxPyBeginAllowThreads();
36681 result = ((wxDisplay const *)arg1)->GetName();
36682 wxPyEndAllowThreads(__tstate);
36683 if (PyErr_Occurred()) SWIG_fail;
36684 }
36685 {
36686 #if wxUSE_UNICODE
36687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36688 #else
36689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36690 #endif
36691 }
36692 return resultobj;
36693 fail:
36694 return NULL;
36695 }
36696
36697
36698 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36699 PyObject *resultobj = 0;
36700 wxDisplay *arg1 = (wxDisplay *) 0 ;
36701 bool result;
36702 void *argp1 = 0 ;
36703 int res1 = 0 ;
36704 PyObject *swig_obj[1] ;
36705
36706 if (!args) SWIG_fail;
36707 swig_obj[0] = args;
36708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36709 if (!SWIG_IsOK(res1)) {
36710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36711 }
36712 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36713 {
36714 PyThreadState* __tstate = wxPyBeginAllowThreads();
36715 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36716 wxPyEndAllowThreads(__tstate);
36717 if (PyErr_Occurred()) SWIG_fail;
36718 }
36719 {
36720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36721 }
36722 return resultobj;
36723 fail:
36724 return NULL;
36725 }
36726
36727
36728 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36729 PyObject *resultobj = 0;
36730 wxDisplay *arg1 = (wxDisplay *) 0 ;
36731 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36732 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36733 PyObject *result = 0 ;
36734 void *argp1 = 0 ;
36735 int res1 = 0 ;
36736 void *argp2 = 0 ;
36737 int res2 = 0 ;
36738 PyObject * obj0 = 0 ;
36739 PyObject * obj1 = 0 ;
36740 char * kwnames[] = {
36741 (char *) "self",(char *) "mode", NULL
36742 };
36743
36744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36746 if (!SWIG_IsOK(res1)) {
36747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36748 }
36749 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36750 if (obj1) {
36751 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36752 if (!SWIG_IsOK(res2)) {
36753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36754 }
36755 if (!argp2) {
36756 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36757 }
36758 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36759 }
36760 {
36761 PyThreadState* __tstate = wxPyBeginAllowThreads();
36762 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36763 wxPyEndAllowThreads(__tstate);
36764 if (PyErr_Occurred()) SWIG_fail;
36765 }
36766 resultobj = result;
36767 return resultobj;
36768 fail:
36769 return NULL;
36770 }
36771
36772
36773 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36774 PyObject *resultobj = 0;
36775 wxDisplay *arg1 = (wxDisplay *) 0 ;
36776 wxVideoMode result;
36777 void *argp1 = 0 ;
36778 int res1 = 0 ;
36779 PyObject *swig_obj[1] ;
36780
36781 if (!args) SWIG_fail;
36782 swig_obj[0] = args;
36783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36784 if (!SWIG_IsOK(res1)) {
36785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36786 }
36787 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36788 {
36789 PyThreadState* __tstate = wxPyBeginAllowThreads();
36790 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36791 wxPyEndAllowThreads(__tstate);
36792 if (PyErr_Occurred()) SWIG_fail;
36793 }
36794 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36795 return resultobj;
36796 fail:
36797 return NULL;
36798 }
36799
36800
36801 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36802 PyObject *resultobj = 0;
36803 wxDisplay *arg1 = (wxDisplay *) 0 ;
36804 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36805 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36806 bool result;
36807 void *argp1 = 0 ;
36808 int res1 = 0 ;
36809 void *argp2 = 0 ;
36810 int res2 = 0 ;
36811 PyObject * obj0 = 0 ;
36812 PyObject * obj1 = 0 ;
36813 char * kwnames[] = {
36814 (char *) "self",(char *) "mode", NULL
36815 };
36816
36817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36819 if (!SWIG_IsOK(res1)) {
36820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36821 }
36822 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36823 if (obj1) {
36824 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36825 if (!SWIG_IsOK(res2)) {
36826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36827 }
36828 if (!argp2) {
36829 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36830 }
36831 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36832 }
36833 {
36834 PyThreadState* __tstate = wxPyBeginAllowThreads();
36835 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36836 wxPyEndAllowThreads(__tstate);
36837 if (PyErr_Occurred()) SWIG_fail;
36838 }
36839 {
36840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36841 }
36842 return resultobj;
36843 fail:
36844 return NULL;
36845 }
36846
36847
36848 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36849 PyObject *resultobj = 0;
36850 wxDisplay *arg1 = (wxDisplay *) 0 ;
36851 void *argp1 = 0 ;
36852 int res1 = 0 ;
36853 PyObject *swig_obj[1] ;
36854
36855 if (!args) SWIG_fail;
36856 swig_obj[0] = args;
36857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36858 if (!SWIG_IsOK(res1)) {
36859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36860 }
36861 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36862 {
36863 PyThreadState* __tstate = wxPyBeginAllowThreads();
36864 wxDisplay_ResetMode(arg1);
36865 wxPyEndAllowThreads(__tstate);
36866 if (PyErr_Occurred()) SWIG_fail;
36867 }
36868 resultobj = SWIG_Py_Void();
36869 return resultobj;
36870 fail:
36871 return NULL;
36872 }
36873
36874
36875 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36876 PyObject *obj;
36877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36878 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36879 return SWIG_Py_Void();
36880 }
36881
36882 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36883 return SWIG_Python_InitShadowInstance(args);
36884 }
36885
36886 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36887 PyObject *resultobj = 0;
36888 wxStandardPaths *result = 0 ;
36889
36890 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36891 {
36892 PyThreadState* __tstate = wxPyBeginAllowThreads();
36893 result = (wxStandardPaths *)wxStandardPaths_Get();
36894 wxPyEndAllowThreads(__tstate);
36895 if (PyErr_Occurred()) SWIG_fail;
36896 }
36897 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36898 return resultobj;
36899 fail:
36900 return NULL;
36901 }
36902
36903
36904 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36905 PyObject *resultobj = 0;
36906 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36907 wxString result;
36908 void *argp1 = 0 ;
36909 int res1 = 0 ;
36910 PyObject *swig_obj[1] ;
36911
36912 if (!args) SWIG_fail;
36913 swig_obj[0] = args;
36914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36915 if (!SWIG_IsOK(res1)) {
36916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36917 }
36918 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36919 {
36920 PyThreadState* __tstate = wxPyBeginAllowThreads();
36921 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36922 wxPyEndAllowThreads(__tstate);
36923 if (PyErr_Occurred()) SWIG_fail;
36924 }
36925 {
36926 #if wxUSE_UNICODE
36927 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36928 #else
36929 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36930 #endif
36931 }
36932 return resultobj;
36933 fail:
36934 return NULL;
36935 }
36936
36937
36938 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36939 PyObject *resultobj = 0;
36940 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36941 wxString result;
36942 void *argp1 = 0 ;
36943 int res1 = 0 ;
36944 PyObject *swig_obj[1] ;
36945
36946 if (!args) SWIG_fail;
36947 swig_obj[0] = args;
36948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36949 if (!SWIG_IsOK(res1)) {
36950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36951 }
36952 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36953 {
36954 PyThreadState* __tstate = wxPyBeginAllowThreads();
36955 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36956 wxPyEndAllowThreads(__tstate);
36957 if (PyErr_Occurred()) SWIG_fail;
36958 }
36959 {
36960 #if wxUSE_UNICODE
36961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36962 #else
36963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36964 #endif
36965 }
36966 return resultobj;
36967 fail:
36968 return NULL;
36969 }
36970
36971
36972 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36973 PyObject *resultobj = 0;
36974 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36975 wxString result;
36976 void *argp1 = 0 ;
36977 int res1 = 0 ;
36978 PyObject *swig_obj[1] ;
36979
36980 if (!args) SWIG_fail;
36981 swig_obj[0] = args;
36982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36983 if (!SWIG_IsOK(res1)) {
36984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36985 }
36986 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36987 {
36988 PyThreadState* __tstate = wxPyBeginAllowThreads();
36989 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36990 wxPyEndAllowThreads(__tstate);
36991 if (PyErr_Occurred()) SWIG_fail;
36992 }
36993 {
36994 #if wxUSE_UNICODE
36995 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36996 #else
36997 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36998 #endif
36999 }
37000 return resultobj;
37001 fail:
37002 return NULL;
37003 }
37004
37005
37006 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37007 PyObject *resultobj = 0;
37008 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37009 wxString result;
37010 void *argp1 = 0 ;
37011 int res1 = 0 ;
37012 PyObject *swig_obj[1] ;
37013
37014 if (!args) SWIG_fail;
37015 swig_obj[0] = args;
37016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37017 if (!SWIG_IsOK(res1)) {
37018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37019 }
37020 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37021 {
37022 PyThreadState* __tstate = wxPyBeginAllowThreads();
37023 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
37024 wxPyEndAllowThreads(__tstate);
37025 if (PyErr_Occurred()) SWIG_fail;
37026 }
37027 {
37028 #if wxUSE_UNICODE
37029 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37030 #else
37031 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37032 #endif
37033 }
37034 return resultobj;
37035 fail:
37036 return NULL;
37037 }
37038
37039
37040 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37041 PyObject *resultobj = 0;
37042 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37043 wxString result;
37044 void *argp1 = 0 ;
37045 int res1 = 0 ;
37046 PyObject *swig_obj[1] ;
37047
37048 if (!args) SWIG_fail;
37049 swig_obj[0] = args;
37050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37051 if (!SWIG_IsOK(res1)) {
37052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37053 }
37054 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37055 {
37056 PyThreadState* __tstate = wxPyBeginAllowThreads();
37057 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
37058 wxPyEndAllowThreads(__tstate);
37059 if (PyErr_Occurred()) SWIG_fail;
37060 }
37061 {
37062 #if wxUSE_UNICODE
37063 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37064 #else
37065 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37066 #endif
37067 }
37068 return resultobj;
37069 fail:
37070 return NULL;
37071 }
37072
37073
37074 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37075 PyObject *resultobj = 0;
37076 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37077 wxString result;
37078 void *argp1 = 0 ;
37079 int res1 = 0 ;
37080 PyObject *swig_obj[1] ;
37081
37082 if (!args) SWIG_fail;
37083 swig_obj[0] = args;
37084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37085 if (!SWIG_IsOK(res1)) {
37086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37087 }
37088 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37089 {
37090 PyThreadState* __tstate = wxPyBeginAllowThreads();
37091 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37092 wxPyEndAllowThreads(__tstate);
37093 if (PyErr_Occurred()) SWIG_fail;
37094 }
37095 {
37096 #if wxUSE_UNICODE
37097 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37098 #else
37099 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37100 #endif
37101 }
37102 return resultobj;
37103 fail:
37104 return NULL;
37105 }
37106
37107
37108 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37109 PyObject *resultobj = 0;
37110 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37111 wxString result;
37112 void *argp1 = 0 ;
37113 int res1 = 0 ;
37114 PyObject *swig_obj[1] ;
37115
37116 if (!args) SWIG_fail;
37117 swig_obj[0] = args;
37118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37119 if (!SWIG_IsOK(res1)) {
37120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37121 }
37122 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37123 {
37124 PyThreadState* __tstate = wxPyBeginAllowThreads();
37125 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37126 wxPyEndAllowThreads(__tstate);
37127 if (PyErr_Occurred()) SWIG_fail;
37128 }
37129 {
37130 #if wxUSE_UNICODE
37131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37132 #else
37133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37134 #endif
37135 }
37136 return resultobj;
37137 fail:
37138 return NULL;
37139 }
37140
37141
37142 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37143 PyObject *resultobj = 0;
37144 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37145 wxString result;
37146 void *argp1 = 0 ;
37147 int res1 = 0 ;
37148 PyObject *swig_obj[1] ;
37149
37150 if (!args) SWIG_fail;
37151 swig_obj[0] = args;
37152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37153 if (!SWIG_IsOK(res1)) {
37154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37155 }
37156 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37157 {
37158 PyThreadState* __tstate = wxPyBeginAllowThreads();
37159 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37160 wxPyEndAllowThreads(__tstate);
37161 if (PyErr_Occurred()) SWIG_fail;
37162 }
37163 {
37164 #if wxUSE_UNICODE
37165 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37166 #else
37167 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37168 #endif
37169 }
37170 return resultobj;
37171 fail:
37172 return NULL;
37173 }
37174
37175
37176 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37177 PyObject *resultobj = 0;
37178 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37179 wxString *arg2 = 0 ;
37180 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37181 wxString result;
37182 void *argp1 = 0 ;
37183 int res1 = 0 ;
37184 bool temp2 = false ;
37185 int val3 ;
37186 int ecode3 = 0 ;
37187 PyObject * obj0 = 0 ;
37188 PyObject * obj1 = 0 ;
37189 PyObject * obj2 = 0 ;
37190 char * kwnames[] = {
37191 (char *) "self",(char *) "lang",(char *) "category", NULL
37192 };
37193
37194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37196 if (!SWIG_IsOK(res1)) {
37197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37198 }
37199 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37200 {
37201 arg2 = wxString_in_helper(obj1);
37202 if (arg2 == NULL) SWIG_fail;
37203 temp2 = true;
37204 }
37205 if (obj2) {
37206 ecode3 = SWIG_AsVal_int(obj2, &val3);
37207 if (!SWIG_IsOK(ecode3)) {
37208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37209 }
37210 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37211 }
37212 {
37213 PyThreadState* __tstate = wxPyBeginAllowThreads();
37214 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37215 wxPyEndAllowThreads(__tstate);
37216 if (PyErr_Occurred()) SWIG_fail;
37217 }
37218 {
37219 #if wxUSE_UNICODE
37220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37221 #else
37222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37223 #endif
37224 }
37225 {
37226 if (temp2)
37227 delete arg2;
37228 }
37229 return resultobj;
37230 fail:
37231 {
37232 if (temp2)
37233 delete arg2;
37234 }
37235 return NULL;
37236 }
37237
37238
37239 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37240 PyObject *resultobj = 0;
37241 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37242 wxString result;
37243 void *argp1 = 0 ;
37244 int res1 = 0 ;
37245 PyObject *swig_obj[1] ;
37246
37247 if (!args) SWIG_fail;
37248 swig_obj[0] = args;
37249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37250 if (!SWIG_IsOK(res1)) {
37251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37252 }
37253 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37254 {
37255 PyThreadState* __tstate = wxPyBeginAllowThreads();
37256 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37257 wxPyEndAllowThreads(__tstate);
37258 if (PyErr_Occurred()) SWIG_fail;
37259 }
37260 {
37261 #if wxUSE_UNICODE
37262 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37263 #else
37264 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37265 #endif
37266 }
37267 return resultobj;
37268 fail:
37269 return NULL;
37270 }
37271
37272
37273 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37274 PyObject *resultobj = 0;
37275 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37276 wxString result;
37277 void *argp1 = 0 ;
37278 int res1 = 0 ;
37279 PyObject *swig_obj[1] ;
37280
37281 if (!args) SWIG_fail;
37282 swig_obj[0] = args;
37283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37284 if (!SWIG_IsOK(res1)) {
37285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37286 }
37287 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37288 {
37289 PyThreadState* __tstate = wxPyBeginAllowThreads();
37290 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37291 wxPyEndAllowThreads(__tstate);
37292 if (PyErr_Occurred()) SWIG_fail;
37293 }
37294 {
37295 #if wxUSE_UNICODE
37296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37297 #else
37298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37299 #endif
37300 }
37301 return resultobj;
37302 fail:
37303 return NULL;
37304 }
37305
37306
37307 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37308 PyObject *resultobj = 0;
37309 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37310 wxString *arg2 = 0 ;
37311 void *argp1 = 0 ;
37312 int res1 = 0 ;
37313 bool temp2 = false ;
37314 PyObject * obj0 = 0 ;
37315 PyObject * obj1 = 0 ;
37316 char * kwnames[] = {
37317 (char *) "self",(char *) "prefix", NULL
37318 };
37319
37320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37322 if (!SWIG_IsOK(res1)) {
37323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37324 }
37325 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37326 {
37327 arg2 = wxString_in_helper(obj1);
37328 if (arg2 == NULL) SWIG_fail;
37329 temp2 = true;
37330 }
37331 {
37332 PyThreadState* __tstate = wxPyBeginAllowThreads();
37333 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
37334 wxPyEndAllowThreads(__tstate);
37335 if (PyErr_Occurred()) SWIG_fail;
37336 }
37337 resultobj = SWIG_Py_Void();
37338 {
37339 if (temp2)
37340 delete arg2;
37341 }
37342 return resultobj;
37343 fail:
37344 {
37345 if (temp2)
37346 delete arg2;
37347 }
37348 return NULL;
37349 }
37350
37351
37352 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37353 PyObject *resultobj = 0;
37354 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37355 wxString result;
37356 void *argp1 = 0 ;
37357 int res1 = 0 ;
37358 PyObject *swig_obj[1] ;
37359
37360 if (!args) SWIG_fail;
37361 swig_obj[0] = args;
37362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37363 if (!SWIG_IsOK(res1)) {
37364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37365 }
37366 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37367 {
37368 PyThreadState* __tstate = wxPyBeginAllowThreads();
37369 result = wxStandardPaths_GetInstallPrefix(arg1);
37370 wxPyEndAllowThreads(__tstate);
37371 if (PyErr_Occurred()) SWIG_fail;
37372 }
37373 {
37374 #if wxUSE_UNICODE
37375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37376 #else
37377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37378 #endif
37379 }
37380 return resultobj;
37381 fail:
37382 return NULL;
37383 }
37384
37385
37386 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37387 PyObject *obj;
37388 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37389 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37390 return SWIG_Py_Void();
37391 }
37392
37393 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37394 PyObject *resultobj = 0;
37395 wxEventType arg1 ;
37396 wxPowerEvent *result = 0 ;
37397 int val1 ;
37398 int ecode1 = 0 ;
37399 PyObject * obj0 = 0 ;
37400 char * kwnames[] = {
37401 (char *) "evtType", NULL
37402 };
37403
37404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37405 ecode1 = SWIG_AsVal_int(obj0, &val1);
37406 if (!SWIG_IsOK(ecode1)) {
37407 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37408 }
37409 arg1 = static_cast< wxEventType >(val1);
37410 {
37411 PyThreadState* __tstate = wxPyBeginAllowThreads();
37412 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37413 wxPyEndAllowThreads(__tstate);
37414 if (PyErr_Occurred()) SWIG_fail;
37415 }
37416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37417 return resultobj;
37418 fail:
37419 return NULL;
37420 }
37421
37422
37423 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37424 PyObject *resultobj = 0;
37425 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37426 void *argp1 = 0 ;
37427 int res1 = 0 ;
37428 PyObject *swig_obj[1] ;
37429
37430 if (!args) SWIG_fail;
37431 swig_obj[0] = args;
37432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37433 if (!SWIG_IsOK(res1)) {
37434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37435 }
37436 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37437 {
37438 PyThreadState* __tstate = wxPyBeginAllowThreads();
37439 (arg1)->Veto();
37440 wxPyEndAllowThreads(__tstate);
37441 if (PyErr_Occurred()) SWIG_fail;
37442 }
37443 resultobj = SWIG_Py_Void();
37444 return resultobj;
37445 fail:
37446 return NULL;
37447 }
37448
37449
37450 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37451 PyObject *resultobj = 0;
37452 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37453 bool result;
37454 void *argp1 = 0 ;
37455 int res1 = 0 ;
37456 PyObject *swig_obj[1] ;
37457
37458 if (!args) SWIG_fail;
37459 swig_obj[0] = args;
37460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37461 if (!SWIG_IsOK(res1)) {
37462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37463 }
37464 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37465 {
37466 PyThreadState* __tstate = wxPyBeginAllowThreads();
37467 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37468 wxPyEndAllowThreads(__tstate);
37469 if (PyErr_Occurred()) SWIG_fail;
37470 }
37471 {
37472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37473 }
37474 return resultobj;
37475 fail:
37476 return NULL;
37477 }
37478
37479
37480 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37481 PyObject *obj;
37482 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37483 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37484 return SWIG_Py_Void();
37485 }
37486
37487 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37488 return SWIG_Python_InitShadowInstance(args);
37489 }
37490
37491 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37492 PyObject *resultobj = 0;
37493 wxPowerType result;
37494
37495 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37496 {
37497 PyThreadState* __tstate = wxPyBeginAllowThreads();
37498 result = (wxPowerType)wxGetPowerType();
37499 wxPyEndAllowThreads(__tstate);
37500 if (PyErr_Occurred()) SWIG_fail;
37501 }
37502 resultobj = SWIG_From_int(static_cast< int >(result));
37503 return resultobj;
37504 fail:
37505 return NULL;
37506 }
37507
37508
37509 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37510 PyObject *resultobj = 0;
37511 wxBatteryState result;
37512
37513 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37514 {
37515 PyThreadState* __tstate = wxPyBeginAllowThreads();
37516 result = (wxBatteryState)wxGetBatteryState();
37517 wxPyEndAllowThreads(__tstate);
37518 if (PyErr_Occurred()) SWIG_fail;
37519 }
37520 resultobj = SWIG_From_int(static_cast< int >(result));
37521 return resultobj;
37522 fail:
37523 return NULL;
37524 }
37525
37526
37527 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37528 PyObject *resultobj = 0;
37529 wxAboutDialogInfo *result = 0 ;
37530
37531 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37532 {
37533 PyThreadState* __tstate = wxPyBeginAllowThreads();
37534 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37535 wxPyEndAllowThreads(__tstate);
37536 if (PyErr_Occurred()) SWIG_fail;
37537 }
37538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37539 return resultobj;
37540 fail:
37541 return NULL;
37542 }
37543
37544
37545 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37546 PyObject *resultobj = 0;
37547 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37548 void *argp1 = 0 ;
37549 int res1 = 0 ;
37550 PyObject *swig_obj[1] ;
37551
37552 if (!args) SWIG_fail;
37553 swig_obj[0] = args;
37554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37555 if (!SWIG_IsOK(res1)) {
37556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37557 }
37558 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37559 {
37560 PyThreadState* __tstate = wxPyBeginAllowThreads();
37561 delete arg1;
37562
37563 wxPyEndAllowThreads(__tstate);
37564 if (PyErr_Occurred()) SWIG_fail;
37565 }
37566 resultobj = SWIG_Py_Void();
37567 return resultobj;
37568 fail:
37569 return NULL;
37570 }
37571
37572
37573 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37574 PyObject *resultobj = 0;
37575 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37576 wxString *arg2 = 0 ;
37577 void *argp1 = 0 ;
37578 int res1 = 0 ;
37579 bool temp2 = false ;
37580 PyObject * obj0 = 0 ;
37581 PyObject * obj1 = 0 ;
37582 char * kwnames[] = {
37583 (char *) "self",(char *) "name", NULL
37584 };
37585
37586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37588 if (!SWIG_IsOK(res1)) {
37589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37590 }
37591 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37592 {
37593 arg2 = wxString_in_helper(obj1);
37594 if (arg2 == NULL) SWIG_fail;
37595 temp2 = true;
37596 }
37597 {
37598 PyThreadState* __tstate = wxPyBeginAllowThreads();
37599 (arg1)->SetName((wxString const &)*arg2);
37600 wxPyEndAllowThreads(__tstate);
37601 if (PyErr_Occurred()) SWIG_fail;
37602 }
37603 resultobj = SWIG_Py_Void();
37604 {
37605 if (temp2)
37606 delete arg2;
37607 }
37608 return resultobj;
37609 fail:
37610 {
37611 if (temp2)
37612 delete arg2;
37613 }
37614 return NULL;
37615 }
37616
37617
37618 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37619 PyObject *resultobj = 0;
37620 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37621 wxString result;
37622 void *argp1 = 0 ;
37623 int res1 = 0 ;
37624 PyObject *swig_obj[1] ;
37625
37626 if (!args) SWIG_fail;
37627 swig_obj[0] = args;
37628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37629 if (!SWIG_IsOK(res1)) {
37630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37631 }
37632 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37633 {
37634 PyThreadState* __tstate = wxPyBeginAllowThreads();
37635 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37636 wxPyEndAllowThreads(__tstate);
37637 if (PyErr_Occurred()) SWIG_fail;
37638 }
37639 {
37640 #if wxUSE_UNICODE
37641 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37642 #else
37643 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37644 #endif
37645 }
37646 return resultobj;
37647 fail:
37648 return NULL;
37649 }
37650
37651
37652 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37653 PyObject *resultobj = 0;
37654 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37655 wxString *arg2 = 0 ;
37656 void *argp1 = 0 ;
37657 int res1 = 0 ;
37658 bool temp2 = false ;
37659 PyObject * obj0 = 0 ;
37660 PyObject * obj1 = 0 ;
37661 char * kwnames[] = {
37662 (char *) "self",(char *) "version", NULL
37663 };
37664
37665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37667 if (!SWIG_IsOK(res1)) {
37668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37669 }
37670 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37671 {
37672 arg2 = wxString_in_helper(obj1);
37673 if (arg2 == NULL) SWIG_fail;
37674 temp2 = true;
37675 }
37676 {
37677 PyThreadState* __tstate = wxPyBeginAllowThreads();
37678 (arg1)->SetVersion((wxString const &)*arg2);
37679 wxPyEndAllowThreads(__tstate);
37680 if (PyErr_Occurred()) SWIG_fail;
37681 }
37682 resultobj = SWIG_Py_Void();
37683 {
37684 if (temp2)
37685 delete arg2;
37686 }
37687 return resultobj;
37688 fail:
37689 {
37690 if (temp2)
37691 delete arg2;
37692 }
37693 return NULL;
37694 }
37695
37696
37697 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37698 PyObject *resultobj = 0;
37699 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37700 bool result;
37701 void *argp1 = 0 ;
37702 int res1 = 0 ;
37703 PyObject *swig_obj[1] ;
37704
37705 if (!args) SWIG_fail;
37706 swig_obj[0] = args;
37707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37708 if (!SWIG_IsOK(res1)) {
37709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37710 }
37711 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37712 {
37713 PyThreadState* __tstate = wxPyBeginAllowThreads();
37714 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37715 wxPyEndAllowThreads(__tstate);
37716 if (PyErr_Occurred()) SWIG_fail;
37717 }
37718 {
37719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37720 }
37721 return resultobj;
37722 fail:
37723 return NULL;
37724 }
37725
37726
37727 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37728 PyObject *resultobj = 0;
37729 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37730 wxString result;
37731 void *argp1 = 0 ;
37732 int res1 = 0 ;
37733 PyObject *swig_obj[1] ;
37734
37735 if (!args) SWIG_fail;
37736 swig_obj[0] = args;
37737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37738 if (!SWIG_IsOK(res1)) {
37739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37740 }
37741 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37742 {
37743 PyThreadState* __tstate = wxPyBeginAllowThreads();
37744 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37745 wxPyEndAllowThreads(__tstate);
37746 if (PyErr_Occurred()) SWIG_fail;
37747 }
37748 {
37749 #if wxUSE_UNICODE
37750 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37751 #else
37752 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37753 #endif
37754 }
37755 return resultobj;
37756 fail:
37757 return NULL;
37758 }
37759
37760
37761 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37762 PyObject *resultobj = 0;
37763 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37764 wxString *arg2 = 0 ;
37765 void *argp1 = 0 ;
37766 int res1 = 0 ;
37767 bool temp2 = false ;
37768 PyObject * obj0 = 0 ;
37769 PyObject * obj1 = 0 ;
37770 char * kwnames[] = {
37771 (char *) "self",(char *) "desc", NULL
37772 };
37773
37774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37776 if (!SWIG_IsOK(res1)) {
37777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37778 }
37779 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37780 {
37781 arg2 = wxString_in_helper(obj1);
37782 if (arg2 == NULL) SWIG_fail;
37783 temp2 = true;
37784 }
37785 {
37786 PyThreadState* __tstate = wxPyBeginAllowThreads();
37787 (arg1)->SetDescription((wxString const &)*arg2);
37788 wxPyEndAllowThreads(__tstate);
37789 if (PyErr_Occurred()) SWIG_fail;
37790 }
37791 resultobj = SWIG_Py_Void();
37792 {
37793 if (temp2)
37794 delete arg2;
37795 }
37796 return resultobj;
37797 fail:
37798 {
37799 if (temp2)
37800 delete arg2;
37801 }
37802 return NULL;
37803 }
37804
37805
37806 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37807 PyObject *resultobj = 0;
37808 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37809 bool result;
37810 void *argp1 = 0 ;
37811 int res1 = 0 ;
37812 PyObject *swig_obj[1] ;
37813
37814 if (!args) SWIG_fail;
37815 swig_obj[0] = args;
37816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37817 if (!SWIG_IsOK(res1)) {
37818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37819 }
37820 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37821 {
37822 PyThreadState* __tstate = wxPyBeginAllowThreads();
37823 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37824 wxPyEndAllowThreads(__tstate);
37825 if (PyErr_Occurred()) SWIG_fail;
37826 }
37827 {
37828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37829 }
37830 return resultobj;
37831 fail:
37832 return NULL;
37833 }
37834
37835
37836 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37837 PyObject *resultobj = 0;
37838 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37839 wxString result;
37840 void *argp1 = 0 ;
37841 int res1 = 0 ;
37842 PyObject *swig_obj[1] ;
37843
37844 if (!args) SWIG_fail;
37845 swig_obj[0] = args;
37846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37847 if (!SWIG_IsOK(res1)) {
37848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37849 }
37850 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37851 {
37852 PyThreadState* __tstate = wxPyBeginAllowThreads();
37853 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37854 wxPyEndAllowThreads(__tstate);
37855 if (PyErr_Occurred()) SWIG_fail;
37856 }
37857 {
37858 #if wxUSE_UNICODE
37859 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37860 #else
37861 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37862 #endif
37863 }
37864 return resultobj;
37865 fail:
37866 return NULL;
37867 }
37868
37869
37870 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37871 PyObject *resultobj = 0;
37872 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37873 wxString *arg2 = 0 ;
37874 void *argp1 = 0 ;
37875 int res1 = 0 ;
37876 bool temp2 = false ;
37877 PyObject * obj0 = 0 ;
37878 PyObject * obj1 = 0 ;
37879 char * kwnames[] = {
37880 (char *) "self",(char *) "copyright", NULL
37881 };
37882
37883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37885 if (!SWIG_IsOK(res1)) {
37886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37887 }
37888 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37889 {
37890 arg2 = wxString_in_helper(obj1);
37891 if (arg2 == NULL) SWIG_fail;
37892 temp2 = true;
37893 }
37894 {
37895 PyThreadState* __tstate = wxPyBeginAllowThreads();
37896 (arg1)->SetCopyright((wxString const &)*arg2);
37897 wxPyEndAllowThreads(__tstate);
37898 if (PyErr_Occurred()) SWIG_fail;
37899 }
37900 resultobj = SWIG_Py_Void();
37901 {
37902 if (temp2)
37903 delete arg2;
37904 }
37905 return resultobj;
37906 fail:
37907 {
37908 if (temp2)
37909 delete arg2;
37910 }
37911 return NULL;
37912 }
37913
37914
37915 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37916 PyObject *resultobj = 0;
37917 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37918 bool result;
37919 void *argp1 = 0 ;
37920 int res1 = 0 ;
37921 PyObject *swig_obj[1] ;
37922
37923 if (!args) SWIG_fail;
37924 swig_obj[0] = args;
37925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37926 if (!SWIG_IsOK(res1)) {
37927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37928 }
37929 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37930 {
37931 PyThreadState* __tstate = wxPyBeginAllowThreads();
37932 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
37933 wxPyEndAllowThreads(__tstate);
37934 if (PyErr_Occurred()) SWIG_fail;
37935 }
37936 {
37937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37938 }
37939 return resultobj;
37940 fail:
37941 return NULL;
37942 }
37943
37944
37945 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37946 PyObject *resultobj = 0;
37947 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37948 wxString result;
37949 void *argp1 = 0 ;
37950 int res1 = 0 ;
37951 PyObject *swig_obj[1] ;
37952
37953 if (!args) SWIG_fail;
37954 swig_obj[0] = args;
37955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37956 if (!SWIG_IsOK(res1)) {
37957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37958 }
37959 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37960 {
37961 PyThreadState* __tstate = wxPyBeginAllowThreads();
37962 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
37963 wxPyEndAllowThreads(__tstate);
37964 if (PyErr_Occurred()) SWIG_fail;
37965 }
37966 {
37967 #if wxUSE_UNICODE
37968 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37969 #else
37970 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37971 #endif
37972 }
37973 return resultobj;
37974 fail:
37975 return NULL;
37976 }
37977
37978
37979 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37980 PyObject *resultobj = 0;
37981 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37982 wxString *arg2 = 0 ;
37983 void *argp1 = 0 ;
37984 int res1 = 0 ;
37985 bool temp2 = false ;
37986 PyObject * obj0 = 0 ;
37987 PyObject * obj1 = 0 ;
37988 char * kwnames[] = {
37989 (char *) "self",(char *) "licence", NULL
37990 };
37991
37992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
37993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37994 if (!SWIG_IsOK(res1)) {
37995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37996 }
37997 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37998 {
37999 arg2 = wxString_in_helper(obj1);
38000 if (arg2 == NULL) SWIG_fail;
38001 temp2 = true;
38002 }
38003 {
38004 PyThreadState* __tstate = wxPyBeginAllowThreads();
38005 (arg1)->SetLicence((wxString const &)*arg2);
38006 wxPyEndAllowThreads(__tstate);
38007 if (PyErr_Occurred()) SWIG_fail;
38008 }
38009 resultobj = SWIG_Py_Void();
38010 {
38011 if (temp2)
38012 delete arg2;
38013 }
38014 return resultobj;
38015 fail:
38016 {
38017 if (temp2)
38018 delete arg2;
38019 }
38020 return NULL;
38021 }
38022
38023
38024 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38025 PyObject *resultobj = 0;
38026 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38027 wxString *arg2 = 0 ;
38028 void *argp1 = 0 ;
38029 int res1 = 0 ;
38030 bool temp2 = false ;
38031 PyObject * obj0 = 0 ;
38032 PyObject * obj1 = 0 ;
38033 char * kwnames[] = {
38034 (char *) "self",(char *) "licence", NULL
38035 };
38036
38037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
38038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38039 if (!SWIG_IsOK(res1)) {
38040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38041 }
38042 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38043 {
38044 arg2 = wxString_in_helper(obj1);
38045 if (arg2 == NULL) SWIG_fail;
38046 temp2 = true;
38047 }
38048 {
38049 PyThreadState* __tstate = wxPyBeginAllowThreads();
38050 (arg1)->SetLicense((wxString const &)*arg2);
38051 wxPyEndAllowThreads(__tstate);
38052 if (PyErr_Occurred()) SWIG_fail;
38053 }
38054 resultobj = SWIG_Py_Void();
38055 {
38056 if (temp2)
38057 delete arg2;
38058 }
38059 return resultobj;
38060 fail:
38061 {
38062 if (temp2)
38063 delete arg2;
38064 }
38065 return NULL;
38066 }
38067
38068
38069 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38070 PyObject *resultobj = 0;
38071 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38072 bool result;
38073 void *argp1 = 0 ;
38074 int res1 = 0 ;
38075 PyObject *swig_obj[1] ;
38076
38077 if (!args) SWIG_fail;
38078 swig_obj[0] = args;
38079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38080 if (!SWIG_IsOK(res1)) {
38081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38082 }
38083 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38084 {
38085 PyThreadState* __tstate = wxPyBeginAllowThreads();
38086 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38087 wxPyEndAllowThreads(__tstate);
38088 if (PyErr_Occurred()) SWIG_fail;
38089 }
38090 {
38091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38092 }
38093 return resultobj;
38094 fail:
38095 return NULL;
38096 }
38097
38098
38099 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38100 PyObject *resultobj = 0;
38101 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38102 wxString result;
38103 void *argp1 = 0 ;
38104 int res1 = 0 ;
38105 PyObject *swig_obj[1] ;
38106
38107 if (!args) SWIG_fail;
38108 swig_obj[0] = args;
38109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38110 if (!SWIG_IsOK(res1)) {
38111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38112 }
38113 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38114 {
38115 PyThreadState* __tstate = wxPyBeginAllowThreads();
38116 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38117 wxPyEndAllowThreads(__tstate);
38118 if (PyErr_Occurred()) SWIG_fail;
38119 }
38120 {
38121 #if wxUSE_UNICODE
38122 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38123 #else
38124 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38125 #endif
38126 }
38127 return resultobj;
38128 fail:
38129 return NULL;
38130 }
38131
38132
38133 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38134 PyObject *resultobj = 0;
38135 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38136 wxIcon *arg2 = 0 ;
38137 void *argp1 = 0 ;
38138 int res1 = 0 ;
38139 void *argp2 = 0 ;
38140 int res2 = 0 ;
38141 PyObject * obj0 = 0 ;
38142 PyObject * obj1 = 0 ;
38143 char * kwnames[] = {
38144 (char *) "self",(char *) "icon", NULL
38145 };
38146
38147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38149 if (!SWIG_IsOK(res1)) {
38150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38151 }
38152 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38153 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38154 if (!SWIG_IsOK(res2)) {
38155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38156 }
38157 if (!argp2) {
38158 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38159 }
38160 arg2 = reinterpret_cast< wxIcon * >(argp2);
38161 {
38162 PyThreadState* __tstate = wxPyBeginAllowThreads();
38163 (arg1)->SetIcon((wxIcon const &)*arg2);
38164 wxPyEndAllowThreads(__tstate);
38165 if (PyErr_Occurred()) SWIG_fail;
38166 }
38167 resultobj = SWIG_Py_Void();
38168 return resultobj;
38169 fail:
38170 return NULL;
38171 }
38172
38173
38174 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38175 PyObject *resultobj = 0;
38176 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38177 bool result;
38178 void *argp1 = 0 ;
38179 int res1 = 0 ;
38180 PyObject *swig_obj[1] ;
38181
38182 if (!args) SWIG_fail;
38183 swig_obj[0] = args;
38184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38185 if (!SWIG_IsOK(res1)) {
38186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38187 }
38188 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38189 {
38190 PyThreadState* __tstate = wxPyBeginAllowThreads();
38191 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38192 wxPyEndAllowThreads(__tstate);
38193 if (PyErr_Occurred()) SWIG_fail;
38194 }
38195 {
38196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38197 }
38198 return resultobj;
38199 fail:
38200 return NULL;
38201 }
38202
38203
38204 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38205 PyObject *resultobj = 0;
38206 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38207 wxIcon result;
38208 void *argp1 = 0 ;
38209 int res1 = 0 ;
38210 PyObject *swig_obj[1] ;
38211
38212 if (!args) SWIG_fail;
38213 swig_obj[0] = args;
38214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38215 if (!SWIG_IsOK(res1)) {
38216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38217 }
38218 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38219 {
38220 PyThreadState* __tstate = wxPyBeginAllowThreads();
38221 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38222 wxPyEndAllowThreads(__tstate);
38223 if (PyErr_Occurred()) SWIG_fail;
38224 }
38225 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38226 return resultobj;
38227 fail:
38228 return NULL;
38229 }
38230
38231
38232 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38233 PyObject *resultobj = 0;
38234 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38235 wxString *arg2 = 0 ;
38236 wxString const &arg3_defvalue = wxEmptyString ;
38237 wxString *arg3 = (wxString *) &arg3_defvalue ;
38238 void *argp1 = 0 ;
38239 int res1 = 0 ;
38240 bool temp2 = false ;
38241 bool temp3 = false ;
38242 PyObject * obj0 = 0 ;
38243 PyObject * obj1 = 0 ;
38244 PyObject * obj2 = 0 ;
38245 char * kwnames[] = {
38246 (char *) "self",(char *) "url",(char *) "desc", NULL
38247 };
38248
38249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38251 if (!SWIG_IsOK(res1)) {
38252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38253 }
38254 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38255 {
38256 arg2 = wxString_in_helper(obj1);
38257 if (arg2 == NULL) SWIG_fail;
38258 temp2 = true;
38259 }
38260 if (obj2) {
38261 {
38262 arg3 = wxString_in_helper(obj2);
38263 if (arg3 == NULL) SWIG_fail;
38264 temp3 = true;
38265 }
38266 }
38267 {
38268 PyThreadState* __tstate = wxPyBeginAllowThreads();
38269 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38270 wxPyEndAllowThreads(__tstate);
38271 if (PyErr_Occurred()) SWIG_fail;
38272 }
38273 resultobj = SWIG_Py_Void();
38274 {
38275 if (temp2)
38276 delete arg2;
38277 }
38278 {
38279 if (temp3)
38280 delete arg3;
38281 }
38282 return resultobj;
38283 fail:
38284 {
38285 if (temp2)
38286 delete arg2;
38287 }
38288 {
38289 if (temp3)
38290 delete arg3;
38291 }
38292 return NULL;
38293 }
38294
38295
38296 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38297 PyObject *resultobj = 0;
38298 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38299 wxString result;
38300 void *argp1 = 0 ;
38301 int res1 = 0 ;
38302 PyObject *swig_obj[1] ;
38303
38304 if (!args) SWIG_fail;
38305 swig_obj[0] = args;
38306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38307 if (!SWIG_IsOK(res1)) {
38308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38309 }
38310 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38311 {
38312 PyThreadState* __tstate = wxPyBeginAllowThreads();
38313 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38314 wxPyEndAllowThreads(__tstate);
38315 if (PyErr_Occurred()) SWIG_fail;
38316 }
38317 {
38318 #if wxUSE_UNICODE
38319 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38320 #else
38321 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38322 #endif
38323 }
38324 return resultobj;
38325 fail:
38326 return NULL;
38327 }
38328
38329
38330 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38331 PyObject *resultobj = 0;
38332 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38333 wxString result;
38334 void *argp1 = 0 ;
38335 int res1 = 0 ;
38336 PyObject *swig_obj[1] ;
38337
38338 if (!args) SWIG_fail;
38339 swig_obj[0] = args;
38340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38341 if (!SWIG_IsOK(res1)) {
38342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38343 }
38344 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38345 {
38346 PyThreadState* __tstate = wxPyBeginAllowThreads();
38347 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38348 wxPyEndAllowThreads(__tstate);
38349 if (PyErr_Occurred()) SWIG_fail;
38350 }
38351 {
38352 #if wxUSE_UNICODE
38353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38354 #else
38355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38356 #endif
38357 }
38358 return resultobj;
38359 fail:
38360 return NULL;
38361 }
38362
38363
38364 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38365 PyObject *resultobj = 0;
38366 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38367 bool result;
38368 void *argp1 = 0 ;
38369 int res1 = 0 ;
38370 PyObject *swig_obj[1] ;
38371
38372 if (!args) SWIG_fail;
38373 swig_obj[0] = args;
38374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38375 if (!SWIG_IsOK(res1)) {
38376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38377 }
38378 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38379 {
38380 PyThreadState* __tstate = wxPyBeginAllowThreads();
38381 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38382 wxPyEndAllowThreads(__tstate);
38383 if (PyErr_Occurred()) SWIG_fail;
38384 }
38385 {
38386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38387 }
38388 return resultobj;
38389 fail:
38390 return NULL;
38391 }
38392
38393
38394 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38395 PyObject *resultobj = 0;
38396 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38397 wxArrayString *arg2 = 0 ;
38398 void *argp1 = 0 ;
38399 int res1 = 0 ;
38400 bool temp2 = false ;
38401 PyObject * obj0 = 0 ;
38402 PyObject * obj1 = 0 ;
38403 char * kwnames[] = {
38404 (char *) "self",(char *) "developers", NULL
38405 };
38406
38407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38409 if (!SWIG_IsOK(res1)) {
38410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38411 }
38412 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38413 {
38414 if (! PySequence_Check(obj1)) {
38415 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38416 SWIG_fail;
38417 }
38418 arg2 = new wxArrayString;
38419 temp2 = true;
38420 int i, len=PySequence_Length(obj1);
38421 for (i=0; i<len; i++) {
38422 PyObject* item = PySequence_GetItem(obj1, i);
38423 wxString* s = wxString_in_helper(item);
38424 if (PyErr_Occurred()) SWIG_fail;
38425 arg2->Add(*s);
38426 delete s;
38427 Py_DECREF(item);
38428 }
38429 }
38430 {
38431 PyThreadState* __tstate = wxPyBeginAllowThreads();
38432 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38433 wxPyEndAllowThreads(__tstate);
38434 if (PyErr_Occurred()) SWIG_fail;
38435 }
38436 resultobj = SWIG_Py_Void();
38437 {
38438 if (temp2) delete arg2;
38439 }
38440 return resultobj;
38441 fail:
38442 {
38443 if (temp2) delete arg2;
38444 }
38445 return NULL;
38446 }
38447
38448
38449 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38450 PyObject *resultobj = 0;
38451 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38452 wxString *arg2 = 0 ;
38453 void *argp1 = 0 ;
38454 int res1 = 0 ;
38455 bool temp2 = false ;
38456 PyObject * obj0 = 0 ;
38457 PyObject * obj1 = 0 ;
38458 char * kwnames[] = {
38459 (char *) "self",(char *) "developer", NULL
38460 };
38461
38462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38464 if (!SWIG_IsOK(res1)) {
38465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38466 }
38467 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38468 {
38469 arg2 = wxString_in_helper(obj1);
38470 if (arg2 == NULL) SWIG_fail;
38471 temp2 = true;
38472 }
38473 {
38474 PyThreadState* __tstate = wxPyBeginAllowThreads();
38475 (arg1)->AddDeveloper((wxString const &)*arg2);
38476 wxPyEndAllowThreads(__tstate);
38477 if (PyErr_Occurred()) SWIG_fail;
38478 }
38479 resultobj = SWIG_Py_Void();
38480 {
38481 if (temp2)
38482 delete arg2;
38483 }
38484 return resultobj;
38485 fail:
38486 {
38487 if (temp2)
38488 delete arg2;
38489 }
38490 return NULL;
38491 }
38492
38493
38494 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38495 PyObject *resultobj = 0;
38496 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38497 bool result;
38498 void *argp1 = 0 ;
38499 int res1 = 0 ;
38500 PyObject *swig_obj[1] ;
38501
38502 if (!args) SWIG_fail;
38503 swig_obj[0] = args;
38504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38505 if (!SWIG_IsOK(res1)) {
38506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38507 }
38508 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38509 {
38510 PyThreadState* __tstate = wxPyBeginAllowThreads();
38511 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38512 wxPyEndAllowThreads(__tstate);
38513 if (PyErr_Occurred()) SWIG_fail;
38514 }
38515 {
38516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38517 }
38518 return resultobj;
38519 fail:
38520 return NULL;
38521 }
38522
38523
38524 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38525 PyObject *resultobj = 0;
38526 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38527 wxArrayString *result = 0 ;
38528 void *argp1 = 0 ;
38529 int res1 = 0 ;
38530 PyObject *swig_obj[1] ;
38531
38532 if (!args) SWIG_fail;
38533 swig_obj[0] = args;
38534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38535 if (!SWIG_IsOK(res1)) {
38536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38537 }
38538 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38539 {
38540 PyThreadState* __tstate = wxPyBeginAllowThreads();
38541 {
38542 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38543 result = (wxArrayString *) &_result_ref;
38544 }
38545 wxPyEndAllowThreads(__tstate);
38546 if (PyErr_Occurred()) SWIG_fail;
38547 }
38548 {
38549 resultobj = wxArrayString2PyList_helper(*result);
38550 }
38551 return resultobj;
38552 fail:
38553 return NULL;
38554 }
38555
38556
38557 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38558 PyObject *resultobj = 0;
38559 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38560 wxArrayString *arg2 = 0 ;
38561 void *argp1 = 0 ;
38562 int res1 = 0 ;
38563 bool temp2 = false ;
38564 PyObject * obj0 = 0 ;
38565 PyObject * obj1 = 0 ;
38566 char * kwnames[] = {
38567 (char *) "self",(char *) "docwriters", NULL
38568 };
38569
38570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38572 if (!SWIG_IsOK(res1)) {
38573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38574 }
38575 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38576 {
38577 if (! PySequence_Check(obj1)) {
38578 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38579 SWIG_fail;
38580 }
38581 arg2 = new wxArrayString;
38582 temp2 = true;
38583 int i, len=PySequence_Length(obj1);
38584 for (i=0; i<len; i++) {
38585 PyObject* item = PySequence_GetItem(obj1, i);
38586 wxString* s = wxString_in_helper(item);
38587 if (PyErr_Occurred()) SWIG_fail;
38588 arg2->Add(*s);
38589 delete s;
38590 Py_DECREF(item);
38591 }
38592 }
38593 {
38594 PyThreadState* __tstate = wxPyBeginAllowThreads();
38595 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38596 wxPyEndAllowThreads(__tstate);
38597 if (PyErr_Occurred()) SWIG_fail;
38598 }
38599 resultobj = SWIG_Py_Void();
38600 {
38601 if (temp2) delete arg2;
38602 }
38603 return resultobj;
38604 fail:
38605 {
38606 if (temp2) delete arg2;
38607 }
38608 return NULL;
38609 }
38610
38611
38612 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38613 PyObject *resultobj = 0;
38614 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38615 wxString *arg2 = 0 ;
38616 void *argp1 = 0 ;
38617 int res1 = 0 ;
38618 bool temp2 = false ;
38619 PyObject * obj0 = 0 ;
38620 PyObject * obj1 = 0 ;
38621 char * kwnames[] = {
38622 (char *) "self",(char *) "docwriter", NULL
38623 };
38624
38625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38627 if (!SWIG_IsOK(res1)) {
38628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38629 }
38630 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38631 {
38632 arg2 = wxString_in_helper(obj1);
38633 if (arg2 == NULL) SWIG_fail;
38634 temp2 = true;
38635 }
38636 {
38637 PyThreadState* __tstate = wxPyBeginAllowThreads();
38638 (arg1)->AddDocWriter((wxString const &)*arg2);
38639 wxPyEndAllowThreads(__tstate);
38640 if (PyErr_Occurred()) SWIG_fail;
38641 }
38642 resultobj = SWIG_Py_Void();
38643 {
38644 if (temp2)
38645 delete arg2;
38646 }
38647 return resultobj;
38648 fail:
38649 {
38650 if (temp2)
38651 delete arg2;
38652 }
38653 return NULL;
38654 }
38655
38656
38657 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38658 PyObject *resultobj = 0;
38659 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38660 bool result;
38661 void *argp1 = 0 ;
38662 int res1 = 0 ;
38663 PyObject *swig_obj[1] ;
38664
38665 if (!args) SWIG_fail;
38666 swig_obj[0] = args;
38667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38668 if (!SWIG_IsOK(res1)) {
38669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38670 }
38671 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38672 {
38673 PyThreadState* __tstate = wxPyBeginAllowThreads();
38674 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38675 wxPyEndAllowThreads(__tstate);
38676 if (PyErr_Occurred()) SWIG_fail;
38677 }
38678 {
38679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38680 }
38681 return resultobj;
38682 fail:
38683 return NULL;
38684 }
38685
38686
38687 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38688 PyObject *resultobj = 0;
38689 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38690 wxArrayString *result = 0 ;
38691 void *argp1 = 0 ;
38692 int res1 = 0 ;
38693 PyObject *swig_obj[1] ;
38694
38695 if (!args) SWIG_fail;
38696 swig_obj[0] = args;
38697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38698 if (!SWIG_IsOK(res1)) {
38699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38700 }
38701 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38702 {
38703 PyThreadState* __tstate = wxPyBeginAllowThreads();
38704 {
38705 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38706 result = (wxArrayString *) &_result_ref;
38707 }
38708 wxPyEndAllowThreads(__tstate);
38709 if (PyErr_Occurred()) SWIG_fail;
38710 }
38711 {
38712 resultobj = wxArrayString2PyList_helper(*result);
38713 }
38714 return resultobj;
38715 fail:
38716 return NULL;
38717 }
38718
38719
38720 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38721 PyObject *resultobj = 0;
38722 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38723 wxArrayString *arg2 = 0 ;
38724 void *argp1 = 0 ;
38725 int res1 = 0 ;
38726 bool temp2 = false ;
38727 PyObject * obj0 = 0 ;
38728 PyObject * obj1 = 0 ;
38729 char * kwnames[] = {
38730 (char *) "self",(char *) "artists", NULL
38731 };
38732
38733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38735 if (!SWIG_IsOK(res1)) {
38736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38737 }
38738 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38739 {
38740 if (! PySequence_Check(obj1)) {
38741 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38742 SWIG_fail;
38743 }
38744 arg2 = new wxArrayString;
38745 temp2 = true;
38746 int i, len=PySequence_Length(obj1);
38747 for (i=0; i<len; i++) {
38748 PyObject* item = PySequence_GetItem(obj1, i);
38749 wxString* s = wxString_in_helper(item);
38750 if (PyErr_Occurred()) SWIG_fail;
38751 arg2->Add(*s);
38752 delete s;
38753 Py_DECREF(item);
38754 }
38755 }
38756 {
38757 PyThreadState* __tstate = wxPyBeginAllowThreads();
38758 (arg1)->SetArtists((wxArrayString const &)*arg2);
38759 wxPyEndAllowThreads(__tstate);
38760 if (PyErr_Occurred()) SWIG_fail;
38761 }
38762 resultobj = SWIG_Py_Void();
38763 {
38764 if (temp2) delete arg2;
38765 }
38766 return resultobj;
38767 fail:
38768 {
38769 if (temp2) delete arg2;
38770 }
38771 return NULL;
38772 }
38773
38774
38775 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38776 PyObject *resultobj = 0;
38777 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38778 wxString *arg2 = 0 ;
38779 void *argp1 = 0 ;
38780 int res1 = 0 ;
38781 bool temp2 = false ;
38782 PyObject * obj0 = 0 ;
38783 PyObject * obj1 = 0 ;
38784 char * kwnames[] = {
38785 (char *) "self",(char *) "artist", NULL
38786 };
38787
38788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38790 if (!SWIG_IsOK(res1)) {
38791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38792 }
38793 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38794 {
38795 arg2 = wxString_in_helper(obj1);
38796 if (arg2 == NULL) SWIG_fail;
38797 temp2 = true;
38798 }
38799 {
38800 PyThreadState* __tstate = wxPyBeginAllowThreads();
38801 (arg1)->AddArtist((wxString const &)*arg2);
38802 wxPyEndAllowThreads(__tstate);
38803 if (PyErr_Occurred()) SWIG_fail;
38804 }
38805 resultobj = SWIG_Py_Void();
38806 {
38807 if (temp2)
38808 delete arg2;
38809 }
38810 return resultobj;
38811 fail:
38812 {
38813 if (temp2)
38814 delete arg2;
38815 }
38816 return NULL;
38817 }
38818
38819
38820 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38821 PyObject *resultobj = 0;
38822 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38823 bool result;
38824 void *argp1 = 0 ;
38825 int res1 = 0 ;
38826 PyObject *swig_obj[1] ;
38827
38828 if (!args) SWIG_fail;
38829 swig_obj[0] = args;
38830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38831 if (!SWIG_IsOK(res1)) {
38832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38833 }
38834 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38835 {
38836 PyThreadState* __tstate = wxPyBeginAllowThreads();
38837 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38838 wxPyEndAllowThreads(__tstate);
38839 if (PyErr_Occurred()) SWIG_fail;
38840 }
38841 {
38842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38843 }
38844 return resultobj;
38845 fail:
38846 return NULL;
38847 }
38848
38849
38850 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38851 PyObject *resultobj = 0;
38852 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38853 wxArrayString *result = 0 ;
38854 void *argp1 = 0 ;
38855 int res1 = 0 ;
38856 PyObject *swig_obj[1] ;
38857
38858 if (!args) SWIG_fail;
38859 swig_obj[0] = args;
38860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38861 if (!SWIG_IsOK(res1)) {
38862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38863 }
38864 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38865 {
38866 PyThreadState* __tstate = wxPyBeginAllowThreads();
38867 {
38868 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38869 result = (wxArrayString *) &_result_ref;
38870 }
38871 wxPyEndAllowThreads(__tstate);
38872 if (PyErr_Occurred()) SWIG_fail;
38873 }
38874 {
38875 resultobj = wxArrayString2PyList_helper(*result);
38876 }
38877 return resultobj;
38878 fail:
38879 return NULL;
38880 }
38881
38882
38883 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38884 PyObject *resultobj = 0;
38885 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38886 wxArrayString *arg2 = 0 ;
38887 void *argp1 = 0 ;
38888 int res1 = 0 ;
38889 bool temp2 = false ;
38890 PyObject * obj0 = 0 ;
38891 PyObject * obj1 = 0 ;
38892 char * kwnames[] = {
38893 (char *) "self",(char *) "translators", NULL
38894 };
38895
38896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38898 if (!SWIG_IsOK(res1)) {
38899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38900 }
38901 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38902 {
38903 if (! PySequence_Check(obj1)) {
38904 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38905 SWIG_fail;
38906 }
38907 arg2 = new wxArrayString;
38908 temp2 = true;
38909 int i, len=PySequence_Length(obj1);
38910 for (i=0; i<len; i++) {
38911 PyObject* item = PySequence_GetItem(obj1, i);
38912 wxString* s = wxString_in_helper(item);
38913 if (PyErr_Occurred()) SWIG_fail;
38914 arg2->Add(*s);
38915 delete s;
38916 Py_DECREF(item);
38917 }
38918 }
38919 {
38920 PyThreadState* __tstate = wxPyBeginAllowThreads();
38921 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38922 wxPyEndAllowThreads(__tstate);
38923 if (PyErr_Occurred()) SWIG_fail;
38924 }
38925 resultobj = SWIG_Py_Void();
38926 {
38927 if (temp2) delete arg2;
38928 }
38929 return resultobj;
38930 fail:
38931 {
38932 if (temp2) delete arg2;
38933 }
38934 return NULL;
38935 }
38936
38937
38938 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38939 PyObject *resultobj = 0;
38940 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38941 wxString *arg2 = 0 ;
38942 void *argp1 = 0 ;
38943 int res1 = 0 ;
38944 bool temp2 = false ;
38945 PyObject * obj0 = 0 ;
38946 PyObject * obj1 = 0 ;
38947 char * kwnames[] = {
38948 (char *) "self",(char *) "translator", NULL
38949 };
38950
38951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
38952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38953 if (!SWIG_IsOK(res1)) {
38954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38955 }
38956 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38957 {
38958 arg2 = wxString_in_helper(obj1);
38959 if (arg2 == NULL) SWIG_fail;
38960 temp2 = true;
38961 }
38962 {
38963 PyThreadState* __tstate = wxPyBeginAllowThreads();
38964 (arg1)->AddTranslator((wxString const &)*arg2);
38965 wxPyEndAllowThreads(__tstate);
38966 if (PyErr_Occurred()) SWIG_fail;
38967 }
38968 resultobj = SWIG_Py_Void();
38969 {
38970 if (temp2)
38971 delete arg2;
38972 }
38973 return resultobj;
38974 fail:
38975 {
38976 if (temp2)
38977 delete arg2;
38978 }
38979 return NULL;
38980 }
38981
38982
38983 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38984 PyObject *resultobj = 0;
38985 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38986 bool result;
38987 void *argp1 = 0 ;
38988 int res1 = 0 ;
38989 PyObject *swig_obj[1] ;
38990
38991 if (!args) SWIG_fail;
38992 swig_obj[0] = args;
38993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38994 if (!SWIG_IsOK(res1)) {
38995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38996 }
38997 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38998 {
38999 PyThreadState* __tstate = wxPyBeginAllowThreads();
39000 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
39001 wxPyEndAllowThreads(__tstate);
39002 if (PyErr_Occurred()) SWIG_fail;
39003 }
39004 {
39005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39006 }
39007 return resultobj;
39008 fail:
39009 return NULL;
39010 }
39011
39012
39013 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39014 PyObject *resultobj = 0;
39015 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39016 wxArrayString *result = 0 ;
39017 void *argp1 = 0 ;
39018 int res1 = 0 ;
39019 PyObject *swig_obj[1] ;
39020
39021 if (!args) SWIG_fail;
39022 swig_obj[0] = args;
39023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39024 if (!SWIG_IsOK(res1)) {
39025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39026 }
39027 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39028 {
39029 PyThreadState* __tstate = wxPyBeginAllowThreads();
39030 {
39031 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
39032 result = (wxArrayString *) &_result_ref;
39033 }
39034 wxPyEndAllowThreads(__tstate);
39035 if (PyErr_Occurred()) SWIG_fail;
39036 }
39037 {
39038 resultobj = wxArrayString2PyList_helper(*result);
39039 }
39040 return resultobj;
39041 fail:
39042 return NULL;
39043 }
39044
39045
39046 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39047 PyObject *resultobj = 0;
39048 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39049 bool result;
39050 void *argp1 = 0 ;
39051 int res1 = 0 ;
39052 PyObject *swig_obj[1] ;
39053
39054 if (!args) SWIG_fail;
39055 swig_obj[0] = args;
39056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39057 if (!SWIG_IsOK(res1)) {
39058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39059 }
39060 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39061 {
39062 PyThreadState* __tstate = wxPyBeginAllowThreads();
39063 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39064 wxPyEndAllowThreads(__tstate);
39065 if (PyErr_Occurred()) SWIG_fail;
39066 }
39067 {
39068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39069 }
39070 return resultobj;
39071 fail:
39072 return NULL;
39073 }
39074
39075
39076 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39077 PyObject *resultobj = 0;
39078 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39079 wxString result;
39080 void *argp1 = 0 ;
39081 int res1 = 0 ;
39082 PyObject *swig_obj[1] ;
39083
39084 if (!args) SWIG_fail;
39085 swig_obj[0] = args;
39086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39087 if (!SWIG_IsOK(res1)) {
39088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39089 }
39090 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39091 {
39092 PyThreadState* __tstate = wxPyBeginAllowThreads();
39093 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39094 wxPyEndAllowThreads(__tstate);
39095 if (PyErr_Occurred()) SWIG_fail;
39096 }
39097 {
39098 #if wxUSE_UNICODE
39099 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39100 #else
39101 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39102 #endif
39103 }
39104 return resultobj;
39105 fail:
39106 return NULL;
39107 }
39108
39109
39110 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39111 PyObject *obj;
39112 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39113 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39114 return SWIG_Py_Void();
39115 }
39116
39117 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39118 return SWIG_Python_InitShadowInstance(args);
39119 }
39120
39121 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39122 PyObject *resultobj = 0;
39123 wxAboutDialogInfo *arg1 = 0 ;
39124 void *argp1 = 0 ;
39125 int res1 = 0 ;
39126 PyObject * obj0 = 0 ;
39127 char * kwnames[] = {
39128 (char *) "info", NULL
39129 };
39130
39131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39132 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39133 if (!SWIG_IsOK(res1)) {
39134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39135 }
39136 if (!argp1) {
39137 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39138 }
39139 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39140 {
39141 PyThreadState* __tstate = wxPyBeginAllowThreads();
39142 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39143 wxPyEndAllowThreads(__tstate);
39144 if (PyErr_Occurred()) SWIG_fail;
39145 }
39146 resultobj = SWIG_Py_Void();
39147 return resultobj;
39148 fail:
39149 return NULL;
39150 }
39151
39152
39153 static PyMethodDef SwigMethods[] = {
39154 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39155 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39156 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39157 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39158 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39159 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39160 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39161 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39162 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39163 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39164 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39165 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39166 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39167 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39168 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39169 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39170 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39171 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39172 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39173 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39174 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39175 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39176 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39177 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39178 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39179 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
39180 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39181 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39182 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39183 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
39184 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39185 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39186 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39187 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39188 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39189 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39190 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39191 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39192 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39193 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39194 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39195 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39196 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39197 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39198 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39199 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39200 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39201 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39202 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39203 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39204 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39205 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39206 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39207 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39208 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39209 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39210 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39211 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39212 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39213 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39214 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39215 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39216 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39217 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39218 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39219 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39220 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39221 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39222 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39223 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39224 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39225 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39226 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39227 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39228 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39229 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39230 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39231 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39232 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39233 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39234 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39235 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39236 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39237 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39238 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39239 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39240 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39241 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39242 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39243 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39244 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39245 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39246 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39247 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39248 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39249 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39250 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39251 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39252 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39253 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39254 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39255 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39256 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39257 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39258 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39259 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39260 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39261 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39262 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39263 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39264 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39265 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39266 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39267 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39268 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39269 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39270 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39271 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39272 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39273 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39274 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39275 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39276 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39277 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39278 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39279 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39280 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39281 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39282 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39283 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39284 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39285 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39286 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39287 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39288 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39289 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39290 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39291 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39292 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39293 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39294 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39295 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39296 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39297 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39298 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39299 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39300 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39301 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39302 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39303 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39304 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39305 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39306 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39307 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39308 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39309 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39310 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39311 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39312 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39313 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39314 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39315 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39316 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39317 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39318 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39319 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39320 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39321 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39322 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39323 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39324 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39325 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39326 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39327 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39328 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39329 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39330 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39331 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39332 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39333 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39334 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39335 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39336 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39337 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39338 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39339 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39340 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39341 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39342 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39343 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39344 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39345 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39346 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39347 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39348 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39349 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39350 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39351 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39352 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39353 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39354 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39355 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39356 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39357 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39358 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39359 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39360 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39361 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39362 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39363 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39364 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39365 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39366 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39367 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39368 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39369 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39370 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39371 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39372 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39373 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39374 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39375 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39376 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39377 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39378 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39379 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39380 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39381 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39382 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39383 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39384 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39385 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39386 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39387 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39388 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39389 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39390 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39391 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39392 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39393 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39394 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39395 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39396 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39397 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39398 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39399 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39400 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39401 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39402 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39403 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39404 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39405 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39406 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39407 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39408 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39409 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39410 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39411 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39412 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39413 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39414 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39415 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39416 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39417 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39418 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39419 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39420 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39421 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39422 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39423 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39424 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39425 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39426 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39427 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39428 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39429 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39430 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39431 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39432 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39433 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39434 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39435 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39436 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39437 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39438 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39439 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39440 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39441 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39442 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39443 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39444 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39445 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39446 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39447 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39448 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39449 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39450 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39451 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39452 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39453 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39454 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39455 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39456 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39457 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39458 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39459 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39460 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39461 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39462 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39463 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39464 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39465 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39466 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39467 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39468 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39469 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39470 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39471 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39472 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39473 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39474 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39475 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39476 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39477 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39478 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39479 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39480 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39481 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39482 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39483 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39484 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39485 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39486 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39487 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39488 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39489 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39490 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39491 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39492 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39493 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39494 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39495 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39496 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39497 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39498 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39499 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39500 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39501 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39502 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39503 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39504 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39505 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39506 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39507 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39508 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39509 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39510 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39511 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39512 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39513 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39514 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39515 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39516 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39517 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39518 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39519 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39520 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39521 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39522 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39523 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39524 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39525 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39526 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39527 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39528 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39529 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39530 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39531 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39532 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39533 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39534 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39535 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39536 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39537 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39538 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39539 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39540 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39541 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39542 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39543 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39544 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39545 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39546 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39547 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39548 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39549 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39550 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39551 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39552 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39553 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39554 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39555 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39556 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39557 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39558 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39559 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39560 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39561 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39562 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39563 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39564 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39565 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39566 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39567 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39568 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39569 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39570 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39571 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39572 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39573 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39574 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39575 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39576 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39577 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39578 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39579 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39580 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39581 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39582 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39583 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39584 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39585 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39586 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39587 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39588 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39589 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39590 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39591 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39592 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39593 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39594 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39595 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39596 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39597 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39598 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39599 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39600 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39601 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39602 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39603 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39604 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39605 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39606 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39607 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39608 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39609 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39610 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39611 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39612 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39613 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39614 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39615 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39616 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39617 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39618 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39619 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39620 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39621 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39622 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39623 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39624 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39625 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39626 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39627 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39628 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39629 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39630 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39631 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39632 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39633 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39634 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39635 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39636 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39637 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39638 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39639 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39640 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39641 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39642 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39643 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39644 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39645 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39646 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39647 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39648 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39649 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39650 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39651 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39652 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39653 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39654 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39655 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39656 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39657 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39658 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39659 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39660 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39661 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39662 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39663 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39664 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39665 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39666 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39667 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39668 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39669 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39671 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39672 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39673 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39674 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39675 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39676 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39677 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39678 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39679 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39680 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39681 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39682 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39683 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39684 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39685 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39686 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39687 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39688 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39689 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39690 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39691 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39692 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39693 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39694 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39695 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39696 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39697 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39698 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39699 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39700 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39701 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39702 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39703 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39704 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39705 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39706 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39707 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39708 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39709 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39710 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39711 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39713 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39715 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39716 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39719 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39720 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39721 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39722 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39723 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39724 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39725 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39726 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39727 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39728 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39729 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39730 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39732 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39733 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39734 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39735 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39736 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39737 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39738 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39739 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39740 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39741 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39742 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39743 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39744 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39745 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39747 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39748 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39749 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39750 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39751 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39754 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39755 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39757 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39759 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39761 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39762 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39763 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39764 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39765 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39766 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39767 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39768 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39769 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39770 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39771 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39772 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39773 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39774 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39775 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39776 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39777 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39778 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39779 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39780 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39781 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39782 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39783 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39784 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39785 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39786 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39787 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39788 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39789 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39790 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39791 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39792 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39793 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39801 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39802 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39803 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39804 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39805 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39807 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39808 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39809 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39810 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39811 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39812 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39814 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39815 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39816 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39817 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39818 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39819 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39821 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39822 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39823 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39824 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39825 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39826 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39827 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39828 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39829 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39830 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39831 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39832 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39833 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39834 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39835 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39836 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39837 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39838 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39839 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39840 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39841 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39842 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39843 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39844 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39845 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39846 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39847 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39848 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39849 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39850 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39851 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39852 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39853 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39854 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39855 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39856 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39857 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39858 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39859 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39860 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39861 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39862 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39863 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39864 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39865 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39866 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39867 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39868 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39869 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39870 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39871 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39872 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39873 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39874 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39875 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39876 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39877 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39878 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39879 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39880 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39881 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39882 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39883 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39884 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39885 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39886 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39887 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39888 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39889 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39890 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39891 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39892 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39893 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39894 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39895 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39896 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39897 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39898 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39899 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39900 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39901 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39902 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39903 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39904 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39905 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39906 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39907 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39908 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39909 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39910 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39911 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39912 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39913 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39914 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39915 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39916 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39917 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39918 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39919 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39920 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39921 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39922 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39923 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
39924 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39925 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39926 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39927 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
39928 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39929 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
39930 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39931 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
39932 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
39933 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
39934 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39935 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
39936 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39937 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
39938 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39939 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
39940 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
39941 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39942 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
39943 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
39944 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39945 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39946 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
39947 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
39948 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
39949 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39950 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
39951 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
39952 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
39953 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39954 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
39955 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
39956 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
39957 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
39958 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
39959 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39960 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39961 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
39962 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
39963 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39964 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
39965 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39966 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
39967 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
39968 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39969 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39970 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
39971 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
39972 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
39973 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
39974 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
39975 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
39976 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
39977 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
39978 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39979 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
39980 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
39981 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
39982 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
39983 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39984 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
39985 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
39986 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
39987 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
39988 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
39989 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
39990 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
39991 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
39992 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
39993 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
39994 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
39995 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39996 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
39997 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39998 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
39999 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
40000 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40001 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
40002 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
40003 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
40004 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
40005 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40006 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
40007 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
40008 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40009 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40010 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40011 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
40012 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40013 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
40014 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
40015 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
40016 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
40017 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
40018 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
40019 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40020 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
40021 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40022 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40023 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
40024 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40025 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40026 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
40027 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
40028 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
40029 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40030 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
40031 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40032 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40033 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
40034 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40035 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40036 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
40037 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
40038 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
40039 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
40040 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
40041 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
40042 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
40043 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
40044 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40045 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40046 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
40047 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
40048 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
40049 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
40050 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
40051 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
40052 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
40053 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
40054 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
40055 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
40056 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
40057 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
40058 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
40059 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
40060 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
40061 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40062 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40063 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40064 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40065 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40066 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40067 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40068 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40069 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40070 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40071 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40072 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40073 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40074 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40075 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40076 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40077 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40078 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40079 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40080 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40081 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40082 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40083 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40084 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40085 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40086 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40087 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40088 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40089 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40090 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40091 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40092 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40093 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40094 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40095 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40096 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40097 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40098 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40099 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40100 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40101 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40102 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40103 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40104 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40105 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40106 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40107 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40108 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40109 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40110 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40111 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40112 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40113 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40114 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40115 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40116 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40117 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40118 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40119 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40120 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40121 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40122 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40123 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40124 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40125 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40126 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40127 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40128 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40129 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40130 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40131 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40132 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40133 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40134 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40135 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40136 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40137 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40138 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40139 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40140 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40141 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40142 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40143 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40144 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40145 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40146 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40147 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40148 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40149 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40150 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40151 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40152 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40153 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40154 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40155 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40156 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40157 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40158 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40159 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40160 { NULL, NULL, 0, NULL }
40161 };
40162
40163
40164 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40165
40166 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40167 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40168 }
40169 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40170 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40171 }
40172 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40173 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40174 }
40175 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40176 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40177 }
40178 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40179 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40180 }
40181 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40182 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40183 }
40184 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40185 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40186 }
40187 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40188 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40189 }
40190 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40191 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40192 }
40193 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40194 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40195 }
40196 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40197 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40198 }
40199 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40200 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40201 }
40202 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40203 return (void *)((wxEvent *) ((wxPyEvent *) x));
40204 }
40205 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40206 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40207 }
40208 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40209 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40210 }
40211 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40212 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40213 }
40214 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40215 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40216 }
40217 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40218 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40219 }
40220 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40221 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40222 }
40223 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40224 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40225 }
40226 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40227 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40228 }
40229 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40230 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40231 }
40232 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40233 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40234 }
40235 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40236 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40237 }
40238 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40239 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40240 }
40241 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40242 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40243 }
40244 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40245 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40246 }
40247 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40248 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40249 }
40250 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40251 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40252 }
40253 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40254 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40255 }
40256 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40257 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40258 }
40259 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40260 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40261 }
40262 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40263 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40264 }
40265 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40266 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40267 }
40268 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40269 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40270 }
40271 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40272 return (void *)((wxEvent *) ((wxShowEvent *) x));
40273 }
40274 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40275 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40276 }
40277 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40278 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40279 }
40280 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40281 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40282 }
40283 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40284 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40285 }
40286 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40287 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40288 }
40289 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40290 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40291 }
40292 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40293 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40294 }
40295 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40296 return (void *)((wxConfigBase *) ((wxConfig *) x));
40297 }
40298 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40299 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40300 }
40301 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40302 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40303 }
40304 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40305 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40306 }
40307 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40308 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40309 }
40310 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40311 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40312 }
40313 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40314 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40315 }
40316 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40317 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40318 }
40319 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40320 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40321 }
40322 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40323 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40324 }
40325 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40326 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40327 }
40328 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40329 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40330 }
40331 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40332 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40333 }
40334 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40335 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40336 }
40337 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40338 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40339 }
40340 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40341 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40342 }
40343 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40344 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40345 }
40346 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40347 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40348 }
40349 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40350 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40351 }
40352 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40353 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40354 }
40355 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40356 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40357 }
40358 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40359 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40360 }
40361 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40362 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40363 }
40364 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40365 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40366 }
40367 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40368 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40369 }
40370 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40371 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40372 }
40373 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40374 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40375 }
40376 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40377 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40378 }
40379 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40380 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40381 }
40382 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40383 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40384 }
40385 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40386 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40387 }
40388 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40389 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40390 }
40391 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40392 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40393 }
40394 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40395 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40396 }
40397 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40398 return (void *)((wxObject *) ((wxSizerItem *) x));
40399 }
40400 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40401 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40402 }
40403 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40404 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40405 }
40406 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40407 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40408 }
40409 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40410 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40411 }
40412 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40413 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40414 }
40415 static void *_p_wxSizerTo_p_wxObject(void *x) {
40416 return (void *)((wxObject *) ((wxSizer *) x));
40417 }
40418 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40419 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40420 }
40421 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40422 return (void *)((wxObject *) ((wxFileHistory *) x));
40423 }
40424 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40425 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40426 }
40427 static void *_p_wxEventTo_p_wxObject(void *x) {
40428 return (void *)((wxObject *) ((wxEvent *) x));
40429 }
40430 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40431 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40432 }
40433 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40434 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40435 }
40436 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40437 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40438 }
40439 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40440 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40441 }
40442 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40443 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40444 }
40445 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40446 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40447 }
40448 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40449 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40450 }
40451 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40452 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40453 }
40454 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40455 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40456 }
40457 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40458 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40459 }
40460 static void *_p_wxControlTo_p_wxObject(void *x) {
40461 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40462 }
40463 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40464 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40465 }
40466 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40467 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40468 }
40469 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40470 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40471 }
40472 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40473 return (void *)((wxObject *) ((wxFSFile *) x));
40474 }
40475 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40476 return (void *)((wxObject *) ((wxClipboard *) x));
40477 }
40478 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40479 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40480 }
40481 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40482 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40483 }
40484 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40485 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40486 }
40487 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40488 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40489 }
40490 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40491 return (void *)((wxObject *) ((wxToolTip *) x));
40492 }
40493 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40494 return (void *)((wxObject *) ((wxMenuItem *) x));
40495 }
40496 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40497 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40498 }
40499 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40500 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40501 }
40502 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40503 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40504 }
40505 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40506 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40507 }
40508 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40509 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40510 }
40511 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40512 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40513 }
40514 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40515 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40516 }
40517 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40518 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40519 }
40520 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40521 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40522 }
40523 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40524 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40525 }
40526 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40527 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40528 }
40529 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40530 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40531 }
40532 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40533 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40534 }
40535 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40536 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40537 }
40538 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40539 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40540 }
40541 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40542 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40543 }
40544 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40545 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40546 }
40547 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40548 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40549 }
40550 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40551 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40552 }
40553 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40554 return (void *)((wxObject *) ((wxImageHandler *) x));
40555 }
40556 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40557 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40558 }
40559 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40560 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40561 }
40562 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
40563 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
40564 }
40565 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40566 return (void *)((wxObject *) ((wxEvtHandler *) x));
40567 }
40568 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40569 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40570 }
40571 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40572 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40573 }
40574 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40575 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40576 }
40577 static void *_p_wxImageTo_p_wxObject(void *x) {
40578 return (void *)((wxObject *) ((wxImage *) x));
40579 }
40580 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40581 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40582 }
40583 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40584 return (void *)((wxObject *) ((wxSystemOptions *) x));
40585 }
40586 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40587 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40588 }
40589 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40590 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40591 }
40592 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40593 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40594 }
40595 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40596 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40597 }
40598 static void *_p_wxWindowTo_p_wxObject(void *x) {
40599 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40600 }
40601 static void *_p_wxMenuTo_p_wxObject(void *x) {
40602 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40603 }
40604 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40605 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40606 }
40607 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40608 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40609 }
40610 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40611 return (void *)((wxObject *) ((wxFileSystem *) x));
40612 }
40613 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40614 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40615 }
40616 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40617 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40618 }
40619 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40620 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40621 }
40622 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40623 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40624 }
40625 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40626 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40627 }
40628 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40629 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40630 }
40631 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40632 return (void *)((wxObject *) ((wxBusyInfo *) x));
40633 }
40634 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40635 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40636 }
40637 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40638 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40639 }
40640 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40641 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40642 }
40643 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40644 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40645 }
40646 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40647 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40648 }
40649 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40650 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40651 }
40652 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40653 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40654 }
40655 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40656 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40657 }
40658 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40659 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40660 }
40661 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40662 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40663 }
40664 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40665 return (void *)((wxLog *) ((wxLogBuffer *) x));
40666 }
40667 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40668 return (void *)((wxLog *) ((wxLogStderr *) x));
40669 }
40670 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40671 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40672 }
40673 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40674 return (void *)((wxLog *) ((wxLogWindow *) x));
40675 }
40676 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40677 return (void *)((wxLog *) ((wxLogChain *) x));
40678 }
40679 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40680 return (void *)((wxLog *) ((wxLogGui *) x));
40681 }
40682 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40683 return (void *)((wxLog *) ((wxPyLog *) x));
40684 }
40685 static void *_p_wxControlTo_p_wxWindow(void *x) {
40686 return (void *)((wxWindow *) ((wxControl *) x));
40687 }
40688 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40689 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40690 }
40691 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40692 return (void *)((wxWindow *) ((wxMenuBar *) x));
40693 }
40694 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40695 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40696 }
40697 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40698 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40699 }
40700 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40701 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};
40702 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40703 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40704 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40705 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40706 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40707 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40708 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40709 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40710 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40711 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40712 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40713 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40714 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40715 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40716 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40717 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40718 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40719 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40720 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40721 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40722 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40723 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40724 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40725 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40726 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40727 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40728 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40729 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40730 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40731 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40732 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40733 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40734 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40735 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40736 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40737 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40738 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40739 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40740 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40741 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40742 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40743 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40744 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40745 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40746 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40747 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40748 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40749 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40750 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40751 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40752 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40753 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40754 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40755 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40756 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40757 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40758 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40759 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40760 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40761 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40762 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40763 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40764 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40765 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40766 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40767 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40768 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40769 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40770 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40771 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40772 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40773 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40774 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40775 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40776 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40777 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40778 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40779 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40780 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40781 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40782 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40783 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40784 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40785 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40786 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40787 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40788 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40789 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40790 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40791 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40792 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40793 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40794 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40795 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40796 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40797 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40798 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40799 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
40800 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40801 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40802 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40803 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40804 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40805 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40806 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40807 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40808 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40809 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40810 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40811 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40812 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40813 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40814 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40815 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40816 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40817 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40818 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40819 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40820 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
40821 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40822 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40823 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40824 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40825 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40826 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40827 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40828 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40829 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40830 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40831 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40832 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40833 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40834 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40835 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40836 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40837 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40838 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40839 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40840 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40841 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40842 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40843 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40844 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40845 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40846 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40847 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40848 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40849 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40850 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40851 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40852 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40853 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40854 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40855 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40856 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40857 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40858 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40859 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40860 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40861 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40862 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40863 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40864 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40865 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40866 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40867 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40868 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40869 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40870 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40871 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40872 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40873 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40874 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40875
40876 static swig_type_info *swig_type_initial[] = {
40877 &_swigt__p_char,
40878 &_swigt__p_form_ops_t,
40879 &_swigt__p_int,
40880 &_swigt__p_unsigned_char,
40881 &_swigt__p_unsigned_int,
40882 &_swigt__p_unsigned_long,
40883 &_swigt__p_void,
40884 &_swigt__p_wxANIHandler,
40885 &_swigt__p_wxAboutDialogInfo,
40886 &_swigt__p_wxAcceleratorTable,
40887 &_swigt__p_wxActivateEvent,
40888 &_swigt__p_wxArrayString,
40889 &_swigt__p_wxBMPHandler,
40890 &_swigt__p_wxBitmap,
40891 &_swigt__p_wxBitmapDataObject,
40892 &_swigt__p_wxBoxSizer,
40893 &_swigt__p_wxBusyCursor,
40894 &_swigt__p_wxBusyInfo,
40895 &_swigt__p_wxCURHandler,
40896 &_swigt__p_wxCaret,
40897 &_swigt__p_wxChar,
40898 &_swigt__p_wxChildFocusEvent,
40899 &_swigt__p_wxClipboard,
40900 &_swigt__p_wxClipboardLocker,
40901 &_swigt__p_wxClipboardTextEvent,
40902 &_swigt__p_wxCloseEvent,
40903 &_swigt__p_wxColour,
40904 &_swigt__p_wxCommandEvent,
40905 &_swigt__p_wxConfig,
40906 &_swigt__p_wxConfigBase,
40907 &_swigt__p_wxConfigPathChanger,
40908 &_swigt__p_wxContextMenuEvent,
40909 &_swigt__p_wxControl,
40910 &_swigt__p_wxControlWithItems,
40911 &_swigt__p_wxCursor,
40912 &_swigt__p_wxCustomDataObject,
40913 &_swigt__p_wxDC,
40914 &_swigt__p_wxDataFormat,
40915 &_swigt__p_wxDataObject,
40916 &_swigt__p_wxDataObjectComposite,
40917 &_swigt__p_wxDataObjectSimple,
40918 &_swigt__p_wxDateEvent,
40919 &_swigt__p_wxDateSpan,
40920 &_swigt__p_wxDateTime,
40921 &_swigt__p_wxDateTime__TimeZone,
40922 &_swigt__p_wxDisplay,
40923 &_swigt__p_wxDisplayChangedEvent,
40924 &_swigt__p_wxDropFilesEvent,
40925 &_swigt__p_wxDuplexMode,
40926 &_swigt__p_wxEraseEvent,
40927 &_swigt__p_wxEvent,
40928 &_swigt__p_wxEvtHandler,
40929 &_swigt__p_wxFSFile,
40930 &_swigt__p_wxFileConfig,
40931 &_swigt__p_wxFileDataObject,
40932 &_swigt__p_wxFileHistory,
40933 &_swigt__p_wxFileSystem,
40934 &_swigt__p_wxFileType,
40935 &_swigt__p_wxFileTypeInfo,
40936 &_swigt__p_wxFlexGridSizer,
40937 &_swigt__p_wxFocusEvent,
40938 &_swigt__p_wxFont,
40939 &_swigt__p_wxFrame,
40940 &_swigt__p_wxGBSizerItem,
40941 &_swigt__p_wxGIFHandler,
40942 &_swigt__p_wxGridBagSizer,
40943 &_swigt__p_wxGridSizer,
40944 &_swigt__p_wxICOHandler,
40945 &_swigt__p_wxIcon,
40946 &_swigt__p_wxIconizeEvent,
40947 &_swigt__p_wxIdleEvent,
40948 &_swigt__p_wxImage,
40949 &_swigt__p_wxImageHandler,
40950 &_swigt__p_wxIndividualLayoutConstraint,
40951 &_swigt__p_wxInitDialogEvent,
40952 &_swigt__p_wxJPEGHandler,
40953 &_swigt__p_wxJoystick,
40954 &_swigt__p_wxJoystickEvent,
40955 &_swigt__p_wxKeyEvent,
40956 &_swigt__p_wxKillError,
40957 &_swigt__p_wxLayoutConstraints,
40958 &_swigt__p_wxLog,
40959 &_swigt__p_wxLogBuffer,
40960 &_swigt__p_wxLogChain,
40961 &_swigt__p_wxLogGui,
40962 &_swigt__p_wxLogNull,
40963 &_swigt__p_wxLogStderr,
40964 &_swigt__p_wxLogTextCtrl,
40965 &_swigt__p_wxLogWindow,
40966 &_swigt__p_wxMaximizeEvent,
40967 &_swigt__p_wxMenu,
40968 &_swigt__p_wxMenuBar,
40969 &_swigt__p_wxMenuEvent,
40970 &_swigt__p_wxMenuItem,
40971 &_swigt__p_wxMetafile,
40972 &_swigt__p_wxMetafileDataObject,
40973 &_swigt__p_wxMimeTypesManager,
40974 &_swigt__p_wxMouseCaptureChangedEvent,
40975 &_swigt__p_wxMouseCaptureLostEvent,
40976 &_swigt__p_wxMouseEvent,
40977 &_swigt__p_wxMouseState,
40978 &_swigt__p_wxMoveEvent,
40979 &_swigt__p_wxMutexGuiLocker,
40980 &_swigt__p_wxNavigationKeyEvent,
40981 &_swigt__p_wxNcPaintEvent,
40982 &_swigt__p_wxNotifyEvent,
40983 &_swigt__p_wxObject,
40984 &_swigt__p_wxOutputStream,
40985 &_swigt__p_wxPCXHandler,
40986 &_swigt__p_wxPNGHandler,
40987 &_swigt__p_wxPNMHandler,
40988 &_swigt__p_wxPaintEvent,
40989 &_swigt__p_wxPaletteChangedEvent,
40990 &_swigt__p_wxPaperSize,
40991 &_swigt__p_wxPlatformInfo,
40992 &_swigt__p_wxPoint,
40993 &_swigt__p_wxPowerEvent,
40994 &_swigt__p_wxProcessEvent,
40995 &_swigt__p_wxPyApp,
40996 &_swigt__p_wxPyArtProvider,
40997 &_swigt__p_wxPyBitmapDataObject,
40998 &_swigt__p_wxPyCommandEvent,
40999 &_swigt__p_wxPyDataObjectSimple,
41000 &_swigt__p_wxPyDropSource,
41001 &_swigt__p_wxPyDropTarget,
41002 &_swigt__p_wxPyEvent,
41003 &_swigt__p_wxPyFileDropTarget,
41004 &_swigt__p_wxPyImageHandler,
41005 &_swigt__p_wxPyLog,
41006 &_swigt__p_wxPyProcess,
41007 &_swigt__p_wxPySizer,
41008 &_swigt__p_wxPyTextDataObject,
41009 &_swigt__p_wxPyTextDropTarget,
41010 &_swigt__p_wxPyTimer,
41011 &_swigt__p_wxPyTipProvider,
41012 &_swigt__p_wxPyValidator,
41013 &_swigt__p_wxQueryNewPaletteEvent,
41014 &_swigt__p_wxRect,
41015 &_swigt__p_wxScrollEvent,
41016 &_swigt__p_wxScrollWinEvent,
41017 &_swigt__p_wxSetCursorEvent,
41018 &_swigt__p_wxShowEvent,
41019 &_swigt__p_wxSingleInstanceChecker,
41020 &_swigt__p_wxSize,
41021 &_swigt__p_wxSizeEvent,
41022 &_swigt__p_wxSizer,
41023 &_swigt__p_wxSizerItem,
41024 &_swigt__p_wxSound,
41025 &_swigt__p_wxStandardPaths,
41026 &_swigt__p_wxStaticBoxSizer,
41027 &_swigt__p_wxStdDialogButtonSizer,
41028 &_swigt__p_wxStopWatch,
41029 &_swigt__p_wxString,
41030 &_swigt__p_wxSysColourChangedEvent,
41031 &_swigt__p_wxSystemOptions,
41032 &_swigt__p_wxSystemSettings,
41033 &_swigt__p_wxTGAHandler,
41034 &_swigt__p_wxTIFFHandler,
41035 &_swigt__p_wxTextCtrl,
41036 &_swigt__p_wxTextDataObject,
41037 &_swigt__p_wxTimeSpan,
41038 &_swigt__p_wxTimer,
41039 &_swigt__p_wxTimerEvent,
41040 &_swigt__p_wxTimerRunner,
41041 &_swigt__p_wxTipProvider,
41042 &_swigt__p_wxToolTip,
41043 &_swigt__p_wxURLDataObject,
41044 &_swigt__p_wxUpdateUIEvent,
41045 &_swigt__p_wxValidator,
41046 &_swigt__p_wxVideoMode,
41047 &_swigt__p_wxWindow,
41048 &_swigt__p_wxWindowCreateEvent,
41049 &_swigt__p_wxWindowDestroyEvent,
41050 &_swigt__p_wxWindowDisabler,
41051 &_swigt__p_wxXPMHandler,
41052 };
41053
41054 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
41055 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
41056 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
41057 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
41058 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
41059 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
41060 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
41061 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
41062 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
41063 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41064 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}};
41065 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41066 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41067 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41068 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41069 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41070 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41071 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41072 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41073 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}};
41074 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41075 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41076 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41077 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41078 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41079 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}};
41080 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41081 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}};
41082 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41083 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41084 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41085 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41086 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41087 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41088 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41089 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41090 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41091 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41092 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41093 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41094 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41095 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41096 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41097 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41098 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41099 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41100 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41101 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41102 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41103 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41104 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41105 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41106 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41107 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41108 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41109 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41110 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41111 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41112 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41113 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41114 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41115 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41116 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41117 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41118 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41119 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41120 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41121 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41122 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41123 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41124 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41125 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}};
41126 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41127 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41128 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41129 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41130 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41131 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41132 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}};
41133 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41134 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41135 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41136 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41137 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41138 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41139 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41140 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41141 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41142 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41143 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41144 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}};
41145 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41146 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41150 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41151 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41152 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41153 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
41154 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41157 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41158 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41159 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41160 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41161 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41162 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41163 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41164 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41165 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41166 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41167 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41168 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41169 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41170 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41171 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41172 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41173 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
41174 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41175 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41176 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41177 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41178 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41179 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41180 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41181 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41182 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41183 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41184 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41185 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41186 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41187 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41188 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41189 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
41190 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41191 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41192 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41193 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41194 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41195 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41196 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41197 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41198 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41199 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41200 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}};
41201 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41202 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41203 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41204 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41205 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41206 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41207 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41208 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41209 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41210 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41211 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41212 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41213 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41214 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41215 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41216 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41217 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41218 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}};
41219 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41220 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41221 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41222 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41223 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}};
41224 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41225 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41226 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41227 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}};
41228 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41229
41230 static swig_cast_info *swig_cast_initial[] = {
41231 _swigc__p_char,
41232 _swigc__p_form_ops_t,
41233 _swigc__p_int,
41234 _swigc__p_unsigned_char,
41235 _swigc__p_unsigned_int,
41236 _swigc__p_unsigned_long,
41237 _swigc__p_void,
41238 _swigc__p_wxANIHandler,
41239 _swigc__p_wxAboutDialogInfo,
41240 _swigc__p_wxAcceleratorTable,
41241 _swigc__p_wxActivateEvent,
41242 _swigc__p_wxArrayString,
41243 _swigc__p_wxBMPHandler,
41244 _swigc__p_wxBitmap,
41245 _swigc__p_wxBitmapDataObject,
41246 _swigc__p_wxBoxSizer,
41247 _swigc__p_wxBusyCursor,
41248 _swigc__p_wxBusyInfo,
41249 _swigc__p_wxCURHandler,
41250 _swigc__p_wxCaret,
41251 _swigc__p_wxChar,
41252 _swigc__p_wxChildFocusEvent,
41253 _swigc__p_wxClipboard,
41254 _swigc__p_wxClipboardLocker,
41255 _swigc__p_wxClipboardTextEvent,
41256 _swigc__p_wxCloseEvent,
41257 _swigc__p_wxColour,
41258 _swigc__p_wxCommandEvent,
41259 _swigc__p_wxConfig,
41260 _swigc__p_wxConfigBase,
41261 _swigc__p_wxConfigPathChanger,
41262 _swigc__p_wxContextMenuEvent,
41263 _swigc__p_wxControl,
41264 _swigc__p_wxControlWithItems,
41265 _swigc__p_wxCursor,
41266 _swigc__p_wxCustomDataObject,
41267 _swigc__p_wxDC,
41268 _swigc__p_wxDataFormat,
41269 _swigc__p_wxDataObject,
41270 _swigc__p_wxDataObjectComposite,
41271 _swigc__p_wxDataObjectSimple,
41272 _swigc__p_wxDateEvent,
41273 _swigc__p_wxDateSpan,
41274 _swigc__p_wxDateTime,
41275 _swigc__p_wxDateTime__TimeZone,
41276 _swigc__p_wxDisplay,
41277 _swigc__p_wxDisplayChangedEvent,
41278 _swigc__p_wxDropFilesEvent,
41279 _swigc__p_wxDuplexMode,
41280 _swigc__p_wxEraseEvent,
41281 _swigc__p_wxEvent,
41282 _swigc__p_wxEvtHandler,
41283 _swigc__p_wxFSFile,
41284 _swigc__p_wxFileConfig,
41285 _swigc__p_wxFileDataObject,
41286 _swigc__p_wxFileHistory,
41287 _swigc__p_wxFileSystem,
41288 _swigc__p_wxFileType,
41289 _swigc__p_wxFileTypeInfo,
41290 _swigc__p_wxFlexGridSizer,
41291 _swigc__p_wxFocusEvent,
41292 _swigc__p_wxFont,
41293 _swigc__p_wxFrame,
41294 _swigc__p_wxGBSizerItem,
41295 _swigc__p_wxGIFHandler,
41296 _swigc__p_wxGridBagSizer,
41297 _swigc__p_wxGridSizer,
41298 _swigc__p_wxICOHandler,
41299 _swigc__p_wxIcon,
41300 _swigc__p_wxIconizeEvent,
41301 _swigc__p_wxIdleEvent,
41302 _swigc__p_wxImage,
41303 _swigc__p_wxImageHandler,
41304 _swigc__p_wxIndividualLayoutConstraint,
41305 _swigc__p_wxInitDialogEvent,
41306 _swigc__p_wxJPEGHandler,
41307 _swigc__p_wxJoystick,
41308 _swigc__p_wxJoystickEvent,
41309 _swigc__p_wxKeyEvent,
41310 _swigc__p_wxKillError,
41311 _swigc__p_wxLayoutConstraints,
41312 _swigc__p_wxLog,
41313 _swigc__p_wxLogBuffer,
41314 _swigc__p_wxLogChain,
41315 _swigc__p_wxLogGui,
41316 _swigc__p_wxLogNull,
41317 _swigc__p_wxLogStderr,
41318 _swigc__p_wxLogTextCtrl,
41319 _swigc__p_wxLogWindow,
41320 _swigc__p_wxMaximizeEvent,
41321 _swigc__p_wxMenu,
41322 _swigc__p_wxMenuBar,
41323 _swigc__p_wxMenuEvent,
41324 _swigc__p_wxMenuItem,
41325 _swigc__p_wxMetafile,
41326 _swigc__p_wxMetafileDataObject,
41327 _swigc__p_wxMimeTypesManager,
41328 _swigc__p_wxMouseCaptureChangedEvent,
41329 _swigc__p_wxMouseCaptureLostEvent,
41330 _swigc__p_wxMouseEvent,
41331 _swigc__p_wxMouseState,
41332 _swigc__p_wxMoveEvent,
41333 _swigc__p_wxMutexGuiLocker,
41334 _swigc__p_wxNavigationKeyEvent,
41335 _swigc__p_wxNcPaintEvent,
41336 _swigc__p_wxNotifyEvent,
41337 _swigc__p_wxObject,
41338 _swigc__p_wxOutputStream,
41339 _swigc__p_wxPCXHandler,
41340 _swigc__p_wxPNGHandler,
41341 _swigc__p_wxPNMHandler,
41342 _swigc__p_wxPaintEvent,
41343 _swigc__p_wxPaletteChangedEvent,
41344 _swigc__p_wxPaperSize,
41345 _swigc__p_wxPlatformInfo,
41346 _swigc__p_wxPoint,
41347 _swigc__p_wxPowerEvent,
41348 _swigc__p_wxProcessEvent,
41349 _swigc__p_wxPyApp,
41350 _swigc__p_wxPyArtProvider,
41351 _swigc__p_wxPyBitmapDataObject,
41352 _swigc__p_wxPyCommandEvent,
41353 _swigc__p_wxPyDataObjectSimple,
41354 _swigc__p_wxPyDropSource,
41355 _swigc__p_wxPyDropTarget,
41356 _swigc__p_wxPyEvent,
41357 _swigc__p_wxPyFileDropTarget,
41358 _swigc__p_wxPyImageHandler,
41359 _swigc__p_wxPyLog,
41360 _swigc__p_wxPyProcess,
41361 _swigc__p_wxPySizer,
41362 _swigc__p_wxPyTextDataObject,
41363 _swigc__p_wxPyTextDropTarget,
41364 _swigc__p_wxPyTimer,
41365 _swigc__p_wxPyTipProvider,
41366 _swigc__p_wxPyValidator,
41367 _swigc__p_wxQueryNewPaletteEvent,
41368 _swigc__p_wxRect,
41369 _swigc__p_wxScrollEvent,
41370 _swigc__p_wxScrollWinEvent,
41371 _swigc__p_wxSetCursorEvent,
41372 _swigc__p_wxShowEvent,
41373 _swigc__p_wxSingleInstanceChecker,
41374 _swigc__p_wxSize,
41375 _swigc__p_wxSizeEvent,
41376 _swigc__p_wxSizer,
41377 _swigc__p_wxSizerItem,
41378 _swigc__p_wxSound,
41379 _swigc__p_wxStandardPaths,
41380 _swigc__p_wxStaticBoxSizer,
41381 _swigc__p_wxStdDialogButtonSizer,
41382 _swigc__p_wxStopWatch,
41383 _swigc__p_wxString,
41384 _swigc__p_wxSysColourChangedEvent,
41385 _swigc__p_wxSystemOptions,
41386 _swigc__p_wxSystemSettings,
41387 _swigc__p_wxTGAHandler,
41388 _swigc__p_wxTIFFHandler,
41389 _swigc__p_wxTextCtrl,
41390 _swigc__p_wxTextDataObject,
41391 _swigc__p_wxTimeSpan,
41392 _swigc__p_wxTimer,
41393 _swigc__p_wxTimerEvent,
41394 _swigc__p_wxTimerRunner,
41395 _swigc__p_wxTipProvider,
41396 _swigc__p_wxToolTip,
41397 _swigc__p_wxURLDataObject,
41398 _swigc__p_wxUpdateUIEvent,
41399 _swigc__p_wxValidator,
41400 _swigc__p_wxVideoMode,
41401 _swigc__p_wxWindow,
41402 _swigc__p_wxWindowCreateEvent,
41403 _swigc__p_wxWindowDestroyEvent,
41404 _swigc__p_wxWindowDisabler,
41405 _swigc__p_wxXPMHandler,
41406 };
41407
41408
41409 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41410
41411 static swig_const_info swig_const_table[] = {
41412 {0, 0, 0, 0.0, 0, 0}};
41413
41414 #ifdef __cplusplus
41415 }
41416 #endif
41417 /* -----------------------------------------------------------------------------
41418 * Type initialization:
41419 * This problem is tough by the requirement that no dynamic
41420 * memory is used. Also, since swig_type_info structures store pointers to
41421 * swig_cast_info structures and swig_cast_info structures store pointers back
41422 * to swig_type_info structures, we need some lookup code at initialization.
41423 * The idea is that swig generates all the structures that are needed.
41424 * The runtime then collects these partially filled structures.
41425 * The SWIG_InitializeModule function takes these initial arrays out of
41426 * swig_module, and does all the lookup, filling in the swig_module.types
41427 * array with the correct data and linking the correct swig_cast_info
41428 * structures together.
41429 *
41430 * The generated swig_type_info structures are assigned staticly to an initial
41431 * array. We just loop though that array, and handle each type individually.
41432 * First we lookup if this type has been already loaded, and if so, use the
41433 * loaded structure instead of the generated one. Then we have to fill in the
41434 * cast linked list. The cast data is initially stored in something like a
41435 * two-dimensional array. Each row corresponds to a type (there are the same
41436 * number of rows as there are in the swig_type_initial array). Each entry in
41437 * a column is one of the swig_cast_info structures for that type.
41438 * The cast_initial array is actually an array of arrays, because each row has
41439 * a variable number of columns. So to actually build the cast linked list,
41440 * we find the array of casts associated with the type, and loop through it
41441 * adding the casts to the list. The one last trick we need to do is making
41442 * sure the type pointer in the swig_cast_info struct is correct.
41443 *
41444 * First off, we lookup the cast->type name to see if it is already loaded.
41445 * There are three cases to handle:
41446 * 1) If the cast->type has already been loaded AND the type we are adding
41447 * casting info to has not been loaded (it is in this module), THEN we
41448 * replace the cast->type pointer with the type pointer that has already
41449 * been loaded.
41450 * 2) If BOTH types (the one we are adding casting info to, and the
41451 * cast->type) are loaded, THEN the cast info has already been loaded by
41452 * the previous module so we just ignore it.
41453 * 3) Finally, if cast->type has not already been loaded, then we add that
41454 * swig_cast_info to the linked list (because the cast->type) pointer will
41455 * be correct.
41456 * ----------------------------------------------------------------------------- */
41457
41458 #ifdef __cplusplus
41459 extern "C" {
41460 #if 0
41461 } /* c-mode */
41462 #endif
41463 #endif
41464
41465 #if 0
41466 #define SWIGRUNTIME_DEBUG
41467 #endif
41468
41469 SWIGRUNTIME void
41470 SWIG_InitializeModule(void *clientdata) {
41471 size_t i;
41472 swig_module_info *module_head;
41473 static int init_run = 0;
41474
41475 clientdata = clientdata;
41476
41477 if (init_run) return;
41478 init_run = 1;
41479
41480 /* Initialize the swig_module */
41481 swig_module.type_initial = swig_type_initial;
41482 swig_module.cast_initial = swig_cast_initial;
41483
41484 /* Try and load any already created modules */
41485 module_head = SWIG_GetModule(clientdata);
41486 if (module_head) {
41487 swig_module.next = module_head->next;
41488 module_head->next = &swig_module;
41489 } else {
41490 /* This is the first module loaded */
41491 swig_module.next = &swig_module;
41492 SWIG_SetModule(clientdata, &swig_module);
41493 }
41494
41495 /* Now work on filling in swig_module.types */
41496 #ifdef SWIGRUNTIME_DEBUG
41497 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41498 #endif
41499 for (i = 0; i < swig_module.size; ++i) {
41500 swig_type_info *type = 0;
41501 swig_type_info *ret;
41502 swig_cast_info *cast;
41503
41504 #ifdef SWIGRUNTIME_DEBUG
41505 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41506 #endif
41507
41508 /* if there is another module already loaded */
41509 if (swig_module.next != &swig_module) {
41510 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41511 }
41512 if (type) {
41513 /* Overwrite clientdata field */
41514 #ifdef SWIGRUNTIME_DEBUG
41515 printf("SWIG_InitializeModule: found type %s\n", type->name);
41516 #endif
41517 if (swig_module.type_initial[i]->clientdata) {
41518 type->clientdata = swig_module.type_initial[i]->clientdata;
41519 #ifdef SWIGRUNTIME_DEBUG
41520 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41521 #endif
41522 }
41523 } else {
41524 type = swig_module.type_initial[i];
41525 }
41526
41527 /* Insert casting types */
41528 cast = swig_module.cast_initial[i];
41529 while (cast->type) {
41530 /* Don't need to add information already in the list */
41531 ret = 0;
41532 #ifdef SWIGRUNTIME_DEBUG
41533 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41534 #endif
41535 if (swig_module.next != &swig_module) {
41536 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41537 #ifdef SWIGRUNTIME_DEBUG
41538 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41539 #endif
41540 }
41541 if (ret) {
41542 if (type == swig_module.type_initial[i]) {
41543 #ifdef SWIGRUNTIME_DEBUG
41544 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41545 #endif
41546 cast->type = ret;
41547 ret = 0;
41548 } else {
41549 /* Check for casting already in the list */
41550 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41551 #ifdef SWIGRUNTIME_DEBUG
41552 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41553 #endif
41554 if (!ocast) ret = 0;
41555 }
41556 }
41557
41558 if (!ret) {
41559 #ifdef SWIGRUNTIME_DEBUG
41560 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41561 #endif
41562 if (type->cast) {
41563 type->cast->prev = cast;
41564 cast->next = type->cast;
41565 }
41566 type->cast = cast;
41567 }
41568 cast++;
41569 }
41570 /* Set entry in modules->types array equal to the type */
41571 swig_module.types[i] = type;
41572 }
41573 swig_module.types[i] = 0;
41574
41575 #ifdef SWIGRUNTIME_DEBUG
41576 printf("**** SWIG_InitializeModule: Cast List ******\n");
41577 for (i = 0; i < swig_module.size; ++i) {
41578 int j = 0;
41579 swig_cast_info *cast = swig_module.cast_initial[i];
41580 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41581 while (cast->type) {
41582 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41583 cast++;
41584 ++j;
41585 }
41586 printf("---- Total casts: %d\n",j);
41587 }
41588 printf("**** SWIG_InitializeModule: Cast List ******\n");
41589 #endif
41590 }
41591
41592 /* This function will propagate the clientdata field of type to
41593 * any new swig_type_info structures that have been added into the list
41594 * of equivalent types. It is like calling
41595 * SWIG_TypeClientData(type, clientdata) a second time.
41596 */
41597 SWIGRUNTIME void
41598 SWIG_PropagateClientData(void) {
41599 size_t i;
41600 swig_cast_info *equiv;
41601 static int init_run = 0;
41602
41603 if (init_run) return;
41604 init_run = 1;
41605
41606 for (i = 0; i < swig_module.size; i++) {
41607 if (swig_module.types[i]->clientdata) {
41608 equiv = swig_module.types[i]->cast;
41609 while (equiv) {
41610 if (!equiv->converter) {
41611 if (equiv->type && !equiv->type->clientdata)
41612 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41613 }
41614 equiv = equiv->next;
41615 }
41616 }
41617 }
41618 }
41619
41620 #ifdef __cplusplus
41621 #if 0
41622 {
41623 /* c-mode */
41624 #endif
41625 }
41626 #endif
41627
41628
41629
41630 #ifdef __cplusplus
41631 extern "C" {
41632 #endif
41633
41634 /* Python-specific SWIG API */
41635 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41636 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41637 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41638
41639 /* -----------------------------------------------------------------------------
41640 * global variable support code.
41641 * ----------------------------------------------------------------------------- */
41642
41643 typedef struct swig_globalvar {
41644 char *name; /* Name of global variable */
41645 PyObject *(*get_attr)(void); /* Return the current value */
41646 int (*set_attr)(PyObject *); /* Set the value */
41647 struct swig_globalvar *next;
41648 } swig_globalvar;
41649
41650 typedef struct swig_varlinkobject {
41651 PyObject_HEAD
41652 swig_globalvar *vars;
41653 } swig_varlinkobject;
41654
41655 SWIGINTERN PyObject *
41656 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41657 return PyString_FromString("<Swig global variables>");
41658 }
41659
41660 SWIGINTERN PyObject *
41661 swig_varlink_str(swig_varlinkobject *v) {
41662 PyObject *str = PyString_FromString("(");
41663 swig_globalvar *var;
41664 for (var = v->vars; var; var=var->next) {
41665 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41666 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41667 }
41668 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41669 return str;
41670 }
41671
41672 SWIGINTERN int
41673 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41674 PyObject *str = swig_varlink_str(v);
41675 fprintf(fp,"Swig global variables ");
41676 fprintf(fp,"%s\n", PyString_AsString(str));
41677 Py_DECREF(str);
41678 return 0;
41679 }
41680
41681 SWIGINTERN void
41682 swig_varlink_dealloc(swig_varlinkobject *v) {
41683 swig_globalvar *var = v->vars;
41684 while (var) {
41685 swig_globalvar *n = var->next;
41686 free(var->name);
41687 free(var);
41688 var = n;
41689 }
41690 }
41691
41692 SWIGINTERN PyObject *
41693 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41694 PyObject *res = NULL;
41695 swig_globalvar *var = v->vars;
41696 while (var) {
41697 if (strcmp(var->name,n) == 0) {
41698 res = (*var->get_attr)();
41699 break;
41700 }
41701 var = var->next;
41702 }
41703 if (res == NULL && !PyErr_Occurred()) {
41704 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41705 }
41706 return res;
41707 }
41708
41709 SWIGINTERN int
41710 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41711 int res = 1;
41712 swig_globalvar *var = v->vars;
41713 while (var) {
41714 if (strcmp(var->name,n) == 0) {
41715 res = (*var->set_attr)(p);
41716 break;
41717 }
41718 var = var->next;
41719 }
41720 if (res == 1 && !PyErr_Occurred()) {
41721 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41722 }
41723 return res;
41724 }
41725
41726 SWIGINTERN PyTypeObject*
41727 swig_varlink_type(void) {
41728 static char varlink__doc__[] = "Swig var link object";
41729 static PyTypeObject varlink_type;
41730 static int type_init = 0;
41731 if (!type_init) {
41732 const PyTypeObject tmp
41733 = {
41734 PyObject_HEAD_INIT(NULL)
41735 0, /* Number of items in variable part (ob_size) */
41736 (char *)"swigvarlink", /* Type name (tp_name) */
41737 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41738 0, /* Itemsize (tp_itemsize) */
41739 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41740 (printfunc) swig_varlink_print, /* Print (tp_print) */
41741 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41742 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41743 0, /* tp_compare */
41744 (reprfunc) swig_varlink_repr, /* tp_repr */
41745 0, /* tp_as_number */
41746 0, /* tp_as_sequence */
41747 0, /* tp_as_mapping */
41748 0, /* tp_hash */
41749 0, /* tp_call */
41750 (reprfunc)swig_varlink_str, /* tp_str */
41751 0, /* tp_getattro */
41752 0, /* tp_setattro */
41753 0, /* tp_as_buffer */
41754 0, /* tp_flags */
41755 varlink__doc__, /* tp_doc */
41756 0, /* tp_traverse */
41757 0, /* tp_clear */
41758 0, /* tp_richcompare */
41759 0, /* tp_weaklistoffset */
41760 #if PY_VERSION_HEX >= 0x02020000
41761 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41762 #endif
41763 #if PY_VERSION_HEX >= 0x02030000
41764 0, /* tp_del */
41765 #endif
41766 #ifdef COUNT_ALLOCS
41767 0,0,0,0 /* tp_alloc -> tp_next */
41768 #endif
41769 };
41770 varlink_type = tmp;
41771 varlink_type.ob_type = &PyType_Type;
41772 type_init = 1;
41773 }
41774 return &varlink_type;
41775 }
41776
41777 /* Create a variable linking object for use later */
41778 SWIGINTERN PyObject *
41779 SWIG_Python_newvarlink(void) {
41780 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41781 if (result) {
41782 result->vars = 0;
41783 }
41784 return ((PyObject*) result);
41785 }
41786
41787 SWIGINTERN void
41788 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41789 swig_varlinkobject *v = (swig_varlinkobject *) p;
41790 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41791 if (gv) {
41792 size_t size = strlen(name)+1;
41793 gv->name = (char *)malloc(size);
41794 if (gv->name) {
41795 strncpy(gv->name,name,size);
41796 gv->get_attr = get_attr;
41797 gv->set_attr = set_attr;
41798 gv->next = v->vars;
41799 }
41800 }
41801 v->vars = gv;
41802 }
41803
41804 SWIGINTERN PyObject *
41805 SWIG_globals() {
41806 static PyObject *_SWIG_globals = 0;
41807 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41808 return _SWIG_globals;
41809 }
41810
41811 /* -----------------------------------------------------------------------------
41812 * constants/methods manipulation
41813 * ----------------------------------------------------------------------------- */
41814
41815 /* Install Constants */
41816 SWIGINTERN void
41817 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41818 PyObject *obj = 0;
41819 size_t i;
41820 for (i = 0; constants[i].type; ++i) {
41821 switch(constants[i].type) {
41822 case SWIG_PY_POINTER:
41823 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41824 break;
41825 case SWIG_PY_BINARY:
41826 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41827 break;
41828 default:
41829 obj = 0;
41830 break;
41831 }
41832 if (obj) {
41833 PyDict_SetItemString(d, constants[i].name, obj);
41834 Py_DECREF(obj);
41835 }
41836 }
41837 }
41838
41839 /* -----------------------------------------------------------------------------*/
41840 /* Fix SwigMethods to carry the callback ptrs when needed */
41841 /* -----------------------------------------------------------------------------*/
41842
41843 SWIGINTERN void
41844 SWIG_Python_FixMethods(PyMethodDef *methods,
41845 swig_const_info *const_table,
41846 swig_type_info **types,
41847 swig_type_info **types_initial) {
41848 size_t i;
41849 for (i = 0; methods[i].ml_name; ++i) {
41850 const char *c = methods[i].ml_doc;
41851 if (c && (c = strstr(c, "swig_ptr: "))) {
41852 int j;
41853 swig_const_info *ci = 0;
41854 const char *name = c + 10;
41855 for (j = 0; const_table[j].type; ++j) {
41856 if (strncmp(const_table[j].name, name,
41857 strlen(const_table[j].name)) == 0) {
41858 ci = &(const_table[j]);
41859 break;
41860 }
41861 }
41862 if (ci) {
41863 size_t shift = (ci->ptype) - types;
41864 swig_type_info *ty = types_initial[shift];
41865 size_t ldoc = (c - methods[i].ml_doc);
41866 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41867 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41868 if (ndoc) {
41869 char *buff = ndoc;
41870 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41871 if (ptr) {
41872 strncpy(buff, methods[i].ml_doc, ldoc);
41873 buff += ldoc;
41874 strncpy(buff, "swig_ptr: ", 10);
41875 buff += 10;
41876 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41877 methods[i].ml_doc = ndoc;
41878 }
41879 }
41880 }
41881 }
41882 }
41883 }
41884
41885 #ifdef __cplusplus
41886 }
41887 #endif
41888
41889 /* -----------------------------------------------------------------------------*
41890 * Partial Init method
41891 * -----------------------------------------------------------------------------*/
41892
41893 #ifdef __cplusplus
41894 extern "C"
41895 #endif
41896 SWIGEXPORT void SWIG_init(void) {
41897 PyObject *m, *d;
41898
41899 /* Fix SwigMethods to carry the callback ptrs when needed */
41900 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41901
41902 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41903 d = PyModule_GetDict(m);
41904
41905 SWIG_InitializeModule(0);
41906 SWIG_InstallConstants(d,swig_const_table);
41907
41908
41909 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41910 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41911 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41912 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41913 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41914 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41915 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
41916 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
41917 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
41918 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
41919 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
41920 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
41921 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
41922 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
41923 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
41924 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
41925 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
41926 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
41927 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
41928 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
41929 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
41930 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
41931 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
41932 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
41933 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
41934 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
41935 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
41936 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
41937 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
41938 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
41939 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
41940 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
41941 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
41942 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
41943 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
41944 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
41945 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
41946 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
41947 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
41948 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
41949 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
41950 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
41951 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
41952 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
41953 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
41954 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
41955 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
41956 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
41957 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
41958 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
41959 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
41960 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
41961 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
41962 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
41963 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
41964 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
41965 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
41966 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
41967 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
41968 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
41969 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
41970 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
41971 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
41972 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
41973 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
41974 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
41975 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
41976 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
41977 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
41978 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
41979 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
41980 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
41981 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
41982 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
41983 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
41984 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
41985 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
41986 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
41987 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
41988 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
41989 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
41990 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
41991 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
41992 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
41993 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
41994 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
41995 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
41996 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
41997 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
41998 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
41999 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
42000 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
42001 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
42002 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
42003 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
42004 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
42005 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
42006 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
42007 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
42008 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
42009 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
42010 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
42011 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
42012 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
42013 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
42014 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
42015 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
42016 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
42017 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
42018 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
42019 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
42020 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
42021 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
42022 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
42023 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
42024 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
42025 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
42026 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
42027 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
42028 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
42029 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
42030 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
42031 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
42032 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
42033 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
42034 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
42035 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
42036 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
42037 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
42038 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
42039 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
42040 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
42041 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
42042 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
42043 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
42044 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
42045 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
42046 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
42047 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
42048 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
42049 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
42050 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
42051 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
42052 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
42053 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
42054 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
42055 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
42056 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
42057
42058 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
42059
42060 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
42061 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
42062 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
42063 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
42064 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
42065 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42066 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42067 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42068 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42069 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42070 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42071 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42072 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42073 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42074 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42075 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42076 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42077 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42078 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42079 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42080 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42081 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42082 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42083 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42084 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42085 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42086 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42087 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42088 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42089 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42090 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42091 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42092 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42093 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42094 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42095 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42096 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42097 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42098 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42099 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42100 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42101 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42102 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42103 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42104 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42105 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42106 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42107 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42108 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42109 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42110 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42111 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42112 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42113
42114 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42115
42116 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42117 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42118 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42119 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42120 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42121 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42122 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42123 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42124 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42125 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42126 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42127 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42128 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42129 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42130 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42131 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42132 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42133 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42134 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42135 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42136 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42137 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42138 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42139 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42140 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42141 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42142 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42143 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42144 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42145 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42146 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42147 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42148 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42149 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42150 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42151 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42152 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42153 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42154 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42155 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42156 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42157 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42158 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42159 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42160 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42161 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42162 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42163 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42164 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42165 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42166 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42167 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42168 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42169 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42170 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42171 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42172 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42173 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42174 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42175 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42176 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42177 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42178 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42179 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42180 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42181 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42182 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42183 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42184 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42185 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42186 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42187 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42188 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42189 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42190 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42191 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42192
42193 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42194
42195 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42196 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42197 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42198 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42199 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42200 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42201 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42202 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42203 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42204 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42205 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42206 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42207 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42208 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42209 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42210 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42211 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42212 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42213 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42214 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42215 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42216 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42217 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42218 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42219 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42220 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42221 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42222 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42223 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42224 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42225 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42226 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42227 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42228 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42229 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42230 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42231 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42232 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42233 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42234 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42235 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42236 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42237 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42238 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42239 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42240 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42241 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42242 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42243 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42244 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42245 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42246 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42247 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42248 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42249 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42250 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42251 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42252 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42253 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42254 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42255 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42256 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42257 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42258 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42259 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42260 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42261 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42262 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42263 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42264 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42265 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42266 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42267 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42268 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42269 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42270 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42271 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42272 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42273 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42274 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42275 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42276 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42277 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42278 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42279 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42280 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42281 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42282 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42283 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42284 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42285 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42286 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42287 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42288 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42289 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42290 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42291 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42292 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42293 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42294 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42295 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42296 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42297 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42298 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42299 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42300 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42301 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42302 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42303 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42304 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42305 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42306 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42307 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42308 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42309 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42310 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42311 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42312 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42313 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42314 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42315 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42316 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42317 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42318 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42319 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42320 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42321 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42322 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42323 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42324 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42325 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42326 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42327 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42328 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42329 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42330 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42331 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42332 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42333 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42334 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42335 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42336 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42337 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42338 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42339 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42340 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42341 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42342 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42343 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42344 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42345 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42346 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42347 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42348 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42349 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42350 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42351 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42352 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42353 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42354 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42355 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42356 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42357 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42358 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42359 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42360 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42361 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42362 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42363 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42364 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42365 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42366 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42367 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42368 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42369 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42370 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42371 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42372 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42373 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42374 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42375 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42376 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42377 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42378 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42379 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42380 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42381 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42382 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42383 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42384 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42385 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42386 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42387 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42388 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42389 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42390 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42391 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42392 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42393 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42394 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42395 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42396 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42397 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42398
42399 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42400 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42401 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42402 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42403
42404 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42405 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42406 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42407 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42408 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42409 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42410 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42411 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42412 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42413 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42414 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42415 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42416 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42417 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42418 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42419 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42420 }
42421
wxWidgets (Impactor)